/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.commons.io;
  
  import java.io.File;
  import java.util.ArrayDeque;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Deque;
  import java.util.List;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  import java.util.stream.Stream;
  
  /**
   * General file name and file path manipulation utilities. The methods in this class
   * operate on strings that represent relative or absolute paths. Nothing in this class
   * ever accesses the file system, or depends on whether a path points to a file that exists.
   * <p>
   * When dealing with file names, you can hit problems when moving from a Windows
   * based development machine to a Unix based production machine.
   * This class aims to help avoid those problems.
   * </p>
   * <p>
   * <strong>NOTE</strong>: You may be able to avoid using this class entirely simply by
   * using JDK {@link File File} objects and the two argument constructor
   * {@link File#File(java.io.File, String) File(File,String)}.
   * </p>
   * <p>
   * Most methods in this class are designed to work the same on both Unix and Windows.
   * Those that don't include 'System', 'Unix', or 'Windows' in their name.
   * </p>
   * <p>
   * Most methods recognize both separators (forward and backslashes), and both
   * sets of prefixes. See the Javadoc of each method for details.
   * </p>
   * <p>
   * This class defines six components within a path (sometimes called a file name or a full file name).
   * Given an absolute Windows path such as C:\dev\project\file.txt they are:
   * </p>
   * <ul>
   * <li>the full file name, or just file name - C:\dev\project\file.txt</li>
   * <li>the prefix - C:\</li>
   * <li>the path - dev\project\</li>
   * <li>the full path - C:\dev\project\</li>
   * <li>the name - file.txt</li>
   * <li>the base name - file</li>
   * <li>the extension - txt</li>
   * </ul>
   * <p>
   * Given an absolute Unix path such as /dev/project/file.txt they are:
   * </p>
   * <ul>
   * <li>the full file name, or just file name - /dev/project/file.txt</li>
   * <li>the prefix - /</li>
   * <li>the path - dev/project</li>
   * <li>the full path - /dev/project</li>
   * <li>the name - file.txt</li>
   * <li>the base name - file</li>
   * <li>the extension - txt</li>
   * </ul>
   * <p>
   * Given a relative Windows path such as dev\project\file.txt they are:
   * </p>
   * <ul>
   * <li>the full file name, or just file name - dev\project\file.txt</li>
   * <li>the prefix - null</li>
   * <li>the path - dev\project\</li>
   * <li>the full path - dev\project\</li>
   * <li>the name - file.txt</li>
   * <li>the base name - file</li>
   * <li>the extension - txt</li>
   * </ul>
   * <p>
   * Given an absolute Unix path such as /dev/project/file.txt they are:
   * </p>
   * <ul>
   * <li>the full path, full file name, or just file name - /dev/project/file.txt</li>
   * <li>the prefix - /</li>
   * <li>the path - dev/project</li>
   * <li>the full path - /dev/project</li>
   * <li>the name - file.txt</li>
   * <li>the base name - file</li>
   * <li>the extension - txt</li>
  * </ul>
  *
  *
  * <p>
  * This class works best if directory names end with a separator.
  * If you omit the last separator, it is impossible to determine if the last component
  * corresponds to a file or a directory. This class treats final components
  * that do not end with a separator as files, not directories.
  * </p>
  * <p>
  * This class only supports Unix and Windows style names.
  * Prefixes are matched as follows:
  * </p>
  * <pre>
  * Windows:
  * a\b\c.txt           --&gt; ""          --&gt; relative
  * \a\b\c.txt          --&gt; "\"         --&gt; current drive absolute
  * C:a\b\c.txt         --&gt; "C:"        --&gt; drive relative
  * C:\a\b\c.txt        --&gt; "C:\"       --&gt; absolute
  * \\server\a\b\c.txt  --&gt; "\\server\" --&gt; UNC
  *
  * Unix:
  * a/b/c.txt           --&gt; ""          --&gt; relative
  * /a/b/c.txt          --&gt; "/"         --&gt; absolute
  * ~/a/b/c.txt         --&gt; "~/"        --&gt; current user
  * ~                   --&gt; "~/"        --&gt; current user (slash added)
  * ~user/a/b/c.txt     --&gt; "~user/"    --&gt; named user
  * ~user               --&gt; "~user/"    --&gt; named user (slash added)
  * </pre>
  * <p>
  * Both prefix styles are matched, irrespective of the machine that you are
  * currently running on.
  * </p>
  *
  * @since 1.1
  */
 public class FilenameUtils {
 
     private static final String[] EMPTY_STRING_ARRAY = {};
 
     private static final String EMPTY_STRING = "";
 
     private static final int NOT_FOUND = -1;
 
     /**
      * The extension separator character.
      * @since 1.4
      */
     public static final char EXTENSION_SEPARATOR = '.';
 
     /**
      * The extension separator String.
      * @since 1.4
      */
     public static final String EXTENSION_SEPARATOR_STR = Character.toString(EXTENSION_SEPARATOR);
 
     /**
      * The Unix separator character.
      */
     private static final char UNIX_NAME_SEPARATOR = '/';
 
     /**
      * The Windows separator character.
      */
     private static final char WINDOWS_NAME_SEPARATOR = '\\';
 
     /**
      * The system separator character.
      */
     private static final char SYSTEM_NAME_SEPARATOR = File.separatorChar;
 
     /**
      * The separator character that is the opposite of the system separator.
      */
     private static final char OTHER_SEPARATOR = flipSeparator(SYSTEM_NAME_SEPARATOR);
 
     private static final Pattern IPV4_PATTERN = Pattern.compile("^(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})$");
 
     private static final int IPV4_MAX_OCTET_VALUE = 255;
 
     private static final int IPV6_MAX_HEX_GROUPS = 8;
 
     private static final int IPV6_MAX_HEX_DIGITS_PER_GROUP = 4;
 
     private static final int MAX_UNSIGNED_SHORT = 0xffff;
 
     private static final int BASE_16 = 16;
 
     private static final Pattern REG_NAME_PART_PATTERN = Pattern.compile("^[a-zA-Z0-9][a-zA-Z0-9-]*$");
 
     /**
      * Concatenates a fileName to a base path using normal command line style rules.
      * <p>
      * The effect is equivalent to resultant directory after changing
      * directory to the first argument, followed by changing directory to
      * the second argument.
      * </p>
      * <p>
      * The first argument is the base path, the second is the path to concatenate.
      * The returned path is always normalized via {@link #normalize(String)},
      * thus {@code ..} is handled.
      * </p>
      * <p>
      * If {@code pathToAdd} is absolute (has an absolute prefix), then
      * it will be normalized and returned.
      * Otherwise, the paths will be joined, normalized and returned.
      * </p>
      * <p>
      * The output will be the same on both Unix and Windows except
      * for the separator character.
      * </p>
      * <pre>
      * /foo/      + bar        --&gt;  /foo/bar
      * /foo       + bar        --&gt;  /foo/bar
      * /foo       + /bar       --&gt;  /bar
      * /foo       + C:/bar     --&gt;  C:/bar
      * /foo       + C:bar      --&gt;  C:bar [1]
      * /foo/a/    + ../bar     --&gt;  /foo/bar
      * /foo/      + ../../bar  --&gt;  null
      * /foo/      + /bar       --&gt;  /bar
      * /foo/..    + /bar       --&gt;  /bar
      * /foo       + bar/c.txt  --&gt;  /foo/bar/c.txt
      * /foo/c.txt + bar        --&gt;  /foo/c.txt/bar [2]
      * </pre>
      * <p>
      * [1] Note that the Windows relative drive prefix is unreliable when
      * used with this method.
      * </p>
      * <p>
      * [2] Note that the first parameter must be a path. If it ends with a name, then
      * the name will be built into the concatenated path. If this might be a problem,
      * use {@link #getFullPath(String)} on the base path argument.
      * </p>
      *
      * @param basePath  the base path to attach to, always treated as a path
      * @param fullFileNameToAdd  the file name (or path) to attach to the base
      * @return the concatenated path, or null if invalid
      * @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
      */
     public static String concat(final String basePath, final String fullFileNameToAdd) {
         final int prefix = getPrefixLength(fullFileNameToAdd);
         if (prefix < 0) {
             return null;
         }
         if (prefix > 0) {
             return normalize(fullFileNameToAdd);
         }
         if (basePath == null) {
             return null;
         }
         final int len = basePath.length();
         if (len == 0) {
             return normalize(fullFileNameToAdd);
         }
         final char ch = basePath.charAt(len - 1);
         if (isSeparator(ch)) {
             return normalize(basePath + fullFileNameToAdd);
         }
         return normalize(basePath + '/' + fullFileNameToAdd);
     }
 
     /**
      * Determines whether the {@code parent} directory contains the {@code child} (a file or directory).
      * This does not read from the file system, and there is no guarantee or expectation that
      * these paths actually exist.
      * <p>
      * The files names are expected to be normalized.
      * </p>
      *
      * Edge cases:
      * <ul>
      * <li>A {@code directory} must not be null: if null, throw IllegalArgumentException</li>
      * <li>A directory does not contain itself: return false</li>
      * <li>A null child file is not contained in any parent: return false</li>
      * </ul>
      *
      * @param canonicalParent the path string to consider as the parent.
      * @param canonicalChild the path string to consider as the child.
      * @return true if the candidate leaf is under the specified composite. False otherwise.
      * @since 2.2
      * @see FileUtils#directoryContains(File, File)
      */
     public static boolean directoryContains(final String canonicalParent, final String canonicalChild) {
         if (isEmpty(canonicalParent) || isEmpty(canonicalChild)) {
             return false;
         }
 
         if (IOCase.SYSTEM.checkEquals(canonicalParent, canonicalChild)) {
             return false;
         }
 
         final char separator = toSeparator(canonicalParent.charAt(0) == UNIX_NAME_SEPARATOR);
         final String parentWithEndSeparator = canonicalParent.charAt(canonicalParent.length() - 1) == separator ? canonicalParent : canonicalParent + separator;
 
         return IOCase.SYSTEM.checkStartsWith(canonicalChild, parentWithEndSeparator);
     }
 
     /**
      * Does the work of getting the path.
      *
      * @param fileName  the file name
      * @param includeSeparator  true to include the end separator
      * @return the path
      * @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
      */
     private static String doGetFullPath(final String fileName, final boolean includeSeparator) {
         if (fileName == null) {
             return null;
         }
         final int prefix = getPrefixLength(fileName);
         if (prefix < 0) {
             return null;
         }
         if (prefix >= fileName.length()) {
             if (includeSeparator) {
                 return getPrefix(fileName);  // add end slash if necessary
             }
             return fileName;
         }
         final int index = indexOfLastSeparator(fileName);
         if (index < 0) {
             return fileName.substring(0, prefix);
         }
         int end = index + (includeSeparator ?  1 : 0);
         if (end == 0) {
             end++;
         }
         return fileName.substring(0, end);
     }
 
     /**
      * Does the work of getting the path.
      *
      * @param fileName  the file name
      * @param separatorAdd  0 to omit the end separator, 1 to return it
      * @return the path
      * @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
      */
     private static String doGetPath(final String fileName, final int separatorAdd) {
         if (fileName == null) {
             return null;
         }
         final int prefix = getPrefixLength(fileName);
         if (prefix < 0) {
             return null;
         }
         final int index = indexOfLastSeparator(fileName);
         final int endIndex = index + separatorAdd;
         if (prefix >= fileName.length() || index < 0 || prefix >= endIndex) {
             return EMPTY_STRING;
         }
         return requireNonNullChars(fileName.substring(prefix, endIndex));
     }
 
     /**
      * Internal method to perform the normalization.
      *
      * @param fileName  the file name
      * @param separator The separator character to use
      * @param keepSeparator  true to keep the final separator
      * @return the normalized fileName
      * @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
      */
     private static String doNormalize(final String fileName, final char separator, final boolean keepSeparator) {
         if (fileName == null) {
             return null;
         }
 
         requireNonNullChars(fileName);
 
         int size = fileName.length();
         if (size == 0) {
             return fileName;
         }
         final int prefix = getPrefixLength(fileName);
         if (prefix < 0) {
             return null;
         }
 
         final char[] array = new char[size + 2];  // +1 for possible extra slash, +2 for arraycopy
         fileName.getChars(0, fileName.length(), array, 0);
 
         // fix separators throughout
         final char otherSeparator = flipSeparator(separator);
         for (int i = 0; i < array.length; i++) {
             if (array[i] == otherSeparator) {
                 array[i] = separator;
             }
         }
 
         // add extra separator on the end to simplify code below
         boolean lastIsDirectory = true;
         if (array[size - 1] != separator) {
             array[size++] = separator;
             lastIsDirectory = false;
         }
 
         // adjoining slashes
         // If we get here, prefix can only be 0 or greater, size 1 or greater
         // If prefix is 0, set loop start to 1 to prevent index errors
         for (int i = prefix != 0 ? prefix : 1; i < size; i++) {
             if (array[i] == separator && array[i - 1] == separator) {
                 System.arraycopy(array, i, array, i - 1, size - i);
                 size--;
                 i--;
             }
         }
 
         // period slash
         for (int i = prefix + 1; i < size; i++) {
             if (array[i] == separator && array[i - 1] == '.' &&
                     (i == prefix + 1 || array[i - 2] == separator)) {
                 if (i == size - 1) {
                     lastIsDirectory = true;
                 }
                 System.arraycopy(array, i + 1, array, i - 1, size - i);
                 size -= 2;
                 i--;
             }
         }
 
         // double period slash
         outer:
         for (int i = prefix + 2; i < size; i++) {
             if (array[i] == separator && array[i - 1] == '.' && array[i - 2] == '.' &&
                     (i == prefix + 2 || array[i - 3] == separator)) {
                 if (i == prefix + 2) {
                     return null;
                 }
                 if (i == size - 1) {
                     lastIsDirectory = true;
                 }
                 int j;
                 for (j = i - 4 ; j >= prefix; j--) {
                     if (array[j] == separator) {
                         // remove b/../ from a/b/../c
                         System.arraycopy(array, i + 1, array, j + 1, size - i);
                         size -= i - j;
                         i = j + 1;
                         continue outer;
                     }
                 }
                 // remove a/../ from a/../c
                 System.arraycopy(array, i + 1, array, prefix, size - i);
                 size -= i + 1 - prefix;
                 i = prefix + 1;
             }
         }
 
         if (size <= 0) {  // should never be less than 0
             return EMPTY_STRING;
         }
         if (size <= prefix) {  // should never be less than prefix
             return new String(array, 0, size);
         }
         if (lastIsDirectory && keepSeparator) {
             return new String(array, 0, size);  // keep trailing separator
         }
         return new String(array, 0, size - 1);  // lose trailing separator
     }
 
     /**
      * Checks whether two file names are exactly equal.
      * <p>
      * No processing is performed on the file names other than comparison.
      * This is merely a null-safe case-sensitive string equality.
      * </p>
      *
      * @param fileName1  the first file name, may be null
      * @param fileName2  the second file name, may be null
      * @return true if the file names are equal, null equals null
      * @see IOCase#SENSITIVE
      */
     public static boolean equals(final String fileName1, final String fileName2) {
         return equals(fileName1, fileName2, false, IOCase.SENSITIVE);
     }
 
     /**
      * Checks whether two file names are equal, optionally normalizing and providing
      * control over the case-sensitivity.
      *
      * @param fileName1  the first file name, may be null
      * @param fileName2  the second file name, may be null
      * @param normalize  whether to normalize the file names
      * @param ioCase  what case sensitivity rule to use, null means case-sensitive
      * @return true if the file names are equal, null equals null
      * @since 1.3
      */
     public static boolean equals(String fileName1, String fileName2, final boolean normalize, final IOCase ioCase) {
 
         if (fileName1 == null || fileName2 == null) {
             return fileName1 == null && fileName2 == null;
         }
         if (normalize) {
             fileName1 = normalize(fileName1);
             if (fileName1 == null) {
                 return false;
             }
             fileName2 = normalize(fileName2);
             if (fileName2 == null) {
                 return false;
             }
         }
         return IOCase.value(ioCase, IOCase.SENSITIVE).checkEquals(fileName1, fileName2);
     }
 
     /**
      * Checks whether two file names are equal after both have been normalized.
      * <p>
      * Both file names are first passed to {@link #normalize(String)}.
      * The check is then performed in a case-sensitive manner.
      * </p>
      *
      * @param fileName1  the first file name, may be null
      * @param fileName2  the second file name, may be null
      * @return true if the file names are equal, null equals null
      * @see IOCase#SENSITIVE
      */
     public static boolean equalsNormalized(final String fileName1, final String fileName2) {
         return equals(fileName1, fileName2, true, IOCase.SENSITIVE);
     }
 
     /**
      * Checks whether two file names are equal using the case rules of the system
      * after both have been normalized.
      * <p>
      * Both file names are first passed to {@link #normalize(String)}.
      * The check is then performed case-sensitively on Unix and
      * case-insensitively on Windows.
      * </p>
      *
      * @param fileName1  the first file name, may be null
      * @param fileName2  the second file name, may be null
      * @return true if the file names are equal, null equals null
      * @see IOCase#SYSTEM
      */
     public static boolean equalsNormalizedOnSystem(final String fileName1, final String fileName2) {
         return equals(fileName1, fileName2, true, IOCase.SYSTEM);
     }
 
     /**
      * Checks whether two file names are equal using the case rules of the system.
      * <p>
      * No processing is performed on the file names other than comparison.
      * The check is case-sensitive on Unix and case-insensitive on Windows.
      * </p>
      *
      * @param fileName1  the first file name, may be null
      * @param fileName2  the second file name, may be null
      * @return true if the file names are equal, null equals null
      * @see IOCase#SYSTEM
      */
     public static boolean equalsOnSystem(final String fileName1, final String fileName2) {
         return equals(fileName1, fileName2, false, IOCase.SYSTEM);
     }
 
     /**
      * Flips the Windows name separator to Linux and vice-versa.
      *
      * @param ch The Windows or Linux name separator.
      * @return The Windows or Linux name separator.
      */
     static char flipSeparator(final char ch) {
         if (ch == UNIX_NAME_SEPARATOR) {
             return WINDOWS_NAME_SEPARATOR;
         }
         if (ch == WINDOWS_NAME_SEPARATOR) {
             return UNIX_NAME_SEPARATOR;
         }
         throw new IllegalArgumentException(String.valueOf(ch));
     }
 
     /**
      * Special handling for NTFS ADS: Don't accept colon in the file name.
      *
      * @param fileName a file name
      * @return ADS offsets.
      */
     private static int getAdsCriticalOffset(final String fileName) {
         // Step 1: Remove leading path segments.
         final int offset1 = fileName.lastIndexOf(SYSTEM_NAME_SEPARATOR);
         final int offset2 = fileName.lastIndexOf(OTHER_SEPARATOR);
         if (offset1 == -1) {
             if (offset2 == -1) {
                 return 0;
             }
             return offset2 + 1;
         }
         if (offset2 == -1) {
             return offset1 + 1;
         }
         return Math.max(offset1, offset2) + 1;
     }
 
     /**
      * Gets the base name, minus the full path and extension, from a full file name.
      * <p>
      * This method will handle a path in either Unix or Windows format.
      * The text after the last forward or backslash and before the last period is returned.
      * </p>
      * <pre>
      * a/b/c.txt --&gt; c
      * a\b\c.txt --&gt; c
      * a/b/c.foo.txt --&gt; c.foo
      * a.txt     --&gt; a
      * a/b/c     --&gt; c
      * a/b/c/    --&gt; ""
      * </pre>
      * <p>
      * The output will be the same irrespective of the machine that the code is running on.
      * </p>
      *
      * @param fileName  the file name, null returns null
      * @return the name of the file without the path, or an empty string if none exists
      * @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
      */
     public static String getBaseName(final String fileName) {
         return removeExtension(getName(fileName));
     }
 
     /**
      * Gets the extension of a file name.
      * <p>
      * This method returns the textual part of the file name after the last period.
      * There must be no directory separator after the period.
      * </p>
      * <pre>
      * foo.txt      --&gt; "txt"
      * a/b/c.jpg    --&gt; "jpg"
      * a/b.txt/c    --&gt; ""
      * a/b/c        --&gt; ""
      * </pre>
      * <p>
      * The output will be the same irrespective of the machine that the code is running on, with the
      * exception of a possible {@link IllegalArgumentException} on Windows (see below).
      * </p>
      * <p>
      * <strong>Note:</strong> This method used to have a hidden problem for names like "foo.exe:bar.txt".
      * In this case, the name wouldn't be the name of a file, but the identifier of an
      * alternate data stream (bar.txt) on the file foo.exe. The method used to return
      * ".txt" here, which would be misleading. Commons IO 2.7 and later throw
      * an {@link IllegalArgumentException} for names like this.
      * </p>
      *
      * @param fileName the file name to retrieve the extension of.
      * @return the extension of the file or an empty string if none exists or {@code null}
      * if the file name is {@code null}.
      * @throws IllegalArgumentException <strong>Windows only:</strong> the file name parameter is, in fact,
      * the identifier of an Alternate Data Stream, for example "foo.exe:bar.txt".
      */
     public static String getExtension(final String fileName) throws IllegalArgumentException {
         if (fileName == null) {
             return null;
         }
         final int index = indexOfExtension(fileName);
         if (index == NOT_FOUND) {
             return EMPTY_STRING;
         }
         return fileName.substring(index + 1);
     }
 
     /**
      * Gets the full path (prefix + path) from a full file name.
      * <p>
      * This method will handle a file in either Unix or Windows format.
      * The method is entirely text based, and returns the text before and
      * including the last forward or backslash.
      * </p>
      * <pre>
      * C:\a\b\c.txt --&gt; C:\a\b\
      * ~/a/b/c.txt  --&gt; ~/a/b/
      * a.txt        --&gt; ""
      * a/b/c        --&gt; a/b/
      * a/b/c/       --&gt; a/b/c/
      * C:           --&gt; C:
      * C:\          --&gt; C:\
      * ~            --&gt; ~/
      * ~/           --&gt; ~/
      * ~user        --&gt; ~user/
      * ~user/       --&gt; ~user/
      * </pre>
      * <p>
      * The output will be the same irrespective of the machine that the code is running on.
      * </p>
      *
      * @param fileName  the file name, null returns null
      * @return the path of the file, an empty string if none exists, null if invalid
      * @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
      */
     public static String getFullPath(final String fileName) {
         return doGetFullPath(fileName, true);
     }
 
     /**
      * Gets the full path (prefix + path) from a full file name,
      * excluding the final directory separator.
      * <p>
      * This method will handle a file in either Unix or Windows format.
      * The method is entirely text based, and returns the text before the
      * last forward or backslash.
      * </p>
      * <pre>
      * C:\a\b\c.txt --&gt; C:\a\b
      * ~/a/b/c.txt  --&gt; ~/a/b
      * a.txt        --&gt; ""
      * a/b/c        --&gt; a/b
      * a/b/c/       --&gt; a/b/c
      * C:           --&gt; C:
      * C:\          --&gt; C:\
      * ~            --&gt; ~
      * ~/           --&gt; ~
      * ~user        --&gt; ~user
      * ~user/       --&gt; ~user
      * </pre>
      * <p>
      * The output will be the same irrespective of the machine that the code is running on.
      * </p>
      *
      * @param fileName  the file name, null returns null
      * @return the path of the file, an empty string if none exists, null if invalid
      * @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
      */
     public static String getFullPathNoEndSeparator(final String fileName) {
         return doGetFullPath(fileName, false);
     }
 
     /**
      * Gets the name minus the path from a full file name.
      * <p>
      * This method will handle a file in either Unix or Windows format.
      * The text after the last forward or backslash is returned.
      * </p>
      * <pre>
      * a/b/c.txt --&gt; c.txt
      * a\b\c.txt --&gt; c.txt
      * a.txt     --&gt; a.txt
      * a/b/c     --&gt; c
      * a/b/c/    --&gt; ""
      * </pre>
      * <p>
      * The output will be the same irrespective of the machine that the code is running on.
      * </p>
      *
      * @param fileName  the file name, null returns null
      * @return the name of the file without the path, or an empty string if none exists
      * @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
      */
     public static String getName(final String fileName) {
         if (fileName == null) {
             return null;
         }
         return requireNonNullChars(fileName).substring(indexOfLastSeparator(fileName) + 1);
     }
 
     /**
      * Gets the path from a full file name, which excludes the prefix and the name.
      * <p>
      * This method will handle a file in either Unix or Windows format.
      * The method is entirely text based, and returns the text before and
      * including the last forward or backslash.
      * </p>
      * <pre>
      * C:\a\b\c.txt --&gt; a\b\
      * ~/a/b/c.txt  --&gt; a/b/
      * a.txt        --&gt; ""
      * a/b/c        --&gt; a/b/
      * a/b/c/       --&gt; a/b/c/
      * </pre>
      * <p>
      * The output will be the same irrespective of the machine that the code is running on.
      * </p>
      * <p>
      * This method drops the prefix from the result.
      * See {@link #getFullPath(String)} for the method that retains the prefix.
      * </p>
      *
      * @param fileName  the file name, null returns null
      * @return the path of the file, an empty string if none exists, null if invalid
      * @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
      */
     public static String getPath(final String fileName) {
         return doGetPath(fileName, 1);
     }
 
     /**
      * Gets the path (which excludes the prefix) from a full file name, and
      * also excluding the final directory separator.
      * <p>
      * This method will handle a file in either Unix or Windows format.
      * The method is entirely text based, and returns the text before the
      * last forward or backslash.
      * </p>
      * <pre>
      * C:\a\b\c.txt --&gt; a\b
      * ~/a/b/c.txt  --&gt; a/b
      * a.txt        --&gt; ""
      * a/b/c        --&gt; a/b
      * a/b/c/       --&gt; a/b/c
      * </pre>
      * <p>
      * The output will be the same irrespective of the machine that the code is running on.
      * </p>
      * <p>
      * This method drops the prefix from the result.
      * See {@link #getFullPathNoEndSeparator(String)} for the method that retains the prefix.
      * </p>
      *
      * @param fileName  the file name, null returns null
      * @return the path of the file, an empty string if none exists, null if invalid
      * @throws IllegalArgumentException if the result path contains the null character ({@code U+0000})
      */
     public static String getPathNoEndSeparator(final String fileName) {
         return doGetPath(fileName, 0);
     }
 
     /**
      * Gets the prefix such as {@code C:/} or {@code ~/} from a full file name,
      * <p>
      * This method will handle a file in either Unix or Windows format.
      * The prefix includes the first slash in the full file name where applicable.
      * </p>
      * <pre>
      * Windows:
      * a\b\c.txt           --&gt; ""          --&gt; relative
      * \a\b\c.txt          --&gt; "\"         --&gt; current drive absolute
      * C:a\b\c.txt         --&gt; "C:"        --&gt; drive relative
      * C:\a\b\c.txt        --&gt; "C:\"       --&gt; absolute
      * \\server\a\b\c.txt  --&gt; "\\server\" --&gt; UNC
      *
      * Unix:
      * a/b/c.txt           --&gt; ""          --&gt; relative
      * /a/b/c.txt          --&gt; "/"         --&gt; absolute
      * ~/a/b/c.txt         --&gt; "~/"        --&gt; current user
      * ~                   --&gt; "~/"        --&gt; current user (slash added)
      * ~user/a/b/c.txt     --&gt; "~user/"    --&gt; named user
      * ~user               --&gt; "~user/"    --&gt; named user (slash added)
      * </pre>
      * <p>
      * The output will be the same irrespective of the machine that the code is running on.
      * ie. both Unix and Windows prefixes are matched regardless.
      * </p>
      *
      * @param fileName  the file name, null returns null
      * @return the prefix of the file, null if invalid
      * @throws IllegalArgumentException if the result contains the null character ({@code U+0000})
      */
     public static String getPrefix(final String fileName) {
         if (fileName == null) {
             return null;
         }
         final int len = getPrefixLength(fileName);
         if (len < 0) {
             return null;
         }
         if (len > fileName.length()) {
             requireNonNullChars(fileName);
             return fileName + UNIX_NAME_SEPARATOR;
         }
         return requireNonNullChars(fileName.substring(0, len));
     }
 
     /**
      * Returns the length of the file name prefix, such as {@code C:/} or {@code ~/}.
      * <p>
      * This method will handle a file in either Unix or Windows format.
      * </p>
      * <p>
      * The prefix length includes the first slash in the full file name
      * if applicable. Thus, it is possible that the length returned is greater
      * than the length of the input string.
      * </p>
      * <pre>
      * Windows:
      * a\b\c.txt           --&gt; 0           --&gt; relative
      * \a\b\c.txt          --&gt; 1           --&gt; current drive absolute
      * C:a\b\c.txt         --&gt; 2           --&gt; drive relative
      * C:\a\b\c.txt        --&gt; 3           --&gt; absolute
      * \\server\a\b\c.txt  --&gt; 9           --&gt; UNC
      * \\\a\b\c.txt        --&gt; -1          --&gt; error
      *
      * Unix:
      * a/b/c.txt           --&gt; 0           --&gt; relative
      * /a/b/c.txt          --&gt; 1           --&gt; absolute
      * ~/a/b/c.txt         --&gt; 2           --&gt; current user
      * ~                   --&gt; 2           --&gt; current user (slash added)
      * ~user/a/b/c.txt     --&gt; 6           --&gt; named user
      * ~user               --&gt; 6           --&gt; named user (slash added)
      * //server/a/b/c.txt  --&gt; 9
      * ///a/b/c.txt        --&gt; -1          --&gt; error
      * C:                  --&gt; 0           --&gt; valid file name as only null character and / are reserved characters
      * </pre>
      * <p>
      * The output will be the same irrespective of the machine that the code is running on.
      * ie. both Unix and Windows prefixes are matched regardless.
      * </p>
      * <p>
      * Note that a leading // (or \\) is used to indicate a UNC name on Windows.
      * These must be followed by a server name, so double-slashes are not collapsed
      * to a single slash at the start of the file name.
      * </p>
      *
      * @param fileName  the file name to find the prefix in, null returns -1
      * @return the length of the prefix, -1 if invalid or null
      */
     public static int getPrefixLength(final String fileName) {
         if (fileName == null) {
             return NOT_FOUND;
         }
         final int len = fileName.length();
         if (len == 0) {
             return 0;
         }
         char ch0 = fileName.charAt(0);
         if (ch0 == ':') {
             return NOT_FOUND;
         }
         if (len == 1) {
             if (ch0 == '~') {
                 return 2;  // return a length greater than the input
             }
             return isSeparator(ch0) ? 1 : 0;
         }
         if (ch0 == '~') {
             int posUnix = fileName.indexOf(UNIX_NAME_SEPARATOR, 1);
             int posWin = fileName.indexOf(WINDOWS_NAME_SEPARATOR, 1);
             if (posUnix == NOT_FOUND && posWin == NOT_FOUND) {
                 return len + 1;  // return a length greater than the input
             }
             posUnix = posUnix == NOT_FOUND ? posWin : posUnix;
             posWin = posWin == NOT_FOUND ? posUnix : posWin;
             return Math.min(posUnix, posWin) + 1;
         }
         final char ch1 = fileName.charAt(1);
         if (ch1 == ':') {
             ch0 = Character.toUpperCase(ch0);
             if (ch0 >= 'A' && ch0 <= 'Z') {
                 if (len == 2 && !FileSystem.getCurrent().supportsDriveLetter()) {
                     return 0;
                 }
                 if (len == 2 || !isSeparator(fileName.charAt(2))) {
                     return 2;
                 }
                 return 3;
             }
             if (ch0 == UNIX_NAME_SEPARATOR) {
                 return 1;
             }
             return NOT_FOUND;
 
         }
         if (!isSeparator(ch0) || !isSeparator(ch1)) {
             return isSeparator(ch0) ? 1 : 0;
         }
         int posUnix = fileName.indexOf(UNIX_NAME_SEPARATOR, 2);
         int posWin = fileName.indexOf(WINDOWS_NAME_SEPARATOR, 2);
         if (posUnix == NOT_FOUND && posWin == NOT_FOUND || posUnix == 2 || posWin == 2) {
             return NOT_FOUND;
         }
         posUnix = posUnix == NOT_FOUND ? posWin : posUnix;
         posWin = posWin == NOT_FOUND ? posUnix : posWin;
         final int pos = Math.min(posUnix, posWin) + 1;
         final String hostnamePart = fileName.substring(2, pos - 1);
         return isValidHostName(hostnamePart) ? pos : NOT_FOUND;
     }
 
     /**
      * Returns the index of the last extension separator character, which is a period.
      * <p>
      * This method also checks that there is no directory separator after the last period. To do this it uses
      * {@link #indexOfLastSeparator(String)} which will handle a file in either Unix or Windows format.
      * </p>
      * <p>
      * The output will be the same irrespective of the machine that the code is running on, with the
      * exception of a possible {@link IllegalArgumentException} on Windows (see below).
      * </p>
      * <strong>Note:</strong> This method used to have a hidden problem for names like "foo.exe:bar.txt".
      * In this case, the name wouldn't be the name of a file, but the identifier of an
      * alternate data stream (bar.txt) on the file foo.exe. The method used to return
      * ".txt" here, which would be misleading. Commons IO 2.7, and later versions, are throwing
      * an {@link IllegalArgumentException} for names like this.
      *
      * @param fileName
      *            the file name to find the last extension separator in, null returns -1
      * @return the index of the last extension separator character, or -1 if there is no such character
      * @throws IllegalArgumentException <strong>Windows only:</strong> the file name parameter is, in fact,
      * the identifier of an Alternate Data Stream, for example "foo.exe:bar.txt".
      */
     public static int indexOfExtension(final String fileName) throws IllegalArgumentException {
         if (fileName == null) {
             return NOT_FOUND;
         }
         if (isSystemWindows()) {
             // Special handling for NTFS ADS: Don't accept colon in the file name.
             final int offset = fileName.indexOf(':', getAdsCriticalOffset(fileName));
             if (offset != -1) {
                 throw new IllegalArgumentException("NTFS ADS separator (':') in file name is forbidden.");
             }
         }
         final int extensionPos = fileName.lastIndexOf(EXTENSION_SEPARATOR);
         final int lastSeparator = indexOfLastSeparator(fileName);
         return lastSeparator > extensionPos ? NOT_FOUND : extensionPos;
     }
 
     /**
      * Returns the index of the last directory separator character.
      * <p>
      * This method will handle a file in either Unix or Windows format.
      * The position of the last forward or backslash is returned.
      * <p>
      * The output will be the same irrespective of the machine that the code is running on.
      *
      * @param fileName  the file name to find the last path separator in, null returns -1
      * @return the index of the last separator character, or -1 if there
      * is no such character
      */
     public static int indexOfLastSeparator(final String fileName) {
         if (fileName == null) {
             return NOT_FOUND;
         }
         final int lastUnixPos = fileName.lastIndexOf(UNIX_NAME_SEPARATOR);
         final int lastWindowsPos = fileName.lastIndexOf(WINDOWS_NAME_SEPARATOR);
         return Math.max(lastUnixPos, lastWindowsPos);
     }
 
     private static boolean isEmpty(final String string) {
         return string == null || string.isEmpty();
     }
 
     /**
      * Checks whether the extension of the file name is one of those specified.
      * <p>
      * This method obtains the extension as the textual part of the file name
      * after the last period. There must be no directory separator after the period.
      * The extension check is case-sensitive on all platforms.
      *
      * @param fileName  the file name, null returns false
      * @param extensions  the extensions to check for, null checks for no extension
      * @return true if the file name is one of the extensions
      * @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
      */
     public static boolean isExtension(final String fileName, final Collection<String> extensions) {
         if (fileName == null) {
             return false;
         }
         requireNonNullChars(fileName);
 
         if (extensions == null || extensions.isEmpty()) {
             return indexOfExtension(fileName) == NOT_FOUND;
         }
         return extensions.contains(getExtension(fileName));
     }
 
     /**
      * Checks whether the extension of the file name is that specified.
      * <p>
      * This method obtains the extension as the textual part of the file name
      * after the last period. There must be no directory separator after the period.
      * The extension check is case-sensitive on all platforms.
      *
      * @param fileName  the file name, null returns false
      * @param extension  the extension to check for, null or empty checks for no extension
      * @return true if the file name has the specified extension
      * @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
      */
     public static boolean isExtension(final String fileName, final String extension) {
         if (fileName == null) {
             return false;
         }
         requireNonNullChars(fileName);
 
         if (isEmpty(extension)) {
             return indexOfExtension(fileName) == NOT_FOUND;
         }
         return getExtension(fileName).equals(extension);
     }
 
     /**
      * Checks whether the extension of the file name is one of those specified.
      * <p>
      * This method obtains the extension as the textual part of the file name
      * after the last period. There must be no directory separator after the period.
      * The extension check is case-sensitive on all platforms.
      *
      * @param fileName  the file name, null returns false
      * @param extensions  the extensions to check for, null checks for no extension
      * @return true if the file name is one of the extensions
      * @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
      */
     public static boolean isExtension(final String fileName, final String... extensions) {
         if (fileName == null) {
             return false;
         }
         requireNonNullChars(fileName);
 
         if (extensions == null || extensions.length == 0) {
             return indexOfExtension(fileName) == NOT_FOUND;
         }
         final String fileExt = getExtension(fileName);
         return Stream.of(extensions).anyMatch(fileExt::equals);
     }
 
     /**
      * Checks whether a given string represents a valid IPv4 address.
      *
      * @param name the name to validate
      * @return true if the given name is a valid IPv4 address
      */
     // mostly copied from org.apache.commons.validator.routines.InetAddressValidator#isValidInet4Address
     private static boolean isIPv4Address(final String name) {
         final Matcher m = IPV4_PATTERN.matcher(name);
         if (!m.matches() || m.groupCount() != 4) {
             return false;
         }
 
         // verify that address subgroups are legal
         for (int i = 1; i <= 4; i++) {
             final String ipSegment = m.group(i);
             final int iIpSegment = Integer.parseInt(ipSegment);
             if (iIpSegment > IPV4_MAX_OCTET_VALUE) {
                 return false;
             }
 
             if (ipSegment.length() > 1 && ipSegment.startsWith("0")) {
                 return false;
             }
 
         }
 
         return true;
     }
 
     // copied from org.apache.commons.validator.routines.InetAddressValidator#isValidInet6Address
     /**
      * Checks whether a given string represents a valid IPv6 address.
      *
      * @param inet6Address the name to validate
      * @return true if the given name is a valid IPv6 address
      */
     private static boolean isIPv6Address(final String inet6Address) {
         final boolean containsCompressedZeroes = inet6Address.contains("::");
         if (containsCompressedZeroes && inet6Address.indexOf("::") != inet6Address.lastIndexOf("::")) {
             return false;
         }
         if (inet6Address.startsWith(":") && !inet6Address.startsWith("::")
                 || inet6Address.endsWith(":") && !inet6Address.endsWith("::")) {
             return false;
         }
         String[] octets = inet6Address.split(":");
         if (containsCompressedZeroes) {
             final List<String> octetList = new ArrayList<>(Arrays.asList(octets));
             if (inet6Address.endsWith("::")) {
                 // String.split() drops ending empty segments
                 octetList.add("");
             } else if (inet6Address.startsWith("::") && !octetList.isEmpty()) {
                 octetList.remove(0);
             }
             octets = octetList.toArray(EMPTY_STRING_ARRAY);
         }
         if (octets.length > IPV6_MAX_HEX_GROUPS) {
             return false;
         }
         int validOctets = 0;
         int emptyOctets = 0; // consecutive empty chunks
         for (int index = 0; index < octets.length; index++) {
             final String octet = octets[index];
             if (octet.isEmpty()) {
                 emptyOctets++;
                 if (emptyOctets > 1) {
                     return false;
                 }
             } else {
                 emptyOctets = 0;
                 // Is last chunk an IPv4 address?
                 if (index == octets.length - 1 && octet.contains(".")) {
                     if (!isIPv4Address(octet)) {
                         return false;
                     }
                     validOctets += 2;
                     continue;
                 }
                 if (octet.length() > IPV6_MAX_HEX_DIGITS_PER_GROUP) {
                     return false;
                 }
                 final int octetInt;
                 try {
                     octetInt = Integer.parseInt(octet, BASE_16);
                 } catch (final NumberFormatException e) {
                     return false;
                 }
                 if (octetInt < 0 || octetInt > MAX_UNSIGNED_SHORT) {
                     return false;
                 }
             }
             validOctets++;
         }
         return validOctets <= IPV6_MAX_HEX_GROUPS && (validOctets >= IPV6_MAX_HEX_GROUPS || containsCompressedZeroes);
     }
 
     /**
      * Checks whether a given string is a valid host name according to
      * RFC 3986 - not accepting IP addresses.
      *
      * @see "https://tools.ietf.org/html/rfc3986#section-3.2.2"
      * @param name the hostname to validate
      * @return true if the given name is a valid host name
      */
     private static boolean isRFC3986HostName(final String name) {
         final String[] parts = name.split("\\.", -1);
         for (int i = 0; i < parts.length; i++) {
             if (parts[i].isEmpty()) {
                 // trailing period is legal, otherwise we've hit a .. sequence
                 return i == parts.length - 1;
             }
             if (!REG_NAME_PART_PATTERN.matcher(parts[i]).matches()) {
                 return false;
             }
         }
         return true;
     }
 
     /**
      * Checks if the character is a separator.
      *
      * @param ch  the character to check
      * @return true if it is a separator character
      */
     private static boolean isSeparator(final char ch) {
         return ch == UNIX_NAME_SEPARATOR || ch == WINDOWS_NAME_SEPARATOR;
     }
 
     /**
      * Determines if Windows file system is in use.
      *
      * @return true if the system is Windows
      */
     static boolean isSystemWindows() {
         return SYSTEM_NAME_SEPARATOR == WINDOWS_NAME_SEPARATOR;
     }
 
     /**
      * Checks whether a given string is a valid host name according to
      * RFC 3986.
      *
      * <p>Accepted are IP addresses (v4 and v6) as well as what the
      * RFC calls a "reg-name". Percent encoded names don't seem to be
      * valid names in UNC paths.</p>
      *
      * @see "https://tools.ietf.org/html/rfc3986#section-3.2.2"
      * @param name the hostname to validate
      * @return true if the given name is a valid host name
      */
     private static boolean isValidHostName(final String name) {
         return isIPv6Address(name) || isRFC3986HostName(name);
     }
 
     /**
      * Normalizes a path, removing double and single period path steps.
      * <p>
      * This method normalizes a path to a standard format.
      * The input may contain separators in either Unix or Windows format.
      * The output will contain separators in the format of the system.
      * <p>
      * A trailing slash will be retained.
      * A double slash will be merged to a single slash (but UNC names are handled).
      * A single period path segment will be removed.
      * A double period will cause that path segment and the one before to be removed.
      * If the double period has no parent path segment, {@code null} is returned.
      * <p>
      * The output will be the same on both Unix and Windows except
      * for the separator character.
      * <pre>
      * /foo//               --&gt;   /foo/
      * /foo/./              --&gt;   /foo/
      * /foo/../bar          --&gt;   /bar
      * /foo/../bar/         --&gt;   /bar/
      * /foo/../bar/../baz   --&gt;   /baz
      * //foo//./bar         --&gt;   //foo/bar
      * /../                 --&gt;   null
      * ../foo               --&gt;   null
      * foo/bar/..           --&gt;   foo/
      * foo/../../bar        --&gt;   null
      * foo/../bar           --&gt;   bar
      * //server/foo/../bar  --&gt;   //server/bar
      * //server/../bar      --&gt;   null
      * C:\foo\..\bar        --&gt;   C:\bar
      * C:\..\bar            --&gt;   null
      * ~/foo/../bar/        --&gt;   ~/bar/
      * ~/../bar             --&gt;   null
      * </pre>
      * (Note the file separator will be correct for Windows/Unix.)
      *
      * @param fileName  the file name to normalize, null returns null
      * @return the normalized fileName, or null if invalid
      * @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
      */
     public static String normalize(final String fileName) {
         return doNormalize(fileName, SYSTEM_NAME_SEPARATOR, true);
     }
 
     /**
      * Normalizes a path, removing double and single period path steps.
      * <p>
      * This method normalizes a path to a standard format.
      * The input may contain separators in either Unix or Windows format.
      * The output will contain separators in the format specified.
      * <p>
      * A trailing slash will be retained.
      * A double slash will be merged to a single slash (but UNC names are handled).
      * A single period path segment will be removed.
      * A double period will cause that path segment and the one before to be removed.
      * If the double period has no parent path segment to work with, {@code null}
      * is returned.
      * <p>
      * The output will be the same on both Unix and Windows except
      * for the separator character.
      * <pre>
      * /foo//               --&gt;   /foo/
      * /foo/./              --&gt;   /foo/
      * /foo/../bar          --&gt;   /bar
      * /foo/../bar/         --&gt;   /bar/
      * /foo/../bar/../baz   --&gt;   /baz
      * //foo//./bar         --&gt;   /foo/bar
      * /../                 --&gt;   null
      * ../foo               --&gt;   null
      * foo/bar/..           --&gt;   foo/
      * foo/../../bar        --&gt;   null
      * foo/../bar           --&gt;   bar
      * //server/foo/../bar  --&gt;   //server/bar
      * //server/../bar      --&gt;   null
      * C:\foo\..\bar        --&gt;   C:\bar
      * C:\..\bar            --&gt;   null
      * ~/foo/../bar/        --&gt;   ~/bar/
      * ~/../bar             --&gt;   null
      * </pre>
      * The output will be the same on both Unix and Windows including
      * the separator character.
      *
      * @param fileName  the file name to normalize, null returns null
      * @param unixSeparator {@code true} if a Unix separator should
      * be used or {@code false} if a Windows separator should be used.
      * @return the normalized fileName, or null if invalid
      * @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
      * @since 2.0
      */
     public static String normalize(final String fileName, final boolean unixSeparator) {
         return doNormalize(fileName, toSeparator(unixSeparator), true);
     }
 
     /**
      * Normalizes a path, removing double and single period path steps,
      * and removing any final directory separator.
      * <p>
      * This method normalizes a path to a standard format.
      * The input may contain separators in either Unix or Windows format.
      * The output will contain separators in the format of the system.
      * <p>
      * A trailing slash will be removed.
      * A double slash will be merged to a single slash (but UNC names are handled).
      * A single period path segment will be removed.
      * A double period will cause that path segment and the one before to be removed.
      * If the double period has no parent path segment to work with, {@code null}
      * is returned.
      * <p>
      * The output will be the same on both Unix and Windows except
      * for the separator character.
      * <pre>
      * /foo//               --&gt;   /foo
      * /foo/./              --&gt;   /foo
      * /foo/../bar          --&gt;   /bar
      * /foo/../bar/         --&gt;   /bar
      * /foo/../bar/../baz   --&gt;   /baz
      * //foo//./bar         --&gt;   /foo/bar
      * /../                 --&gt;   null
      * ../foo               --&gt;   null
      * foo/bar/..           --&gt;   foo
      * foo/../../bar        --&gt;   null
      * foo/../bar           --&gt;   bar
      * //server/foo/../bar  --&gt;   //server/bar
      * //server/../bar      --&gt;   null
      * C:\foo\..\bar        --&gt;   C:\bar
      * C:\..\bar            --&gt;   null
      * ~/foo/../bar/        --&gt;   ~/bar
      * ~/../bar             --&gt;   null
      * </pre>
      * (Note the file separator returned will be correct for Windows/Unix)
      *
      * @param fileName  the file name to normalize, null returns null
      * @return the normalized fileName, or null if invalid
      * @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
      */
     public static String normalizeNoEndSeparator(final String fileName) {
         return doNormalize(fileName, SYSTEM_NAME_SEPARATOR, false);
     }
 
     /**
      * Normalizes a path, removing double and single period path steps,
      * and removing any final directory separator.
      * <p>
      * This method normalizes a path to a standard format.
      * The input may contain separators in either Unix or Windows format.
      * The output will contain separators in the format specified.
      * <p>
      * A trailing slash will be removed.
      * A double slash will be merged to a single slash (but UNC names are handled).
      * A single period path segment will be removed.
      * A double period will cause that path segment and the one before to be removed.
      * If the double period has no parent path segment to work with, {@code null}
      * is returned.
      * <p>
      * The output will be the same on both Unix and Windows including
      * the separator character.
      * <pre>
      * /foo//               --&gt;   /foo
      * /foo/./              --&gt;   /foo
      * /foo/../bar          --&gt;   /bar
      * /foo/../bar/         --&gt;   /bar
      * /foo/../bar/../baz   --&gt;   /baz
      * //foo//./bar         --&gt;   /foo/bar
      * /../                 --&gt;   null
      * ../foo               --&gt;   null
      * foo/bar/..           --&gt;   foo
      * foo/../../bar        --&gt;   null
      * foo/../bar           --&gt;   bar
      * //server/foo/../bar  --&gt;   //server/bar
      * //server/../bar      --&gt;   null
      * C:\foo\..\bar        --&gt;   C:\bar
      * C:\..\bar            --&gt;   null
      * ~/foo/../bar/        --&gt;   ~/bar
      * ~/../bar             --&gt;   null
      * </pre>
      *
      * @param fileName  the file name to normalize, null returns null
      * @param unixSeparator {@code true} if a Unix separator should
      * be used or {@code false} if a Windows separator should be used.
      * @return the normalized fileName, or null if invalid
      * @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
      * @since 2.0
      */
     public static String normalizeNoEndSeparator(final String fileName, final boolean unixSeparator) {
          return doNormalize(fileName, toSeparator(unixSeparator), false);
     }
 
     /**
      * Removes the extension from a fileName.
      * <p>
      * This method returns the textual part of the file name before the last period.
      * There must be no directory separator after the period.
      * <pre>
      * foo.txt    --&gt; foo
      * .txt       --&gt; "" (empty string)
      * a\b\c.jpg  --&gt; a\b\c
      * /a/b/c.jpg --&gt; /a/b/c
      * a\b\c      --&gt; a\b\c
      * a.b\c      --&gt; a.b\c
      * </pre>
      * <p>
      * The output will be the same irrespective of the machine that the code is running on.
      *
      * @param fileName  the file name, null returns null
      * @return the file name minus the extension
      * @throws IllegalArgumentException if the file name contains the null character ({@code U+0000})
      */
     public static String removeExtension(final String fileName) {
         if (fileName == null) {
             return null;
         }
         requireNonNullChars(fileName);
 
         final int index = indexOfExtension(fileName);
         if (index == NOT_FOUND) {
             return fileName;
         }
         return fileName.substring(0, index);
     }
 
     /**
      * Checks the input for null characters ({@code U+0000}), a sign of unsanitized data being passed to file level functions.
      *
      * This may be used to defend against poison byte attacks.
      *
      * @param path the path to check
      * @return The input
      * @throws IllegalArgumentException if path contains the null character ({@code U+0000})
      */
     private static String requireNonNullChars(final String path) {
         if (path.indexOf(0) >= 0) {
             throw new IllegalArgumentException(
                 "Null character present in file/path name. There are no known legitimate use cases for such data, but several injection attacks may use it");
         }
         return path;
     }
 
     /**
      * Converts all separators to the system separator.
      *
      * @param path the path to be changed, null ignored.
      * @return the updated path.
      */
     public static String separatorsToSystem(final String path) {
         return FileSystem.getCurrent().normalizeSeparators(path);
     }
 
     /**
      * Converts all separators to the Unix separator of forward slash.
      *
      * @param path the path to be changed, null ignored.
      * @return the new path.
      */
     public static String separatorsToUnix(final String path) {
         return FileSystem.LINUX.normalizeSeparators(path);
     }
 
     /**
      * Converts all separators to the Windows separator of backslash.
      *
      * @param path the path to be changed, null ignored.
      * @return the updated path.
      */
     public static String separatorsToWindows(final String path) {
         return FileSystem.WINDOWS.normalizeSeparators(path);
     }
 
     /**
      * Splits a string into a number of tokens.
      * The text is split by '?' and '*'.
      * Where multiple '*' occur consecutively they are collapsed into a single '*'.
      *
      * @param text  the text to split
      * @return the array of tokens, never null
      */
     static String[] splitOnTokens(final String text) {
         // used by wildcardMatch
         // package level so a unit test may run on this
 
         if (text.indexOf('?') == NOT_FOUND && text.indexOf('*') == NOT_FOUND) {
             return new String[] { text };
         }
 
         final char[] array = text.toCharArray();
         final ArrayList<String> list = new ArrayList<>();
         final StringBuilder buffer = new StringBuilder();
         char prevChar = 0;
         for (final char ch : array) {
             if (ch == '?' || ch == '*') {
                 if (buffer.length() != 0) {
                     list.add(buffer.toString());
                     buffer.setLength(0);
                 }
                 if (ch == '?') {
                     list.add("?");
                 } else if (prevChar != '*') { // ch == '*' here; check if previous char was '*'
                     list.add("*");
                 }
             } else {
                 buffer.append(ch);
             }
             prevChar = ch;
         }
         if (buffer.length() != 0) {
             list.add(buffer.toString());
         }
 
         return list.toArray(EMPTY_STRING_ARRAY);
     }
 
     /**
      * Returns '/' if given true, '\\' otherwise.
      *
      * @param unixSeparator which separator to return.
      * @return '/' if given true, '\\' otherwise.
      */
     private static char toSeparator(final boolean unixSeparator) {
         return unixSeparator ? UNIX_NAME_SEPARATOR : WINDOWS_NAME_SEPARATOR;
     }
 
     /**
      * Checks a fileName to see if it matches the specified wildcard matcher,
      * always testing case-sensitive.
      * <p>
      * The wildcard matcher uses the characters '?' and '*' to represent a
      * single or multiple (zero or more) wildcard characters.
      * This is the same as often found on DOS/Unix command lines.
      * The check is case-sensitive always.
      * <pre>
      * wildcardMatch("c.txt", "*.txt")      --&gt; true
      * wildcardMatch("c.txt", "*.jpg")      --&gt; false
      * wildcardMatch("a/b/c.txt", "a/b/*")  --&gt; true
      * wildcardMatch("c.txt", "*.???")      --&gt; true
      * wildcardMatch("c.txt", "*.????")     --&gt; false
      * </pre>
      * The sequence "*?" does not work properly at present in match strings.
      *
      * @param fileName  the file name to match on
      * @param wildcardMatcher  the wildcard string to match against
      * @return true if the file name matches the wildcard string
      * @see IOCase#SENSITIVE
      */
     public static boolean wildcardMatch(final String fileName, final String wildcardMatcher) {
         return wildcardMatch(fileName, wildcardMatcher, IOCase.SENSITIVE);
     }
 
     /**
      * Checks a fileName to see if it matches the specified wildcard matcher
      * allowing control over case-sensitivity.
      * <p>
      * The wildcard matcher uses the characters '?' and '*' to represent a
      * single or multiple (zero or more) wildcard characters.
      * The sequence "*?" does not work properly at present in match strings.
      *
      * @param fileName  the file name to match on
      * @param wildcardMatcher  the wildcard string to match against
      * @param ioCase  what case sensitivity rule to use, null means case-sensitive
      * @return true if the file name matches the wildcard string
      * @since 1.3
      */
     public static boolean wildcardMatch(final String fileName, final String wildcardMatcher, IOCase ioCase) {
         if (fileName == null && wildcardMatcher == null) {
             return true;
         }
         if (fileName == null || wildcardMatcher == null) {
             return false;
         }
         ioCase = IOCase.value(ioCase, IOCase.SENSITIVE);
         final String[] wcs = splitOnTokens(wildcardMatcher);
         boolean anyChars = false;
         int textIdx = 0;
         int wcsIdx = 0;
         final Deque<int[]> backtrack = new ArrayDeque<>(wcs.length);
 
         // loop around a backtrack stack, to handle complex * matching
         do {
             if (!backtrack.isEmpty()) {
                 final int[] array = backtrack.pop();
                 wcsIdx = array[0];
                 textIdx = array[1];
                 anyChars = true;
             }
 
             // loop whilst tokens and text left to process
             while (wcsIdx < wcs.length) {
 
                 if (wcs[wcsIdx].equals("?")) {
                     // ? so move to next text char
                     textIdx++;
                     if (textIdx > fileName.length()) {
                         break;
                     }
                     anyChars = false;
 
                 } else if (wcs[wcsIdx].equals("*")) {
                     // set any chars status
                     anyChars = true;
                     if (wcsIdx == wcs.length - 1) {
                         textIdx = fileName.length();
                     }
 
                 } else {
                     // matching text token
                     if (anyChars) {
                         // any chars then try to locate text token
                         textIdx = ioCase.checkIndexOf(fileName, textIdx, wcs[wcsIdx]);
                         if (textIdx == NOT_FOUND) {
                             // token not found
                             break;
                         }
                         final int repeat = ioCase.checkIndexOf(fileName, textIdx + 1, wcs[wcsIdx]);
                         if (repeat >= 0) {
                             backtrack.push(new int[] {wcsIdx, repeat});
                         }
                     } else if (!ioCase.checkRegionMatches(fileName, textIdx, wcs[wcsIdx])) {
                         // matching from current position
                         // couldn't match token
                         break;
                     }
 
                     // matched text token, move text index to end of matched token
                     textIdx += wcs[wcsIdx].length();
                     anyChars = false;
                 }
 
                 wcsIdx++;
             }
 
             // full match
             if (wcsIdx == wcs.length && textIdx == fileName.length()) {
                 return true;
             }
 
         } while (!backtrack.isEmpty());
 
         return false;
     }
 
     /**
      * Checks a fileName to see if it matches the specified wildcard matcher
      * using the case rules of the system.
      * <p>
      * The wildcard matcher uses the characters '?' and '*' to represent a
      * single or multiple (zero or more) wildcard characters.
      * This is the same as often found on DOS/Unix command lines.
      * The check is case-sensitive on Unix and case-insensitive on Windows.
      * <pre>
      * wildcardMatch("c.txt", "*.txt")      --&gt; true
      * wildcardMatch("c.txt", "*.jpg")      --&gt; false
      * wildcardMatch("a/b/c.txt", "a/b/*")  --&gt; true
      * wildcardMatch("c.txt", "*.???")      --&gt; true
      * wildcardMatch("c.txt", "*.????")     --&gt; false
      * </pre>
      * The sequence "*?" does not work properly at present in match strings.
      *
      * @param fileName  the file name to match on
      * @param wildcardMatcher  the wildcard string to match against
      * @return true if the file name matches the wildcard string
      * @see IOCase#SYSTEM
      */
     public static boolean wildcardMatchOnSystem(final String fileName, final String wildcardMatcher) {
         return wildcardMatch(fileName, wildcardMatcher, IOCase.SYSTEM);
     }
 
     /**
      * Instances should NOT be constructed in standard programming.
      *
      * @deprecated TODO Make private in 3.0.
      */
     @Deprecated
     public FilenameUtils() {
         // empty
     }
 }