[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Dotgnu-pnet-commits] CVS: pnetlib/tests/runtime/System/IO Makefile, NO
|
From: |
Rhys Weatherley <address@hidden> |
|
Subject: |
[Dotgnu-pnet-commits] CVS: pnetlib/tests/runtime/System/IO Makefile, NONE, 1.1 SuiteIO.cs, NONE, 1.1 TestPath.cs, NONE, 1.1 |
|
Date: |
Mon, 18 Aug 2003 02:42:50 -0400 |
Update of /cvsroot/dotgnu-pnet/pnetlib/tests/runtime/System/IO
In directory subversions:/tmp/cvs-serv24933/tests/runtime/System/IO
Added Files:
Makefile SuiteIO.cs TestPath.cs
Log Message:
Rewrite the "System.IO.Path" class and add a large number of test cases for it.
--- NEW FILE ---
all:
(cd ../..; make)
check:
(cd ../..; make check)
--- NEW FILE ---
/*
* SuiteIO.cs - Tests for "System.IO".
*
* Copyright (C) 2003 Southern Storm Software, Pty Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
using CSUnit;
using System;
public class SuiteIO
{
public static TestSuite Suite()
{
TestSuite suite = new TestSuite("I/O Tests");
suite.AddTests(typeof(TestPath));
return suite;
}
}; // class SuiteIO
--- NEW FILE ---
/*
* TestPath.cs - Test the "Path" class.
*
* Copyright (C) 2003 Southern Storm Software, Pty Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
using CSUnit;
using System;
using System.IO;
public class TestPath : TestCase
{
// Constructor.
public TestPath(String name)
: base(name)
{
// Nothing to do here.
}
// Set up for the tests.
protected override void Setup()
{
// Nothing to do here.
}
// Clean up after the tests.
protected override void Cleanup()
{
// Nothing to do here.
}
// Test the path character properties.
public void TestPathCharacters()
{
char sep = Path.DirectorySeparatorChar;
Assert("DirSep", (sep == '/' || sep == '\\'));
sep = Path.AltDirectorySeparatorChar;
Assert("AltDirSep", (sep == '/' || sep == '\\'
|| sep == '\0'));
sep = Path.PathSeparator;
Assert("PathSep", (sep == ':' || sep == ';'));
#if !ECMA_COMPAT
char vsep = Path.VolumeSeparatorChar;
Assert("VolumeSep", (vsep == ':' || vsep ==
'\0'));
if(vsep == ':')
{
Assert("PathSepNotColon", (sep != ':'));
}
#endif
}
// Check two paths for equal, taking separator differences into account.
private void AssertPathEquals(String name, String expected, String
actual)
{
// Check the null cases.
if(expected == null)
{
AssertNull(name + " [1]", actual);
return;
}
AssertNotNull(name + " [2]", actual);
// Check that the path is correctly normalized.
if(Path.DirectorySeparatorChar == '\\')
{
if(actual.IndexOf('/') != -1)
{
Fail(name + " [3]");
}
actual = actual.Replace('\\', '/');
}
else
{
if(actual.IndexOf('\\') != -1)
{
Fail(name + " [4]");
}
}
// Check the paths for equality.
if(String.Compare(expected, actual, true) != 0)
{
AssertEquals(name + " [5]", expected,
actual);
}
}
// Test the Combine method.
public void TestPathCombine()
{
try
{
Path.Combine(null, "foo");
Fail("Combine (1)");
}
catch(ArgumentNullException)
{
// Success.
}
try
{
Path.Combine("foo", null);
Fail("Combine (2)");
}
catch(ArgumentNullException)
{
// Success.
}
AssertPathEquals("Combine (3)", "foo/bar",
Path.Combine("", "foo/bar"));
AssertPathEquals("Combine (4)", "foo/bar",
Path.Combine("foo\\bar", ""));
AssertPathEquals("Combine (5)", "c:",
Path.Combine("/foo", "c:"));
AssertPathEquals("Combine (6)", "/",
Path.Combine("foo", "/"));
AssertPathEquals("Combine (7)", "c:a",
Path.Combine("c:", "a"));
AssertPathEquals("Combine (8)", "c:/a",
Path.Combine("c:\\", "a"));
AssertPathEquals("Combine (9)", "a/b",
Path.Combine("a", "b"));
AssertPathEquals("Combine (10)", "a/b",
Path.Combine("a\\", "b"));
AssertPathEquals("Combine (10)", "a/b/../c",
Path.Combine("a\\", "b/../c"));
}
// Test the GetDirectoryName method.
public void TestPathGetDirectoryName()
{
AssertPathEquals("GetDirectoryName (1)", null,
Path.GetDirectoryName(null));
try
{
Path.GetDirectoryName("");
Fail("GetDirectoryName (2)");
}
catch(ArgumentException)
{
// Success.
}
AssertPathEquals("GetDirectoryName (3)", null,
Path.GetDirectoryName("/"));
AssertPathEquals("GetDirectoryName (4)", "/",
Path.GetDirectoryName("\\foo"));
AssertPathEquals("GetDirectoryName (5)", "",
Path.GetDirectoryName("a"));
AssertPathEquals("GetDirectoryName (6)", "a",
Path.GetDirectoryName("a/b"));
AssertPathEquals("GetDirectoryName (7)", "a",
Path.GetDirectoryName("a/"));
AssertPathEquals("GetDirectoryName (8)", null,
Path.GetDirectoryName("c:"));
AssertPathEquals("GetDirectoryName (9)", null,
Path.GetDirectoryName("c:\\"));
AssertPathEquals("GetDirectoryName (10)", "c:/",
Path.GetDirectoryName("c:\\a"));
AssertPathEquals("GetDirectoryName (10)",
"a/b/c",
Path.GetDirectoryName("a/b/c/d"));
try
{
Path.GetDirectoryName("\\\\foo");
Fail("GetDirectoryName (11)");
}
catch(ArgumentException)
{
// Success.
}
try
{
Path.GetDirectoryName("\\\\foo\\");
Fail("GetDirectoryName (12)");
}
catch(ArgumentException)
{
// Success.
}
AssertPathEquals("GetDirectoryName (13)", null,
Path.GetDirectoryName("\\\\foo\\bar"));
AssertPathEquals("GetDirectoryName (14)",
"//foo/bar",
Path.GetDirectoryName("\\\\foo\\bar\\baz"));
}
// Test the GetFileName method.
public void TestPathGetFileName()
{
AssertNull("GetFileName (1)",
Path.GetFileName(null));
AssertEquals("GetFileName (2)", "",
Path.GetFileName(""));
AssertEquals("GetFileName (3)", "",
Path.GetFileName("/"));
AssertEquals("GetFileName (4)", "a",
Path.GetFileName("a"));
AssertEquals("GetFileName (5)", "b",
Path.GetFileName("a\\b"));
AssertEquals("GetFileName (6)", "",
Path.GetFileName("c:"));
AssertEquals("GetFileName (7)", "",
Path.GetFileName("c:\\"));
AssertEquals("GetFileName (8)", "foo",
Path.GetFileName("\\\\foo"));
AssertEquals("GetFileName (9)", "bar",
Path.GetFileName("\\\\foo\\bar"));
}
// Test the GetFileNameWithoutExtension method.
public void TestPathGetFileNameWithoutExtension()
{
AssertNull("GetFileNameWithoutExtension (1)",
Path.GetFileName(null));
AssertEquals("GetFileNameWithoutExtension (2)",
"",
Path.GetFileNameWithoutExtension(""));
AssertEquals("GetFileNameWithoutExtension (3)",
"",
Path.GetFileNameWithoutExtension("/"));
AssertEquals("GetFileNameWithoutExtension (4)",
"a",
Path.GetFileNameWithoutExtension("a"));
AssertEquals("GetFileNameWithoutExtension (5)",
"b",
Path.GetFileNameWithoutExtension("a\\b"));
AssertEquals("GetFileNameWithoutExtension (6)",
"",
Path.GetFileNameWithoutExtension("c:"));
AssertEquals("GetFileNameWithoutExtension (7)",
"",
Path.GetFileNameWithoutExtension("c:\\"));
AssertEquals("GetFileNameWithoutExtension (8)",
"foo",
Path.GetFileNameWithoutExtension("\\\\foo"));
AssertEquals("GetFileNameWithoutExtension (9)",
"bar",
Path.GetFileNameWithoutExtension("\\\\foo\\bar"));
AssertEquals("GetFileNameWithoutExtension
(10)", "a",
Path.GetFileNameWithoutExtension("a."));
AssertEquals("GetFileNameWithoutExtension
(11)", "a",
Path.GetFileNameWithoutExtension("a.exe"));
AssertEquals("GetFileNameWithoutExtension
(12)", "a",
Path.GetFileNameWithoutExtension("/foo/a.exe"));
AssertEquals("GetFileNameWithoutExtension
(13)", "a.b",
Path.GetFileNameWithoutExtension("a.b.c"));
}
// Test the GetExtension method.
public void TestPathGetExtension()
{
AssertNull("GetExtension (1)",
Path.GetExtension(null));
AssertEquals("GetExtension (2)", "",
Path.GetExtension(""));
AssertEquals("GetExtension (3)", "",
Path.GetExtension("/"));
AssertEquals("GetExtension (4)", "",
Path.GetExtension("a"));
AssertEquals("GetExtension (5)", "",
Path.GetExtension("a\\b"));
AssertEquals("GetExtension (6)", "",
Path.GetExtension("c:"));
AssertEquals("GetExtension (7)", "",
Path.GetExtension("c:\\"));
AssertEquals("GetExtension (8)", "",
Path.GetExtension("\\\\foo"));
AssertEquals("GetExtension (9)", "",
Path.GetExtension("\\\\foo\\bar"));
AssertEquals("GetExtension (10)", "",
Path.GetExtension("a."));
AssertEquals("GetExtension (11)", "exe",
Path.GetExtension("a.exe"));
AssertEquals("GetExtension (12)", "exe",
Path.GetExtension("/foo/a.exe"));
AssertEquals("GetExtension (13)", "c",
Path.GetExtension("a.b.c"));
AssertEquals("GetExtension (14)", "",
Path.GetExtension("a.b."));
}
// Test the GetFullPath method.
public void TestPathGetFullPath()
{
// Make sure that we aren't on drive X, if one
exists
// on this system, to prevent test mismatches
below.
String dir = Directory.GetCurrentDirectory();
if(dir.Length >= 2)
{
if((dir[0] == 'x' || dir[0] == 'X') &&
dir[1] == ':')
{
Directory.SetCurrentDirectory
("c:" +
Path.DirectorySeparatorChar.ToString());
}
}
// Run the tests.
try
{
Path.GetFullPath(null);
Fail("GetFullPath (1)");
}
catch(ArgumentNullException)
{
// Success.
}
try
{
Path.GetFullPath("");
Fail("GetFullPath (2)");
}
catch(ArgumentException)
{
// Success.
}
try
{
// Network share with host, but no root
path.
Path.GetFullPath("\\\\foo");
Fail("GetFullPath (3)");
}
catch(ArgumentException)
{
// Success.
}
AssertPathEquals("GetFullPath (4)", "x:/abc",
Path.GetFullPath("x:\\abc"));
AssertPathEquals("GetFullPath (5)", "x:/abc",
Path.GetFullPath("x:abc"));
AssertPathEquals("GetFullPath (6)", "x:/def",
Path.GetFullPath("x:/abc/../def"));
AssertPathEquals("GetFullPath (7)", "x:/",
Path.GetFullPath("x:"));
AssertPathEquals("GetFullPath (8)", "x:/",
Path.GetFullPath("x:/"));
AssertPathEquals("GetFullPath (9)", "/def",
Path.GetFullPath("/../def"));
AssertPathEquals("GetFullPath (10)",
"//foo/bar",
Path.GetFullPath("\\\\foo\\bar"));
AssertPathEquals("GetFullPath (11)",
"//foo/bar",
Path.GetFullPath("\\\\foo\\bar\\.."));
AssertPathEquals("GetFullPath (12)", "/a/c/e",
Path.GetFullPath("/a/b/.././c/d/../e"));
}
// Test the GetPathRoot method.
public void TestPathGetPathRoot()
{
try
{
Path.GetPathRoot(null);
Fail("GetPathRoot (1)");
}
catch(ArgumentNullException)
{
// Success.
}
try
{
Path.GetPathRoot("");
Fail("GetPathRoot (2)");
}
catch(ArgumentException)
{
// Success.
}
try
{
// Network share with host, but no root
path.
Path.GetPathRoot("\\\\foo");
Fail("GetPathRoot (3)");
}
catch(ArgumentException)
{
// Success.
}
AssertPathEquals("GetPathRoot (4)", "x:/",
Path.GetPathRoot("x:\\abc"));
AssertPathEquals("GetPathRoot (5)", "x:/",
Path.GetPathRoot("x:abc"));
AssertPathEquals("GetPathRoot (6)", "x:/",
Path.GetPathRoot("x:/abc/../def"));
AssertPathEquals("GetPathRoot (7)", "x:/",
Path.GetPathRoot("x:"));
AssertPathEquals("GetPathRoot (8)", "x:/",
Path.GetPathRoot("x:/"));
AssertPathEquals("GetPathRoot (9)", "/",
Path.GetPathRoot("/../def"));
AssertPathEquals("GetPathRoot (10)",
"//foo/bar",
Path.GetPathRoot("\\\\foo\\bar"));
AssertPathEquals("GetPathRoot (11)",
"//foo/bar",
Path.GetPathRoot("\\\\foo\\bar\\.."));
AssertPathEquals("GetPathRoot (12)",
"//foo/bar",
Path.GetPathRoot("\\\\foo\\bar\\baz"));
AssertPathEquals("GetPathRoot (13)", "/",
Path.GetPathRoot("/a/b/.././c/d/../e"));
}
// Test the GetTempPath method.
public void TestPathGetTempPath()
{
String temp = Path.GetTempPath();
AssertNotNull("GetTempPath (1)", temp);
Assert("GetTempPath (2)", temp.Length > 0);
}
// Test the HasExtension method.
public void TestPathHasExtension()
{
Assert("HasExtension (1)",
!Path.HasExtension(null));
Assert("HasExtension (2)",
!Path.HasExtension(""));
Assert("HasExtension (3)",
!Path.HasExtension("/"));
Assert("HasExtension (4)",
!Path.HasExtension("a"));
Assert("HasExtension (5)",
!Path.HasExtension("a\\b"));
Assert("HasExtension (6)",
!Path.HasExtension("c:"));
Assert("HasExtension (7)",
!Path.HasExtension("c:\\"));
Assert("HasExtension (8)",
!Path.HasExtension("\\\\foo"));
Assert("HasExtension (9)",
!Path.HasExtension("\\\\foo\\bar"));
Assert("HasExtension (10)",
!Path.HasExtension("a."));
Assert("HasExtension (11)",
Path.HasExtension("a.exe"));
Assert("HasExtension (12)",
Path.HasExtension("/foo/a.exe"));
Assert("HasExtension (13)",
Path.HasExtension("a.b.c"));
Assert("HasExtension (14)",
!Path.HasExtension("a.b."));
}
// Test the IsPathRooted method.
public void TestPathIsPathRooted()
{
Assert("IsPathRooted (1)",
!Path.IsPathRooted(null));
Assert("IsPathRooted (2)",
Path.IsPathRooted("/"));
Assert("IsPathRooted (3)",
!Path.IsPathRooted("a"));
Assert("IsPathRooted (4)",
!Path.IsPathRooted(""));
Assert("IsPathRooted (5)",
Path.IsPathRooted("c:\\"));
Assert("IsPathRooted (6)",
Path.IsPathRooted("c:"));
Assert("IsPathRooted (7)",
Path.IsPathRooted("\\\\foo"));
}
}; // class TestPath
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Dotgnu-pnet-commits] CVS: pnetlib/tests/runtime/System/IO Makefile, NONE, 1.1 SuiteIO.cs, NONE, 1.1 TestPath.cs, NONE, 1.1,
Rhys Weatherley <address@hidden> <=
- Prev by Date:
[Dotgnu-pnet-commits] CVS: pnetlib/runtime/System/IO Directory.cs, 1.18, 1.19 Path.cs, 1.16, 1.17
- Next by Date:
[Dotgnu-pnet-commits] CVS: pnetlib ChangeLog,1.1265,1.1266
- Previous by thread:
[Dotgnu-pnet-commits] CVS: pnetlib/runtime/System/IO Directory.cs, 1.18, 1.19 Path.cs, 1.16, 1.17
- Next by thread:
[Dotgnu-pnet-commits] CVS: pnetlib ChangeLog,1.1265,1.1266
- Index(es):