//jordenwu 精简
public int UnityExtractStreamZipInit(Stream inputStream, string targetDirectory)
{
continueRunning_ = true;
overwrite_ = Overwrite.Always;
confirmDelegate_ = null;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
restoreDateTimeOnExtract_ = false;
createEmptyDirectories_ = true;
//
zipFile_ = new ZipFile(inputStream);
zipFile_.IsStreamOwner = false;
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
//获取文件总数
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
int fileCnt = 0;
while (enumerator.MoveNext())
{
ZipEntry ze = enumerator.Current as ZipEntry;
if (ze != null)
{
if (ze.IsFile)
{
fileCnt++;
}
}
}
return(fileCnt);
}
/// <summary>
/// Extract the contents of a zip file.
/// </summary>
/// <param name="zipFileName">The zip file to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating wether to restore the date and time for extracted files.</param>
public void ExtractZip(string zipFileName, string targetDirectory, string fileFilter, string directoryFilter)
{
continueRunning_ = true;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
using (zipFile_ = new ZipFile(zipFileName))
{
IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
var entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
// TODO Path.GetDirectory can fail here on invalid characters.
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) &&
fileFilter_.IsMatch(entry.Name))
{
ExtractEntry(entry);
}
}
}
}
}
public static bool unzipFile(Stream inputStream, string targetDirectory, bool overwrite, OnUnzipProgress callback)
{
bool ret = false;
callback(0, 0);
using (ZipFile zipFile_ = new ZipFile(inputStream))
{
int totalBytes = (int)zipFile_.unzipSize;
UnzipCach cach = new UnzipCach();
cach.start(totalBytes, callback, overwrite);
INameTransform extractNameTransform_ = new WindowsNameTransform(targetDirectory);
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while (enumerator.MoveNext())
{
try
{
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
string fileName = extractNameTransform_.TransformFile(entry.Name);
string dirName = Path.GetDirectoryName(Path.GetFullPath(fileName));
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
Stream source = zipFile_.GetInputStream(entry);
cach.addFile(fileName, (int)entry.Size, source);
source.Close();
}
else
{
string dirName = extractNameTransform_.TransformDirectory(entry.Name);
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
}
}
catch (Exception e)
{
cach.setState(UnzipCach.State.Error);
//LogManager.GetInstance().LogException(e.Message, e, LogManager.ModuleFilter.RES);
}
if (cach.isError())
{
break;
}
}
cach.setState(UnzipCach.State.Ok);
ret = cach.stop();
callback(1, ret?0:1);
return(ret);
}
}
/// <summary>
/// Extract the contents of a zip file held in a stream.
/// </summary>
/// <param name="inputStream">The seekable input stream containing the zip to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating whether to restore the date and time for extracted files.</param>
/// <param name="isStreamOwner">Flag indicating whether the inputStream will be closed by this method.</param>
public void ExtractZip(Stream inputStream, string targetDirectory,
Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate,
string fileFilter, string directoryFilter, bool restoreDateTime,
bool isStreamOwner)
{
if ((overwrite == Overwrite.Prompt) && (confirmDelegate == null))
{
throw new ArgumentNullException("confirmDelegate");
}
continueRunning_ = true;
overwrite_ = overwrite;
confirmDelegate_ = confirmDelegate;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
restoreDateTimeOnExtract_ = restoreDateTime;
using (zipFile_ = new ZipFile(inputStream))
{
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
zipFile_.IsStreamOwner = isStreamOwner;
IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
var entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
// TODO Path.GetDirectory can fail here on invalid characters.
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) &&
fileFilter_.IsMatch(entry.Name))
{
ExtractEntry(entry);
}
}
else if (entry.IsDirectory)
{
if (directoryFilter_.IsMatch(entry.Name) && CreateEmptyDirectories)
{
ExtractEntry(entry);
}
}
else
{
// Do nothing for volume labels etc...
}
}
}
}
void ExtractZipThread()
{
continueRunning_ = true;
overwrite_ = Overwrite.Always;
confirmDelegate_ = null;
extractNameTransform_ = new WindowsNameTransform(mTmpDirectory);
fileFilter_ = new NameFilter(null);
directoryFilter_ = new NameFilter(null);
restoreDateTimeOnExtract_ = false;
using (zipFile_ = new ZipFile(mInputStream)) {
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
mUnzipSize = (int)zipFile_.unzipSize;
zipFile_.IsStreamOwner = true;
WaitForEndOfFrame w = new WaitForEndOfFrame();
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
// TODO Path.GetDirectory can fail here on invalid characters.
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) && fileFilter_.IsMatch(entry.Name))
{
ExtractEntry(entry);
}
}
else if (entry.IsDirectory)
{
if (directoryFilter_.IsMatch(entry.Name) && CreateEmptyDirectories)
{
ExtractEntry(entry);
}
}
else
{
// Do nothing for volume labels etc...
}
}
mInputStream.Close();
if (mUnzipSize == mUnzipBytes)
{
Directory.Move(mTmpDirectory, mOutDirectory);
mCallback(1f, 0);
}
}
}
public void ExtractZip(string zipFileName, string targetDirectory,
Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate,
string fileFilter, string directoryFilter, bool restoreDateTime)
{
if ((overwrite == Overwrite.Prompt) && (confirmDelegate == null))
{
throw new ArgumentNullException("confirmDelegate");
}
continueRunning_ = true;
overwrite_ = overwrite;
confirmDelegate_ = confirmDelegate;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
restoreDateTimeOnExtract_ = restoreDateTime;
using (zipFile_ = new ZipFile(zipFileName)) {
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) && fileFilter_.IsMatch(entry.Name))
{
ExtractEntry(entry);
}
}
else if (entry.IsDirectory)
{
if (directoryFilter_.IsMatch(entry.Name) && CreateEmptyDirectories)
{
ExtractEntry(entry);
}
}
else
{
}
}
}
}
// TODO: Replace with clean OFS-based zip methods
static void ExtractPackage(IFile wrapFile, IDirectory destinationDirectory)
{
var nt = new WindowsNameTransform(destinationDirectory.Path.FullPath);
using (var zipFile = new ZipFile(wrapFile.OpenRead()))
{
foreach (ZipEntry zipEntry in zipFile)
{
if (zipEntry.IsFile)
{
var filePath = nt.TransformFile(zipEntry.Name);
using (var targetFile = destinationDirectory.FileSystem.GetFile(filePath).MustExist().OpenWrite())
using (var sourceFile = zipFile.GetInputStream(zipEntry))
sourceFile.CopyTo(targetFile);
// TODO: restore last write time here by adding it to OFS
}
}
}
}
// Token: 0x060008FD RID: 2301 RVA: 0x00032FFC File Offset: 0x000311FC
public string TransformFile(string name)
{
if (name != null)
{
name = WindowsNameTransform.MakeValidName(name, this._replacementChar);
if (this._trimIncomingPaths)
{
name = Path.GetFileName(name);
}
if (this._baseDirectory != null)
{
name = Path.Combine(this._baseDirectory, name);
}
}
else
{
name = string.Empty;
}
return(name);
}
public void BasicDirectories()
{
WindowsNameTransform wnt = new WindowsNameTransform();
wnt.TrimIncomingPaths = false;
string tutu = Path.GetDirectoryName("\\bogan\\ping.txt");
TestDirectory(wnt, "d/", "d");
TestDirectory(wnt, "d", "d");
TestDirectory(wnt, "absolute/file2", @"absolute\file2");
const string BaseDir1 = @"C:\Dir";
wnt.BaseDirectory = BaseDir1;
TestDirectory(wnt, "talofa", Path.Combine(BaseDir1, "talofa"));
const string BaseDir2 = @"C:\Dir\";
wnt.BaseDirectory = BaseDir2;
TestDirectory(wnt, "talofa", Path.Combine(BaseDir2, "talofa"));
}
/// <summary>
/// Extract the contents of a zip file held in a stream.
/// </summary>
/// <param name="inputStream">The seekable input stream containing the zip to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating whether to restore the date and time for extracted files.</param>
/// <param name="isStreamOwner">Flag indicating whether the inputStream will be closed by this method.</param>
public void ExtractZip(Stream inputStream, string targetDirectory,
Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate,
string fileFilter, string directoryFilter, bool restoreDateTime,
bool isStreamOwner)
{
if ((overwrite == Overwrite.Prompt) && (confirmDelegate == null))
{
throw new ArgumentNullException("confirmDelegate");
}
continueRunning_ = true;
overwrite_ = overwrite;
confirmDelegate_ = confirmDelegate;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
restoreDateTimeOnExtract_ = restoreDateTime;
using (zipFile_ = new ZipFile(inputStream))
{
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
zipFile_.IsStreamOwner = isStreamOwner;
extractEnum_ = zipFile_.GetEnumerator();
totalCount_ = 0;
while (continueRunning_ && extractEnum_.MoveNext())
{
ZipEntry entry = (ZipEntry)extractEnum_.Current;
totalCount_ += entry.Size;
}
extractEnum_.Reset();
doneCount_ = 0;
ExtractUpdate();
}
}
public bool BeginExtractZipSelf(string orgPath, string tarPath, string filefilter)
{
bool res = true;
try
{
Stream inputStream = File.Open(orgPath, FileMode.Open, FileAccess.Read, FileShare.Read);
continueRunning_ = true;
overwrite_ = Overwrite.Always;
confirmDelegate_ = null;
extractNameTransform_ = new WindowsNameTransform(tarPath);
fileFilter_ = new NameFilter(filefilter);
directoryFilter_ = new NameFilter(null);
//restoreDateTimeOnExtract_ = restoreDateTimeOnExtract_;
zipFile_ = new ZipFile(inputStream);
{
#if !NETCF_1_0
if (password_ != null)
{
zipFile_.Password = password_;
}
#endif
zipFile_.IsStreamOwner = true;
enumerator_ = zipFile_.GetEnumerator();
}
}
catch
{
res = false;
}
return(res);
}
protected static bool ExtractPackage(IFile wrapFile, IDirectory destinationDirectory)
{
try
{
var nt = new WindowsNameTransform(destinationDirectory.Path.FullPath);
using (var zipFile = new ZipFile(wrapFile.OpenRead()))
{
foreach (ZipEntry zipEntry in zipFile)
{
if (zipEntry.IsFile)
{
IFile destinationFile;
if (System.IO.Path.DirectorySeparatorChar == '\\')
destinationFile = destinationDirectory.FileSystem.GetFile(nt.TransformFile(zipEntry.Name));
else
destinationFile = destinationDirectory.GetFile(zipEntry.Name);
using (var targetFile = destinationFile.MustExist().OpenWrite())
using (var sourceFile = zipFile.GetInputStream(zipEntry))
StreamExtensions.CopyTo(sourceFile, targetFile);
// TODO: restore last write time here by adding it to OFS
}
}
}
}
catch (Exception e)
{
return false;
}
return true;
}
object extractZip( object zipFileName, string rootDirectory,IStringFilter nf, IStringFilter df)
{
object ret = null;
WindowsNameTransform extractNameTransform = new WindowsNameTransform(rootDirectory);
Dictionary<string, bool> dirs = new Dictionary<string, bool>(StringComparer.InvariantCultureIgnoreCase);
Stream str;
if (zipFileName is byte[])
str = new MemoryStream((byte[])zipFileName);
else
str=new SeekableStream(Context.OpenStream(zipFileName.ToString()),true);
using (ZipFile zip = new ZipFile(str))
{
if (Password != null)
zip.Password = Context.TransformStr(Password, Transform);
foreach (ZipEntry entry in zip)
{
string targetName = null;
if (entry.IsFile)
{
targetName = extractNameTransform.TransformFile(entry.Name);
if (!UsePath)
targetName = Path.Combine(rootDirectory, Path.GetFileName(targetName));
}
else if (entry.IsDirectory)
{
if (UsePath)
targetName = extractNameTransform.TransformDirectory(entry.Name);
else
targetName = rootDirectory;
}
if (string.IsNullOrEmpty(targetName))
continue;
if (!Hidden)
{
if (isDos(entry) && (((FileAttributes) entry.ExternalFileAttributes) & (FileAttributes.Hidden)) != 0)
continue;
}
if (string.IsNullOrEmpty(entry.Name))
continue;
var n = new ZipFSEntry(entry, ZipTime);
if ((entry.IsFile && df.IsMatch(Path.GetDirectoryName(n.FullName)) && nf.IsMatch(n.Name)) ||
(entry.IsDirectory && df.IsMatch(n.FullName)))
{
object r = extract(zip, rootDirectory, targetName, entry, dirs);
if (r!=null)
return r;
}
}
}
return ret;
}
/// <summary>
/// Extract the contents of a zip file held in a stream.
/// </summary>
/// <param name="inputStream">The seekable input stream containing the zip to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating whether to restore the date and time for extracted files.</param>
/// <param name="isStreamOwner">Flag indicating whether the inputStream will be closed by this method.</param>
public void ExtractZip(Stream inputStream, string targetDirectory,
Overwrite overwrite, ConfirmOverwriteDelegate confirmDelegate,
string fileFilter, string directoryFilter, bool restoreDateTime,
bool isStreamOwner)
{
if ((overwrite == Overwrite.Prompt) && (confirmDelegate == null)) {
throw new ArgumentNullException("confirmDelegate");
}
continueRunning_ = true;
overwrite_ = overwrite;
confirmDelegate_ = confirmDelegate;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
restoreDateTimeOnExtract_ = restoreDateTime;
using (zipFile_ = new ZipFile(inputStream)) {
#if !NETCF_1_0
if (password_ != null) {
zipFile_.Password = password_;
}
#endif
zipFile_.IsStreamOwner = isStreamOwner;
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext()) {
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
// TODO Path.GetDirectory can fail here on invalid characters.
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) && fileFilter_.IsMatch(entry.Name)) {
ExtractEntry(entry);
}
}
else if (entry.IsDirectory) {
if (directoryFilter_.IsMatch(entry.Name) && CreateEmptyDirectories) {
ExtractEntry(entry);
}
}
else {
// Do nothing for volume labels etc...
}
}
}
}
public void ReplacementChecking()
{
WindowsNameTransform wnt = new WindowsNameTransform();
try {
wnt.Replacement = '*';
Assert.Fail("Expected an exception");
}
catch(ArgumentException) {
}
try {
wnt.Replacement = '?';
Assert.Fail("Expected an exception");
}
catch(ArgumentException) {
}
try {
wnt.Replacement = ':';
Assert.Fail("Expected an exception");
}
catch(ArgumentException) {
}
try {
wnt.Replacement = '/';
Assert.Fail("Expected an exception");
}
catch(ArgumentException) {
}
try {
wnt.Replacement = '\\';
Assert.Fail("Expected an exception");
}
catch(ArgumentException) {
}
}
public void Replacement()
{
WindowsNameTransform wnt = new WindowsNameTransform();
wnt.TrimIncomingPaths = false;
TestFile(wnt, "c::", "_");
TestFile(wnt, "c\\/>", @"c\_");
}
public void NameTooLong()
{
WindowsNameTransform wnt = new WindowsNameTransform();
string veryLong = new string('x', 261);
try {
wnt.TransformDirectory(veryLong);
Assert.Fail("Expected an exception");
}
catch (PathTooLongException) {
}
}
public void LengthBoundaryOk()
{
WindowsNameTransform wnt = new WindowsNameTransform();
string veryLong = "c:\\" + new string('x', 260);
try {
string transformed = wnt.TransformDirectory(veryLong);
}
catch {
Assert.Fail("Expected no exception");
}
}
public void BasicFiles()
{
WindowsNameTransform wnt = new WindowsNameTransform();
wnt.TrimIncomingPaths = false;
TestFile(wnt, "Bogan", "Bogan");
TestFile(wnt, "absolute/file2", @"absolute\file2");
TestFile(wnt, "C:/base/////////t", @"base\t");
TestFile(wnt, "//unc/share/zebidi/and/dylan", @"zebidi\and\dylan");
TestFile(wnt, @"\\unc\share\/zebidi\/and\/dylan", @"zebidi\and\dylan");
}
/// <summary>
/// Extract the contents of a zip file.
/// </summary>
/// <param name="zipFileName">The zip file to extract from.</param>
/// <param name="targetDirectory">The directory to save extracted information in.</param>
/// <param name="overwrite">The style of <see cref="Overwrite">overwriting</see> to apply.</param>
/// <param name="confirmDelegate">A delegate to invoke when confirming overwriting.</param>
/// <param name="fileFilter">A filter to apply to files.</param>
/// <param name="directoryFilter">A filter to apply to directories.</param>
/// <param name="restoreDateTime">Flag indicating wether to restore the date and time for extracted files.</param>
public void ExtractZip(string zipFileName, string targetDirectory, string fileFilter, string directoryFilter)
{
continueRunning_ = true;
extractNameTransform_ = new WindowsNameTransform(targetDirectory);
fileFilter_ = new NameFilter(fileFilter);
directoryFilter_ = new NameFilter(directoryFilter);
using (zipFile_ = new ZipFile(zipFileName))
{
IEnumerator enumerator = zipFile_.GetEnumerator();
while (continueRunning_ && enumerator.MoveNext())
{
var entry = (ZipEntry) enumerator.Current;
if (entry.IsFile)
{
// TODO Path.GetDirectory can fail here on invalid characters.
if (directoryFilter_.IsMatch(Path.GetDirectoryName(entry.Name)) &&
fileFilter_.IsMatch(entry.Name))
{
ExtractEntry(entry);
}
}
}
}
}
static void unzipFileThread()
{
//LogManager.GetInstance().LogMessage("unzip begin outpath="+_targetDirectory, LogManager.ModuleFilter.RES);
_callback(0, 0);
bool ret = false;
using (ZipFile zipFile_ = new ZipFile(_inputStream))
{
int totalBytes = (int)zipFile_.unzipSize;
UnzipCach cach = new UnzipCach();
cach.start(totalBytes, _callback);
INameTransform extractNameTransform_ = new WindowsNameTransform(_tmpDirectory);
System.Collections.IEnumerator enumerator = zipFile_.GetEnumerator();
while (enumerator.MoveNext())
{
try
{
ZipEntry entry = (ZipEntry)enumerator.Current;
if (entry.IsFile)
{
string fileName = extractNameTransform_.TransformFile(entry.Name);
string dirName = Path.GetDirectoryName(Path.GetFullPath(fileName));
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
Stream source = zipFile_.GetInputStream(entry);
cach.addFile(fileName, (int)entry.Size, source);
source.Close();
}
else
{
string dirName = extractNameTransform_.TransformDirectory(entry.Name);
if (!Directory.Exists(dirName))
{
Directory.CreateDirectory(dirName);
}
}
}
catch (Exception e)
{
cach.setState(UnzipCach.State.Error);
//LogManager.GetInstance().LogException(e.Message, e, LogManager.ModuleFilter.RES);
}
if (cach.isError())
{
break;
}
}
cach.setState(UnzipCach.State.Ok);
if (cach.stop())
{
try
{
Directory.Move(_tmpDirectory, _targetDirectory);
ret = true;
}
catch (Exception e)
{
//LogManager.GetInstance().LogException("unzip rename dir error.", e);
}
}
_callback(1, ret?0:1);
//LogManager.GetInstance().LogMessage("unzip end", LogManager.ModuleFilter.RES);
_inputStream = null;
_callback = null;
}
}
// Token: 0x060008FE RID: 2302 RVA: 0x0003304C File Offset: 0x0003124C
public static bool IsValidName(string name)
{
return(name != null && name.Length <= 260 && string.Compare(name, WindowsNameTransform.MakeValidName(name, '_')) == 0);
}
public void BasicFiles()
{
var wnt = new WindowsNameTransform();
wnt.TrimIncomingPaths = false;
TestFile(wnt, "Bogan", "Bogan");
TestFile(wnt, "absolute/file2", Path.Combine("absolute", "file2"));
TestFile(wnt, "C:/base/////////t", Path.Combine("base", "t"));
TestFile(wnt, "//unc/share/zebidi/and/dylan", Path.Combine("zebidi", "and", "dylan"));
TestFile(wnt, @"\\unc\share\/zebidi\/and\/dylan", Path.Combine("zebidi", "and", "dylan"));
}
public void BasicDirectories()
{
WindowsNameTransform wnt = new WindowsNameTransform();
wnt.TrimIncomingPaths = false;
string tutu = Path.GetDirectoryName("\\bogan\\ping.txt");
TestDirectory(wnt, "d/", "d");
TestDirectory(wnt, "d", "d");
TestDirectory(wnt, "absolute/file2", @"absolute\file2");
string BaseDir1 = Path.Combine("C:", "Dir");
wnt.BaseDirectory = BaseDir1;
TestDirectory(wnt, "talofa", Path.Combine(BaseDir1 , "talofa"));
string BaseDir2 = string.Format(@"C:{0}Dir{0}", Path.DirectorySeparatorChar);
wnt.BaseDirectory = BaseDir2;
TestDirectory(wnt, "talofa", Path.Combine(BaseDir2, "talofa"));
}
public void Replacement()
{
var wnt = new WindowsNameTransform();
wnt.TrimIncomingPaths = false;
TestFile(wnt, "c::", "_");
TestFile(wnt, "c\\/>", Path.Combine("c", "_"));
}
