shishantbiswas/c3c
1
1
Fork 0
mirror of https://github.com/c3lang/c3c.git synced 2026-02-27 12:01:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

First 0.7 update, removing all deprecated features.

Browse Source
This commit is contained in:
Christoffer Lerno
2025-02-27 14:16:36 +01:00
committed by Christoffer Lerno
parent cff6697818
commit 2a895ec7be
1589 changed files with 2635 additions and 115363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
test/unit/stdlib/io/multireader.c3
View File

@@ -3,13 +3,12 @@ module std::io @test;
fn void test_multireader()
{
MultiReader mr;
mr.init(mem,
mr.tinit(
&&wrap_bytes("foo"),
&&wrap_bytes(" "),
&&wrap_bytes("bar"),
&&wrap_bytes("!"),
);
defer mr.free();
ByteWriter w;
io::copy_to(&mr, w.tinit())!!;

540
test/unit/stdlib/io/path.c3
View File

@@ -2,13 +2,13 @@ module std::io::path @test;
fn void test_dot()
{
Path p = path::new(".")!!;
Path p = path::new(mem, ".")!!;
defer p.free();
assert(@catch(p.parent()));
// It must be possible to form the absolute version.
Path p2 = p.new_absolute()!!;
Path p2 = p.absolute(mem)!!;
p2.free();
p2 = p.new_append("/hello/world")!!;
p2 = p.append(mem, "/hello/world")!!;
if (p2.env == POSIX)
{
assert(p2.str_view() == "hello/world");
@@ -22,357 +22,357 @@ fn void test_dot()
fn void test_parent()
{
Path p = path::new("")!!;
Path p = path::new(mem, "")!!;
assert(@catch(p.parent()));
p.free();
p = path::new("/", path_env: PathEnv.POSIX)!!;
p = path::new(mem, "/", path_env: PathEnv.POSIX)!!;
assert(@catch(p.parent()));
p.free();
p = path::new("/a/b/c", path_env: PathEnv.POSIX)!!;
p = path::new(mem, "/a/b/c", path_env: PathEnv.POSIX)!!;
assert(p.parent().str_view()!! == "/a/b");
p.free();
p = path::new("/a/b/c", path_env: PathEnv.WIN32)!!;
p = path::new(mem, "/a/b/c", path_env: PathEnv.WIN32)!!;
assert(p.parent().str_view()!! == `\a\b`);
p.free();
}
fn void test_path_normalized() => mem::@scoped(allocator::temp())
{
assert(path::new("", path_env: PathEnv.WIN32).str_view()!! == "");
assert(@catch(path::new("1:\\a\\b\\c.txt", path_env: PathEnv.WIN32)));
assert(@catch(path::new(":", path_env: PathEnv.WIN32)));
assert(@catch(path::new("1:", path_env: PathEnv.WIN32)));
assert(@catch(path::new("1:a", path_env: PathEnv.WIN32)));
// assert(@catch(path::new(`\\\a\b\c.txt`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(`\\server\a\b\..\..\..\c`, path_env: PathEnv.WIN32)));
assert(path::new(mem, "", path_env: PathEnv.WIN32).str_view()!! == "");
assert(@catch(path::new(mem, "1:\\a\\b\\c.txt", path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, ":", path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, "1:", path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, "1:a", path_env: PathEnv.WIN32)));
// assert(@catch(path::new(mem, `\\\a\b\c.txt`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, `\\server\a\b\..\..\..\c`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(`\\a`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(`/a/b/../../../c`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(`/a/b/../../../c`, path_env: PathEnv.POSIX)));
assert(@catch(path::new(`/a/b/../../..`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(`/a/b/../../..`, path_env: PathEnv.POSIX)));
assert(@catch(path::new(`/../a`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(`/../a`, path_env: PathEnv.POSIX)));
assert(@catch(path::new(`/..`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(`/..`, path_env: PathEnv.POSIX)));
assert(@catch(path::new(`C:/a/b/../../../c`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(`C:/../a`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(`C:/..`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, `\\a`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, `/a/b/../../../c`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, `/a/b/../../../c`, path_env: PathEnv.POSIX)));
assert(@catch(path::new(mem, `/a/b/../../..`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, `/a/b/../../..`, path_env: PathEnv.POSIX)));
assert(@catch(path::new(mem, `/../a`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, `/../a`, path_env: PathEnv.POSIX)));
assert(@catch(path::new(mem, `/..`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, `/..`, path_env: PathEnv.POSIX)));
assert(@catch(path::new(mem, `C:/a/b/../../../c`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, `C:/../a`, path_env: PathEnv.WIN32)));
assert(@catch(path::new(mem, `C:/..`, path_env: PathEnv.WIN32)));
assert(path::new("/", path_env: PathEnv.POSIX).str_view()!! == "/");
assert(path::new("/./", path_env: PathEnv.POSIX).str_view()!! == "/");
assert(path::new("/foo/../", path_env: PathEnv.POSIX).str_view()!! == "/");
assert(path::new("/foo/bar/../", path_env: PathEnv.POSIX).str_view()!! == "/foo");
assert(path::new("/foo//bar", path_env: PathEnv.POSIX).str_view()!! == "/foo/bar");
assert(path::new("/foo//bar/../", path_env: PathEnv.POSIX).str_view()!! == "/foo");
assert(path::new("/foo/.bar", path_env: PathEnv.POSIX).str_view()!! == "/foo/.bar");
assert(path::new(`\foo\.bar`, path_env: PathEnv.WIN32).str_view()!! == `\foo\.bar`);
assert(path::new("a\\b/c.txt", path_env: PathEnv.WIN32).str_view()!! == `a\b\c.txt`);
assert(path::new("a\\b/c.txt", path_env: PathEnv.POSIX).str_view()!! == "a\\b/c.txt");
assert(path::new("C:\\a\\b/c.txt", path_env: PathEnv.WIN32).str_view()!! == `C:\a\b\c.txt`);
assert(path::new("C:\\a\\b/c.txt", path_env: PathEnv.POSIX).str_view()!! == "C:\\a\\b/c.txt");
assert(path::new(`\\server\a\b/c.txt`, path_env: PathEnv.WIN32).str_view()!! == `\\server\a\b\c.txt`);
assert(path::new(`\\server\a\b/c.txt`, path_env: PathEnv.POSIX).str_view()!! == `\\server\a\b/c.txt`);
assert(path::new(`c:\hello//bar\\\\foo.txt`, path_env: PathEnv.WIN32).str_view()!! == `c:\hello\bar\foo.txt`);
assert(path::new(mem, "/", path_env: PathEnv.POSIX).str_view()!! == "/");
assert(path::new(mem, "/./", path_env: PathEnv.POSIX).str_view()!! == "/");
assert(path::new(mem, "/foo/../", path_env: PathEnv.POSIX).str_view()!! == "/");
assert(path::new(mem, "/foo/bar/../", path_env: PathEnv.POSIX).str_view()!! == "/foo");
assert(path::new(mem, "/foo//bar", path_env: PathEnv.POSIX).str_view()!! == "/foo/bar");
assert(path::new(mem, "/foo//bar/../", path_env: PathEnv.POSIX).str_view()!! == "/foo");
assert(path::new(mem, "/foo/.bar", path_env: PathEnv.POSIX).str_view()!! == "/foo/.bar");
assert(path::new(mem, `\foo\.bar`, path_env: PathEnv.WIN32).str_view()!! == `\foo\.bar`);
assert(path::new(mem, "a\\b/c.txt", path_env: PathEnv.WIN32).str_view()!! == `a\b\c.txt`);
assert(path::new(mem, "a\\b/c.txt", path_env: PathEnv.POSIX).str_view()!! == "a\\b/c.txt");
assert(path::new(mem, "C:\\a\\b/c.txt", path_env: PathEnv.WIN32).str_view()!! == `C:\a\b\c.txt`);
assert(path::new(mem, "C:\\a\\b/c.txt", path_env: PathEnv.POSIX).str_view()!! == "C:\\a\\b/c.txt");
assert(path::new(mem, `\\server\a\b/c.txt`, path_env: PathEnv.WIN32).str_view()!! == `\\server\a\b\c.txt`);
assert(path::new(mem, `\\server\a\b/c.txt`, path_env: PathEnv.POSIX).str_view()!! == `\\server\a\b/c.txt`);
assert(path::new(mem, `c:\hello//bar\\\\foo.txt`, path_env: PathEnv.WIN32).str_view()!! == `c:\hello\bar\foo.txt`);
assert(path::new(`~\a\b/c.txt`, path_env: PathEnv.WIN32).str_view()!! == `~\a\b\c.txt`);
assert(path::new(`~\a\b/c.txt`, path_env: PathEnv.POSIX).str_view()!! == `~\a\b/c.txt`);
assert(path::new(mem, `~\a\b/c.txt`, path_env: PathEnv.WIN32).str_view()!! == `~\a\b\c.txt`);
assert(path::new(mem, `~\a\b/c.txt`, path_env: PathEnv.POSIX).str_view()!! == `~\a\b/c.txt`);
assert(path::new(`a/b/../../../c`, path_env: PathEnv.WIN32).str_view()!! == `..\c`);
assert(path::new(`a/b/../../../c`, path_env: PathEnv.POSIX).str_view()!! == `../c`);
assert(path::new(`a/b/../../..`, path_env: PathEnv.WIN32).str_view()!! == `..`);
assert(path::new(`a/b/../../..`, path_env: PathEnv.POSIX).str_view()!! == `..`);
assert(path::new(`../a`, path_env: PathEnv.WIN32).str_view()!! == `..\a`);
assert(path::new(`../a`, path_env: PathEnv.POSIX).str_view()!! == `../a`);
assert(path::new(`..`, path_env: PathEnv.WIN32).str_view()!! == `..`);
assert(path::new(`..`, path_env: PathEnv.POSIX).str_view()!! == `..`);
assert(path::new(`a/b/../c`, path_env: PathEnv.WIN32).str_view()!! == `a\c`);
assert(path::new(`a/b/../c`, path_env: PathEnv.POSIX).str_view()!! == `a/c`);
assert(path::new(`a/b/../../c`, path_env: PathEnv.WIN32).str_view()!! == `c`);
assert(path::new(`a/b/../../c`, path_env: PathEnv.POSIX).str_view()!! == `c`);
assert(path::new(`a/b/..`, path_env: PathEnv.WIN32).str_view()!! == `a`);
assert(path::new(`a/b/..`, path_env: PathEnv.POSIX).str_view()!! == `a`);
assert(path::new(`a/b/../`, path_env: PathEnv.WIN32).str_view()!! == `a`);
assert(path::new(`a/b/../`, path_env: PathEnv.POSIX).str_view()!! == `a`);
assert(path::new(`a/b/../..`, path_env: PathEnv.WIN32).str_view()!! == ".");
assert(path::new(`a/b/../..`, path_env: PathEnv.POSIX).str_view()!! == ".");
assert(path::new(`a/b/../../`, path_env: PathEnv.WIN32).str_view()!! == ".");
assert(path::new(`a/b/../../`, path_env: PathEnv.POSIX).str_view()!! == ".");
assert(path::new(`a/b/../c/../d`, path_env: PathEnv.WIN32).str_view()!! == `a\d`);
assert(path::new(`a/b/../c/../d`, path_env: PathEnv.POSIX).str_view()!! == `a/d`);
assert(path::new(`a/b/../c/../d/`, path_env: PathEnv.WIN32).str_view()!! == `a\d`);
assert(path::new(`a/b/../c/../d/`, path_env: PathEnv.POSIX).str_view()!! == `a/d`);
assert(path::new(`a/b//d`, path_env: PathEnv.WIN32).str_view()!! == `a\b\d`);
assert(path::new(`a/b//d`, path_env: PathEnv.POSIX).str_view()!! == `a/b/d`);
assert(path::new(`a/b/././.`, path_env: PathEnv.WIN32).str_view()!! == `a\b`);
assert(path::new(`a/b/././.`, path_env: PathEnv.POSIX).str_view()!! == `a/b`);
assert(path::new(`a/b/./././`, path_env: PathEnv.WIN32).str_view()!! == `a\b`);
assert(path::new(`a/b/./././`, path_env: PathEnv.POSIX).str_view()!! == `a/b`);
assert(path::new(`./a/`, path_env: PathEnv.WIN32).str_view()!! == `a`);
assert(path::new(`./a/`, path_env: PathEnv.POSIX).str_view()!! == `a`);
assert(path::new(`./`, path_env: PathEnv.WIN32).str_view()!! == `.`);
assert(path::new(`./`, path_env: PathEnv.POSIX).str_view()!! == `.`);
assert(path::new(`.`, path_env: PathEnv.WIN32).str_view()!! == `.`);
assert(path::new(`.`, path_env: PathEnv.POSIX).str_view()!! == `.`);
assert(path::new(``, path_env: PathEnv.WIN32).str_view()!! == ``);
assert(path::new(``, path_env: PathEnv.POSIX).str_view()!! == ``);
assert(path::new(`/a`, path_env: PathEnv.WIN32).str_view()!! == `\a`);
assert(path::new(`/a`, path_env: PathEnv.POSIX).str_view()!! == `/a`);
assert(path::new(`/a/`, path_env: PathEnv.WIN32).str_view()!! == `\a`);
assert(path::new(`/a/`, path_env: PathEnv.POSIX).str_view()!! == `/a`);
assert(path::new(`/a/b/../c`, path_env: PathEnv.WIN32).str_view()!! == `\a\c`);
assert(path::new(`/a/b/../c`, path_env: PathEnv.POSIX).str_view()!! == `/a/c`);
assert(path::new(`/a/b/../../c`, path_env: PathEnv.WIN32).str_view()!! == `\c`);
assert(path::new(`/a/b/../../c`, path_env: PathEnv.POSIX).str_view()!! == `/c`);
assert(path::new(`/a/b/..`, path_env: PathEnv.WIN32).str_view()!! == `\a`);
assert(path::new(`/a/b/..`, path_env: PathEnv.POSIX).str_view()!! == `/a`);
assert(path::new(`/a/b/../..`, path_env: PathEnv.WIN32).str_view()!! == `\`);
assert(path::new(`/a/b/../..`, path_env: PathEnv.POSIX).str_view()!! == `/`);
assert(path::new(`/a/b/../c/../d`, path_env: PathEnv.WIN32).str_view()!! == `\a\d`);
assert(path::new(`/a/b/../c/../d`, path_env: PathEnv.POSIX).str_view()!! == `/a/d`);
assert(path::new(`/a/b//d`, path_env: PathEnv.WIN32).str_view()!! == `\a\b\d`);
assert(path::new(`/a/b//d`, path_env: PathEnv.POSIX).str_view()!! == `/a/b/d`);
assert(path::new(`/./a/`, path_env: PathEnv.WIN32).str_view()!! == `\a`);
assert(path::new(`/./a/`, path_env: PathEnv.POSIX).str_view()!! == `/a`);
assert(path::new(`/./`, path_env: PathEnv.WIN32).str_view()!! == `\`);
assert(path::new(`/./`, path_env: PathEnv.POSIX).str_view()!! == `/`);
assert(path::new(`/.`, path_env: PathEnv.WIN32).str_view()!! == `\`);
assert(path::new(`/.`, path_env: PathEnv.POSIX).str_view()!! == `/`);
assert(path::new(`/`, path_env: PathEnv.WIN32).str_view()!! == `\`);
assert(path::new(`/`, path_env: PathEnv.POSIX).str_view()!! == `/`);
assert(path::new(`C:/a`, path_env: PathEnv.WIN32).str_view()!! == `C:\a`);
assert(path::new(`C:/a`, path_env: PathEnv.POSIX).str_view()!! == `C:/a`);
assert(path::new(`C:/a/b/../c`, path_env: PathEnv.WIN32).str_view()!! == `C:\a\c`);
assert(path::new(`C:/a/b/../c`, path_env: PathEnv.POSIX).str_view()!! == `C:/a/c`);
assert(path::new(`C:/a/b/../../c`, path_env: PathEnv.WIN32).str_view()!! == `C:\c`);
assert(path::new(`C:/a/b/../../c`, path_env: PathEnv.POSIX).str_view()!! == `C:/c`);
assert(path::new(`C:/a/b/../../../c`, path_env: PathEnv.POSIX).str_view()!! == `c`);
assert(path::new(`C:/a/b/..`, path_env: PathEnv.WIN32).str_view()!! == `C:\a`);
assert(path::new(`C:/a/b/..`, path_env: PathEnv.POSIX).str_view()!! == `C:/a`);
assert(path::new(`C:/a/b/../..`, path_env: PathEnv.WIN32).str_view()!! == `C:\`);
assert(path::new(`C:/a/b/../..`, path_env: PathEnv.POSIX).str_view()!! == `C:`);
assert(path::new(`C:/a/b/../c/../d`, path_env: PathEnv.WIN32).str_view()!! == `C:\a\d`);
assert(path::new(`C:/a/b/../c/../d`, path_env: PathEnv.POSIX).str_view()!! == `C:/a/d`);
assert(path::new(`C:/a/b//d`, path_env: PathEnv.WIN32).str_view()!! == `C:\a\b\d`);
assert(path::new(`C:/a/b//d`, path_env: PathEnv.POSIX).str_view()!! == `C:/a/b/d`);
assert(path::new(`C:/a/b/././.`, path_env: PathEnv.WIN32).str_view()!! == `C:\a\b`);
assert(path::new(`C:/a/b/././.`, path_env: PathEnv.POSIX).str_view()!! == `C:/a/b`);
assert(path::new(`C:/./a`, path_env: PathEnv.WIN32).str_view()!! == `C:\a`);
assert(path::new(`C:/./a`, path_env: PathEnv.POSIX).str_view()!! == `C:/a`);
assert(path::new(`C:/./`, path_env: PathEnv.WIN32).str_view()!! == `C:\`);
assert(path::new(`C:/./`, path_env: PathEnv.POSIX).str_view()!! == `C:`);
assert(path::new(`C:/../a`, path_env: PathEnv.POSIX).str_view()!! == `a`);
assert(path::new(`C:/..`, path_env: PathEnv.POSIX).str_view()!! == `.`);
assert(path::new(`C:/`, path_env: PathEnv.WIN32).str_view()!! == `C:\`);
assert(path::new(`C:/`, path_env: PathEnv.POSIX).str_view()!! == `C:`);
assert(path::new(`C:a`, path_env: PathEnv.WIN32).str_view()!! == `C:a`);
assert(path::new(`C:a`, path_env: PathEnv.POSIX).str_view()!! == `C:a`);
assert(path::new(`C:a/`, path_env: PathEnv.WIN32).str_view()!! == `C:a`);
assert(path::new(`C:a/`, path_env: PathEnv.POSIX).str_view()!! == `C:a`);
assert(path::new(mem, `a/b/../../../c`, path_env: PathEnv.WIN32).str_view()!! == `..\c`);
assert(path::new(mem, `a/b/../../../c`, path_env: PathEnv.POSIX).str_view()!! == `../c`);
assert(path::new(mem, `a/b/../../..`, path_env: PathEnv.WIN32).str_view()!! == `..`);
assert(path::new(mem, `a/b/../../..`, path_env: PathEnv.POSIX).str_view()!! == `..`);
assert(path::new(mem, `../a`, path_env: PathEnv.WIN32).str_view()!! == `..\a`);
assert(path::new(mem, `../a`, path_env: PathEnv.POSIX).str_view()!! == `../a`);
assert(path::new(mem, `..`, path_env: PathEnv.WIN32).str_view()!! == `..`);
assert(path::new(mem, `..`, path_env: PathEnv.POSIX).str_view()!! == `..`);
assert(path::new(mem, `a/b/../c`, path_env: PathEnv.WIN32).str_view()!! == `a\c`);
assert(path::new(mem, `a/b/../c`, path_env: PathEnv.POSIX).str_view()!! == `a/c`);
assert(path::new(mem, `a/b/../../c`, path_env: PathEnv.WIN32).str_view()!! == `c`);
assert(path::new(mem, `a/b/../../c`, path_env: PathEnv.POSIX).str_view()!! == `c`);
assert(path::new(mem, `a/b/..`, path_env: PathEnv.WIN32).str_view()!! == `a`);
assert(path::new(mem, `a/b/..`, path_env: PathEnv.POSIX).str_view()!! == `a`);
assert(path::new(mem, `a/b/../`, path_env: PathEnv.WIN32).str_view()!! == `a`);
assert(path::new(mem, `a/b/../`, path_env: PathEnv.POSIX).str_view()!! == `a`);
assert(path::new(mem, `a/b/../..`, path_env: PathEnv.WIN32).str_view()!! == ".");
assert(path::new(mem, `a/b/../..`, path_env: PathEnv.POSIX).str_view()!! == ".");
assert(path::new(mem, `a/b/../../`, path_env: PathEnv.WIN32).str_view()!! == ".");
assert(path::new(mem, `a/b/../../`, path_env: PathEnv.POSIX).str_view()!! == ".");
assert(path::new(mem, `a/b/../c/../d`, path_env: PathEnv.WIN32).str_view()!! == `a\d`);
assert(path::new(mem, `a/b/../c/../d`, path_env: PathEnv.POSIX).str_view()!! == `a/d`);
assert(path::new(mem, `a/b/../c/../d/`, path_env: PathEnv.WIN32).str_view()!! == `a\d`);
assert(path::new(mem, `a/b/../c/../d/`, path_env: PathEnv.POSIX).str_view()!! == `a/d`);
assert(path::new(mem, `a/b//d`, path_env: PathEnv.WIN32).str_view()!! == `a\b\d`);
assert(path::new(mem, `a/b//d`, path_env: PathEnv.POSIX).str_view()!! == `a/b/d`);
assert(path::new(mem, `a/b/././.`, path_env: PathEnv.WIN32).str_view()!! == `a\b`);
assert(path::new(mem, `a/b/././.`, path_env: PathEnv.POSIX).str_view()!! == `a/b`);
assert(path::new(mem, `a/b/./././`, path_env: PathEnv.WIN32).str_view()!! == `a\b`);
assert(path::new(mem, `a/b/./././`, path_env: PathEnv.POSIX).str_view()!! == `a/b`);
assert(path::new(mem, `./a/`, path_env: PathEnv.WIN32).str_view()!! == `a`);
assert(path::new(mem, `./a/`, path_env: PathEnv.POSIX).str_view()!! == `a`);
assert(path::new(mem, `./`, path_env: PathEnv.WIN32).str_view()!! == `.`);
assert(path::new(mem, `./`, path_env: PathEnv.POSIX).str_view()!! == `.`);
assert(path::new(mem, `.`, path_env: PathEnv.WIN32).str_view()!! == `.`);
assert(path::new(mem, `.`, path_env: PathEnv.POSIX).str_view()!! == `.`);
assert(path::new(mem, ``, path_env: PathEnv.WIN32).str_view()!! == ``);
assert(path::new(mem, ``, path_env: PathEnv.POSIX).str_view()!! == ``);
assert(path::new(mem, `/a`, path_env: PathEnv.WIN32).str_view()!! == `\a`);
assert(path::new(mem, `/a`, path_env: PathEnv.POSIX).str_view()!! == `/a`);
assert(path::new(mem, `/a/`, path_env: PathEnv.WIN32).str_view()!! == `\a`);
assert(path::new(mem, `/a/`, path_env: PathEnv.POSIX).str_view()!! == `/a`);
assert(path::new(mem, `/a/b/../c`, path_env: PathEnv.WIN32).str_view()!! == `\a\c`);
assert(path::new(mem, `/a/b/../c`, path_env: PathEnv.POSIX).str_view()!! == `/a/c`);
assert(path::new(mem, `/a/b/../../c`, path_env: PathEnv.WIN32).str_view()!! == `\c`);
assert(path::new(mem, `/a/b/../../c`, path_env: PathEnv.POSIX).str_view()!! == `/c`);
assert(path::new(mem, `/a/b/..`, path_env: PathEnv.WIN32).str_view()!! == `\a`);
assert(path::new(mem, `/a/b/..`, path_env: PathEnv.POSIX).str_view()!! == `/a`);
assert(path::new(mem, `/a/b/../..`, path_env: PathEnv.WIN32).str_view()!! == `\`);
assert(path::new(mem, `/a/b/../..`, path_env: PathEnv.POSIX).str_view()!! == `/`);
assert(path::new(mem, `/a/b/../c/../d`, path_env: PathEnv.WIN32).str_view()!! == `\a\d`);
assert(path::new(mem, `/a/b/../c/../d`, path_env: PathEnv.POSIX).str_view()!! == `/a/d`);
assert(path::new(mem, `/a/b//d`, path_env: PathEnv.WIN32).str_view()!! == `\a\b\d`);
assert(path::new(mem, `/a/b//d`, path_env: PathEnv.POSIX).str_view()!! == `/a/b/d`);
assert(path::new(mem, `/./a/`, path_env: PathEnv.WIN32).str_view()!! == `\a`);
assert(path::new(mem, `/./a/`, path_env: PathEnv.POSIX).str_view()!! == `/a`);
assert(path::new(mem, `/./`, path_env: PathEnv.WIN32).str_view()!! == `\`);
assert(path::new(mem, `/./`, path_env: PathEnv.POSIX).str_view()!! == `/`);
assert(path::new(mem, `/.`, path_env: PathEnv.WIN32).str_view()!! == `\`);
assert(path::new(mem, `/.`, path_env: PathEnv.POSIX).str_view()!! == `/`);
assert(path::new(mem, `/`, path_env: PathEnv.WIN32).str_view()!! == `\`);
assert(path::new(mem, `/`, path_env: PathEnv.POSIX).str_view()!! == `/`);
assert(path::new(mem, `C:/a`, path_env: PathEnv.WIN32).str_view()!! == `C:\a`);
assert(path::new(mem, `C:/a`, path_env: PathEnv.POSIX).str_view()!! == `C:/a`);
assert(path::new(mem, `C:/a/b/../c`, path_env: PathEnv.WIN32).str_view()!! == `C:\a\c`);
assert(path::new(mem, `C:/a/b/../c`, path_env: PathEnv.POSIX).str_view()!! == `C:/a/c`);
assert(path::new(mem, `C:/a/b/../../c`, path_env: PathEnv.WIN32).str_view()!! == `C:\c`);
assert(path::new(mem, `C:/a/b/../../c`, path_env: PathEnv.POSIX).str_view()!! == `C:/c`);
assert(path::new(mem, `C:/a/b/../../../c`, path_env: PathEnv.POSIX).str_view()!! == `c`);
assert(path::new(mem, `C:/a/b/..`, path_env: PathEnv.WIN32).str_view()!! == `C:\a`);
assert(path::new(mem, `C:/a/b/..`, path_env: PathEnv.POSIX).str_view()!! == `C:/a`);
assert(path::new(mem, `C:/a/b/../..`, path_env: PathEnv.WIN32).str_view()!! == `C:\`);
assert(path::new(mem, `C:/a/b/../..`, path_env: PathEnv.POSIX).str_view()!! == `C:`);
assert(path::new(mem, `C:/a/b/../c/../d`, path_env: PathEnv.WIN32).str_view()!! == `C:\a\d`);
assert(path::new(mem, `C:/a/b/../c/../d`, path_env: PathEnv.POSIX).str_view()!! == `C:/a/d`);
assert(path::new(mem, `C:/a/b//d`, path_env: PathEnv.WIN32).str_view()!! == `C:\a\b\d`);
assert(path::new(mem, `C:/a/b//d`, path_env: PathEnv.POSIX).str_view()!! == `C:/a/b/d`);
assert(path::new(mem, `C:/a/b/././.`, path_env: PathEnv.WIN32).str_view()!! == `C:\a\b`);
assert(path::new(mem, `C:/a/b/././.`, path_env: PathEnv.POSIX).str_view()!! == `C:/a/b`);
assert(path::new(mem, `C:/./a`, path_env: PathEnv.WIN32).str_view()!! == `C:\a`);
assert(path::new(mem, `C:/./a`, path_env: PathEnv.POSIX).str_view()!! == `C:/a`);
assert(path::new(mem, `C:/./`, path_env: PathEnv.WIN32).str_view()!! == `C:\`);
assert(path::new(mem, `C:/./`, path_env: PathEnv.POSIX).str_view()!! == `C:`);
assert(path::new(mem, `C:/../a`, path_env: PathEnv.POSIX).str_view()!! == `a`);
assert(path::new(mem, `C:/..`, path_env: PathEnv.POSIX).str_view()!! == `.`);
assert(path::new(mem, `C:/`, path_env: PathEnv.WIN32).str_view()!! == `C:\`);
assert(path::new(mem, `C:/`, path_env: PathEnv.POSIX).str_view()!! == `C:`);
assert(path::new(mem, `C:a`, path_env: PathEnv.WIN32).str_view()!! == `C:a`);
assert(path::new(mem, `C:a`, path_env: PathEnv.POSIX).str_view()!! == `C:a`);
assert(path::new(mem, `C:a/`, path_env: PathEnv.WIN32).str_view()!! == `C:a`);
assert(path::new(mem, `C:a/`, path_env: PathEnv.POSIX).str_view()!! == `C:a`);
assert(path::new(`C:a/b/../c`, path_env: PathEnv.WIN32).str_view()!! == `C:a\c`);
assert(path::new(`C:a/b/../c`, path_env: PathEnv.POSIX).str_view()!! == `C:a/c`);
assert(path::new(`C:a/b/../../c`, path_env: PathEnv.WIN32).str_view()!! == `C:c`);
assert(path::new(`C:a/b/../../c`, path_env: PathEnv.POSIX).str_view()!! == `c`);
assert(path::new(`C:a/b/..`, path_env: PathEnv.WIN32).str_view()!! == `C:a`);
assert(path::new(`C:a/b/..`, path_env: PathEnv.POSIX).str_view()!! == `C:a`);
assert(path::new(`C:a/b/../..`, path_env: PathEnv.WIN32).str_view()!! == `C:`);
assert(path::new(`C:a/b/../..`, path_env: PathEnv.POSIX).str_view()!! == `.`);
assert(path::new(`C:a/b/../c/../d`, path_env: PathEnv.WIN32).str_view()!! == `C:a\d`);
assert(path::new(`C:a/b/../c/../d`, path_env: PathEnv.POSIX).str_view()!! == `C:a/d`);
assert(path::new(`C:a/b//d`, path_env: PathEnv.WIN32).str_view()!! == `C:a\b\d`);
assert(path::new(`C:a/b//d`, path_env: PathEnv.POSIX).str_view()!! == `C:a/b/d`);
assert(path::new(`C:a/b/././.`, path_env: PathEnv.WIN32).str_view()!! == `C:a\b`);
assert(path::new(`C:a/b/././.`, path_env: PathEnv.POSIX).str_view()!! == `C:a/b`);
assert(path::new(`C:a/b/../../../c`, path_env: PathEnv.WIN32).str_view()!! == `C:..\c`);
assert(path::new(`C:./a`, path_env: PathEnv.WIN32).str_view()!! == `C:a`);
assert(path::new(`C:./a`, path_env: PathEnv.POSIX).str_view()!! == `C:./a`);
assert(path::new(`C:./`, path_env: PathEnv.WIN32).str_view()!! == `C:`);
assert(path::new(`C:./`, path_env: PathEnv.POSIX).str_view()!! == `C:.`);
assert(path::new(`C:../a`, path_env: PathEnv.POSIX).str_view()!! == `C:../a`);
assert(path::new(`C:../a`, path_env: PathEnv.WIN32).str_view()!! == `C:..\a`);
assert(path::new(`C:..`, path_env: PathEnv.POSIX).str_view()!! == `C:..`);
assert(path::new(`C:..`, path_env: PathEnv.WIN32).str_view()!! == `C:..`);
assert(path::new(`C:`, path_env: PathEnv.WIN32).str_view()!! == `C:`);
assert(path::new(`C:`, path_env: PathEnv.POSIX).str_view()!! == `C:`);
assert(path::new(mem, `C:a/b/../c`, path_env: PathEnv.WIN32).str_view()!! == `C:a\c`);
assert(path::new(mem, `C:a/b/../c`, path_env: PathEnv.POSIX).str_view()!! == `C:a/c`);
assert(path::new(mem, `C:a/b/../../c`, path_env: PathEnv.WIN32).str_view()!! == `C:c`);
assert(path::new(mem, `C:a/b/../../c`, path_env: PathEnv.POSIX).str_view()!! == `c`);
assert(path::new(mem, `C:a/b/..`, path_env: PathEnv.WIN32).str_view()!! == `C:a`);
assert(path::new(mem, `C:a/b/..`, path_env: PathEnv.POSIX).str_view()!! == `C:a`);
assert(path::new(mem, `C:a/b/../..`, path_env: PathEnv.WIN32).str_view()!! == `C:`);
assert(path::new(mem, `C:a/b/../..`, path_env: PathEnv.POSIX).str_view()!! == `.`);
assert(path::new(mem, `C:a/b/../c/../d`, path_env: PathEnv.WIN32).str_view()!! == `C:a\d`);
assert(path::new(mem, `C:a/b/../c/../d`, path_env: PathEnv.POSIX).str_view()!! == `C:a/d`);
assert(path::new(mem, `C:a/b//d`, path_env: PathEnv.WIN32).str_view()!! == `C:a\b\d`);
assert(path::new(mem, `C:a/b//d`, path_env: PathEnv.POSIX).str_view()!! == `C:a/b/d`);
assert(path::new(mem, `C:a/b/././.`, path_env: PathEnv.WIN32).str_view()!! == `C:a\b`);
assert(path::new(mem, `C:a/b/././.`, path_env: PathEnv.POSIX).str_view()!! == `C:a/b`);
assert(path::new(mem, `C:a/b/../../../c`, path_env: PathEnv.WIN32).str_view()!! == `C:..\c`);
assert(path::new(mem, `C:./a`, path_env: PathEnv.WIN32).str_view()!! == `C:a`);
assert(path::new(mem, `C:./a`, path_env: PathEnv.POSIX).str_view()!! == `C:./a`);
assert(path::new(mem, `C:./`, path_env: PathEnv.WIN32).str_view()!! == `C:`);
assert(path::new(mem, `C:./`, path_env: PathEnv.POSIX).str_view()!! == `C:.`);
assert(path::new(mem, `C:../a`, path_env: PathEnv.POSIX).str_view()!! == `C:../a`);
assert(path::new(mem, `C:../a`, path_env: PathEnv.WIN32).str_view()!! == `C:..\a`);
assert(path::new(mem, `C:..`, path_env: PathEnv.POSIX).str_view()!! == `C:..`);
assert(path::new(mem, `C:..`, path_env: PathEnv.WIN32).str_view()!! == `C:..`);
assert(path::new(mem, `C:`, path_env: PathEnv.WIN32).str_view()!! == `C:`);
assert(path::new(mem, `C:`, path_env: PathEnv.POSIX).str_view()!! == `C:`);
assert(path::new(`\\server\foo/a`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a`);
assert(path::new(`\\server\foo/a`, path_env: PathEnv.POSIX).str_view()!! == `\\server\foo/a`);
assert(path::new(`\\server\foo\a\b\..\c`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a\c`);
assert(path::new(`\\server\foo\a\b\..\..\c`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\c`);
assert(path::new(`\\server\foo\a\b\..`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a`);
assert(path::new(`\\server\foo\a\..`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\`);
assert(path::new(`\\server\foo\a\b\..\c\..\d`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a\d`);
assert(path::new(`\\server\foo\a\b\\d`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a\b\d`);
assert(path::new(`\\server\foo\a\b\.\.\.`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a\b`);
assert(path::new(`\\server\foo\.\a`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a`);
assert(path::new(`\\server\foo\.`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\`);
assert(path::new(`\\server\foo\`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\`);
assert(path::new(mem, `\\server\foo/a`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a`);
assert(path::new(mem, `\\server\foo/a`, path_env: PathEnv.POSIX).str_view()!! == `\\server\foo/a`);
assert(path::new(mem, `\\server\foo\a\b\..\c`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a\c`);
assert(path::new(mem, `\\server\foo\a\b\..\..\c`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\c`);
assert(path::new(mem, `\\server\foo\a\b\..`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a`);
assert(path::new(mem, `\\server\foo\a\..`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\`);
assert(path::new(mem, `\\server\foo\a\b\..\c\..\d`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a\d`);
assert(path::new(mem, `\\server\foo\a\b\\d`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a\b\d`);
assert(path::new(mem, `\\server\foo\a\b\.\.\.`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a\b`);
assert(path::new(mem, `\\server\foo\.\a`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\a`);
assert(path::new(mem, `\\server\foo\.`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\`);
assert(path::new(mem, `\\server\foo\`, path_env: PathEnv.WIN32).str_view()!! == `\\server\foo\`);
}
fn void test_extension() => mem::@scoped(allocator::temp())
{
assert(@catch(path::new(`C:`, path_env: PathEnv.WIN32).extension()));
assert(@catch(path::new(`C:`, path_env: PathEnv.POSIX).extension()));
assert(@catch(path::new(`file`, path_env: PathEnv.WIN32).extension()));
assert(@catch(path::new(`file`, path_env: PathEnv.POSIX).extension()));
assert(@catch(path::new(`C:\temp\foo.bar\README`, path_env: PathEnv.WIN32).extension()));
assert(@catch(path::new(mem, `C:`, path_env: PathEnv.WIN32).extension()));
assert(@catch(path::new(mem, `C:`, path_env: PathEnv.POSIX).extension()));
assert(@catch(path::new(mem, `file`, path_env: PathEnv.WIN32).extension()));
assert(@catch(path::new(mem, `file`, path_env: PathEnv.POSIX).extension()));
assert(@catch(path::new(mem, `C:\temp\foo.bar\README`, path_env: PathEnv.WIN32).extension()));
assert(path::new_windows("file.txt").extension()!! == "txt");
assert(path::new_posix("file.txt").extension()!! == "txt");
assert(path::for_windows(mem, "file.txt").extension()!! == "txt");
assert(path::for_posix(mem, "file.txt").extension()!! == "txt");
assert(path::new_windows("a/b/file.txt").extension()!! == "txt");
assert(path::new_posix("a/b/file.txt").extension()!! == "txt");
assert(path::for_windows(mem, "a/b/file.txt").extension()!! == "txt");
assert(path::for_posix(mem, "a/b/file.txt").extension()!! == "txt");
assert(path::new_windows("a\\b\\file.txt").extension()!! == "txt");
assert(path::for_windows(mem, "a\\b\\file.txt").extension()!! == "txt");
assert(path::new_windows("a.b/file.txt").extension()!! == "txt");
assert(path::new_posix("a.b/file.txt").extension()!! == "txt");
assert(path::new_windows("a.b/file.txt").extension()!! == "txt");
assert(path::new_posix("a.b/file.txt").extension()!! == "txt");
assert(path::for_windows(mem, "a.b/file.txt").extension()!! == "txt");
assert(path::for_posix(mem, "a.b/file.txt").extension()!! == "txt");
assert(path::for_windows(mem, "a.b/file.txt").extension()!! == "txt");
assert(path::for_posix(mem, "a.b/file.txt").extension()!! == "txt");
assert(path::new_windows("a.b\\file.txt").extension()!! == "txt");
assert(path::for_windows(mem, "a.b\\file.txt").extension()!! == "txt");
assert(path::new_windows("domain.dot.com").extension()!! == "com");
assert(path::new_posix("domain.dot.com").extension()!! == "com");
assert(path::for_windows(mem, "domain.dot.com").extension()!! == "com");
assert(path::for_posix(mem, "domain.dot.com").extension()!! == "com");
assert(path::new_windows("image.jpeg").extension()!! == "jpeg");
assert(path::new_posix("image.jpeg").extension()!! == "jpeg");
assert(path::for_windows(mem, "image.jpeg").extension()!! == "jpeg");
assert(path::for_posix(mem, "image.jpeg").extension()!! == "jpeg");
assert(path::new_windows("../filename.ext").extension()!! == "ext");
assert(path::new_posix("../filename.ext").extension()!! == "ext");
assert(path::for_windows(mem, "../filename.ext").extension()!! == "ext");
assert(path::for_posix(mem, "../filename.ext").extension()!! == "ext");
}
fn void test_has_extension() => mem::@scoped(allocator::temp())
{
assert(!path::new(`C:\temp\foo.bar\README`, path_env: PathEnv.WIN32)!!.has_extension(`bar\README`));
assert(!path::new(mem, `C:\temp\foo.bar\README`, path_env: PathEnv.WIN32)!!.has_extension(`bar\README`));
assert(path::new_windows("file.txt")!!.has_extension("txt"));
assert(path::new_posix("file.txt")!!.has_extension("txt"));
assert(path::for_windows(mem, "file.txt")!!.has_extension("txt"));
assert(path::for_posix(mem, "file.txt")!!.has_extension("txt"));
assert(path::new_windows("a/b/file.txt")!!.has_extension("txt"));
assert(path::new_posix("a/b/file.txt")!!.has_extension("txt"));
assert(path::for_windows(mem, "a/b/file.txt")!!.has_extension("txt"));
assert(path::for_posix(mem, "a/b/file.txt")!!.has_extension("txt"));
assert(path::new_windows("a\\b\\file.txt")!!.has_extension("txt"));
assert(path::for_windows(mem, "a\\b\\file.txt")!!.has_extension("txt"));
assert(path::new_windows("a.b/file.txt")!!.has_extension("txt"));
assert(path::new_posix("a.b/file.txt")!!.has_extension("txt"));
assert(path::new_windows("a.b/file.txt")!!.has_extension("txt"));
assert(path::new_posix("a.b/file.txt")!!.has_extension("txt"));
assert(path::for_windows(mem, "a.b/file.txt")!!.has_extension("txt"));
assert(path::for_posix(mem, "a.b/file.txt")!!.has_extension("txt"));
assert(path::for_windows(mem, "a.b/file.txt")!!.has_extension("txt"));
assert(path::for_posix(mem, "a.b/file.txt")!!.has_extension("txt"));
assert(path::new_windows("a.b\\file.txt")!!.has_extension("txt"));
assert(path::for_windows(mem, "a.b\\file.txt")!!.has_extension("txt"));
assert(path::new_windows("domain.dot.com")!!.has_extension("com"));
assert(path::new_posix("domain.dot.com")!!.has_extension("com"));
assert(path::for_windows(mem, "domain.dot.com")!!.has_extension("com"));
assert(path::for_posix(mem, "domain.dot.com")!!.has_extension("com"));
assert(path::new_windows("image.jpeg")!!.has_extension("jpeg"));
assert(path::new_posix("image.jpeg")!!.has_extension("jpeg"));
assert(path::for_windows(mem, "image.jpeg")!!.has_extension("jpeg"));
assert(path::for_posix(mem, "image.jpeg")!!.has_extension("jpeg"));
assert(path::new_windows("../filename.ext")!!.has_extension("ext"));
assert(path::new_posix("../filename.ext")!!.has_extension("ext"));
assert(path::for_windows(mem, "../filename.ext")!!.has_extension("ext"));
assert(path::for_posix(mem, "../filename.ext")!!.has_extension("ext"));
}
fn void test_basename() => mem::@scoped(allocator::temp())
{
assert(path::new_windows("file.txt").basename()!! == "file.txt");
assert(path::new_posix("file.txt").basename()!! == "file.txt");
assert(path::for_windows(mem, "file.txt").basename()!! == "file.txt");
assert(path::for_posix(mem, "file.txt").basename()!! == "file.txt");
assert(path::new_windows("a/b/file.txt").basename()!! == "file.txt");
assert(path::new_posix("a/b/file.txt").basename()!! == "file.txt");
assert(path::for_windows(mem, "a/b/file.txt").basename()!! == "file.txt");
assert(path::for_posix(mem, "a/b/file.txt").basename()!! == "file.txt");
assert(path::new_windows("a.b/file.txt").basename()!! == "file.txt");
assert(path::new_posix("a.b/file.txt").basename()!! == "file.txt");
assert(path::for_windows(mem, "a.b/file.txt").basename()!! == "file.txt");
assert(path::for_posix(mem, "a.b/file.txt").basename()!! == "file.txt");
assert(path::new_windows("a.b/file.txt").basename()!! == "file.txt");
assert(path::new_posix("a.b/file.txt").basename()!! == "file.txt");
assert(path::for_windows(mem, "a.b/file.txt").basename()!! == "file.txt");
assert(path::for_posix(mem, "a.b/file.txt").basename()!! == "file.txt");
assert(path::new_windows("../filename.ext").basename()!! == "filename.ext");
assert(path::new_posix("../filename.ext").basename()!! == "filename.ext");
assert(path::for_windows(mem, "../filename.ext").basename()!! == "filename.ext");
assert(path::for_posix(mem, "../filename.ext").basename()!! == "filename.ext");
assert(path::new_windows("C:").basename()!! == "");
assert(path::new_posix("C:").basename()!! == "C:");
assert(path::for_windows(mem, "C:").basename()!! == "");
assert(path::for_posix(mem, "C:").basename()!! == "C:");
assert(path::new_windows("../..").basename()!! == "..");
assert(path::new_posix("../..").basename()!! == "..");
assert(path::for_windows(mem, "../..").basename()!! == "..");
assert(path::for_posix(mem, "../..").basename()!! == "..");
assert(path::new_windows(`\\server\abc`).basename()!! == "");
assert(path::new_posix(`\\server\abc`).basename()!! == `\\server\abc`);
assert(path::for_windows(mem, `\\server\abc`).basename()!! == "");
assert(path::for_posix(mem, `\\server\abc`).basename()!! == `\\server\abc`);
}
fn void test_dirname() => mem::@scoped(allocator::temp())
{
assert(path::new_posix("").dirname()!! == ".");
assert(path::new_posix("/file").dirname()!! == "/");
assert(path::new_posix("///").dirname()!! == "/");
assert(path::new_windows("d:").dirname()!! == "d:");
assert(path::new_windows("d:file").dirname()!! == "d:");
assert(path::new_windows(`d:\file`).dirname()!! == `d:\`);
assert(path::for_posix(mem, "").dirname()!! == ".");
assert(path::for_posix(mem, "/file").dirname()!! == "/");
assert(path::for_posix(mem, "///").dirname()!! == "/");
assert(path::for_windows(mem, "d:").dirname()!! == "d:");
assert(path::for_windows(mem, "d:file").dirname()!! == "d:");
assert(path::for_windows(mem, `d:\file`).dirname()!! == `d:\`);
assert(path::new_windows("file.txt").dirname()!! == ".");
assert(path::new_posix("file.txt").dirname()!! == ".");
assert(path::for_windows(mem, "file.txt").dirname()!! == ".");
assert(path::for_posix(mem, "file.txt").dirname()!! == ".");
assert(path::new_windows("a/b/file.txt").dirname()!! == `a\b`);
assert(path::new_posix("a/b/file.txt").dirname()!! == "a/b");
assert(path::for_windows(mem, "a/b/file.txt").dirname()!! == `a\b`);
assert(path::for_posix(mem, "a/b/file.txt").dirname()!! == "a/b");
assert(path::new_windows("a.b/file.txt").dirname()!! == "a.b");
assert(path::new_posix("a.b/file.txt").dirname()!! == "a.b");
assert(path::for_windows(mem, "a.b/file.txt").dirname()!! == "a.b");
assert(path::for_posix(mem, "a.b/file.txt").dirname()!! == "a.b");
assert(path::new_windows("../filename.ext").dirname()!! == "..");
assert(path::new_posix("../filename.ext").dirname()!! == "..");
assert(path::for_windows(mem, "../filename.ext").dirname()!! == "..");
assert(path::for_posix(mem, "../filename.ext").dirname()!! == "..");
assert(path::new_windows("C:").dirname()!! == "C:");
assert(path::new_posix("C:").dirname()!! == ".");
assert(path::for_windows(mem, "C:").dirname()!! == "C:");
assert(path::for_posix(mem, "C:").dirname()!! == ".");
assert(path::new_windows("C:/").dirname()!! == "C:\\");
assert(path::new_posix("C:/").dirname()!! == ".");
assert(path::for_windows(mem, "C:/").dirname()!! == "C:\\");
assert(path::for_posix(mem, "C:/").dirname()!! == ".");
assert(path::new_windows("C:/a").dirname()!! == "C:\\");
assert(path::new_posix("C:/a").dirname()!! == "C:");
assert(path::for_windows(mem, "C:/a").dirname()!! == "C:\\");
assert(path::for_posix(mem, "C:/a").dirname()!! == "C:");
assert(path::new_windows("../..").dirname()!! == "..");
assert(path::new_posix("../..").dirname()!! == "..");
assert(path::for_windows(mem, "../..").dirname()!! == "..");
assert(path::for_posix(mem, "../..").dirname()!! == "..");
assert(path::new_windows(`\\server\share\dir\file`).dirname()!! == `\\server\share\dir`);
assert(path::new_windows(`\\server\share\file`).dirname()!! == `\\server\share`);
assert(path::new_windows(`\\server\share\`).dirname()!! == `\\server\share`);
assert(path::new_windows(`\\server\share`).dirname()!! == `\\server\share`);
assert(path::new_posix(`\\server\`).dirname()!! == `.`);
assert(path::for_windows(mem, `\\server\share\dir\file`).dirname()!! == `\\server\share\dir`);
assert(path::for_windows(mem, `\\server\share\file`).dirname()!! == `\\server\share`);
assert(path::for_windows(mem, `\\server\share\`).dirname()!! == `\\server\share`);
assert(path::for_windows(mem, `\\server\share`).dirname()!! == `\\server\share`);
assert(path::for_posix(mem, `\\server\`).dirname()!! == `.`);
}
fn void test_path_volume() => mem::@scoped(allocator::temp())
{
assert(path::new_windows(`C:\abs`).volume_name()!! == `C:`);
assert(path::new_windows(`C:abs`).volume_name()!! == `C:`);
assert(path::new_posix(`C:/abs`).volume_name()!! == ``);
assert(path::new_posix(`C:abs`).volume_name()!! == ``);
assert(path::new_windows(`\\server\foo`).volume_name()!! == `\\server\foo`);
assert(path::new_windows(`\\server\foo\abc`).volume_name()!! == `\\server\foo`);
assert(path::for_windows(mem, `C:\abs`).volume_name()!! == `C:`);
assert(path::for_windows(mem, `C:abs`).volume_name()!! == `C:`);
assert(path::for_posix(mem, `C:/abs`).volume_name()!! == ``);
assert(path::for_posix(mem, `C:abs`).volume_name()!! == ``);
assert(path::for_windows(mem, `\\server\foo`).volume_name()!! == `\\server\foo`);
assert(path::for_windows(mem, `\\server\foo\abc`).volume_name()!! == `\\server\foo`);
}
fn void test_path_is_absolute() => mem::@scoped(allocator::temp())
{
assert(!path::new_posix("").is_absolute()!!);
assert(path::new_posix("/").is_absolute()!!);
assert(path::new_posix("/a/b").is_absolute()!!);
assert(!path::new_posix("a/b").is_absolute()!!);
assert(!path::for_posix(mem, "").is_absolute()!!);
assert(path::for_posix(mem, "/").is_absolute()!!);
assert(path::for_posix(mem, "/a/b").is_absolute()!!);
assert(!path::for_posix(mem, "a/b").is_absolute()!!);
assert(!path::new_windows(`C:`).is_absolute()!!);
assert(path::new_windows(`C:\abs`).is_absolute()!!);
assert(!path::new_windows(`C:abs`).is_absolute()!!);
assert(path::new_windows(`\\server\foo`).is_absolute()!!);
assert(path::new_windows(`\\server\foo\abc`).is_absolute()!!);
assert(!path::for_windows(mem, `C:`).is_absolute()!!);
assert(path::for_windows(mem, `C:\abs`).is_absolute()!!);
assert(!path::for_windows(mem, `C:abs`).is_absolute()!!);
assert(path::for_windows(mem, `\\server\foo`).is_absolute()!!);
assert(path::for_windows(mem, `\\server\foo\abc`).is_absolute()!!);
}
fn void test_path_absolute() => mem::@scoped(allocator::temp())
{
$if env::WIN32:
assert(path::new_windows(`C:\abs`).new_absolute()!!.str_view() == `C:\abs`);
assert(path::for_windows(mem, `C:\abs`).absolute(mem, )!!.str_view() == `C:\abs`);
$else
assert(path::new_posix("/").new_absolute()!!.str_view() == "/");
assert(path::new_posix(".").new_absolute()!!.str_view() == path::temp_cwd()!!.str_view());
assert(path::for_posix(mem, "/").absolute(mem, )!!.str_view() == "/");
assert(path::for_posix(mem, ".").absolute(mem, )!!.str_view() == path::tcwd()!!.str_view());
$endif
}

54
test/unit/stdlib/io/printf.c3
View File

@@ -3,19 +3,19 @@ module std::io @test;
fn void printf_int()
{
String s;
s = string::new_format("[%-10d]", 78);
s = string::format(mem, "[%-10d]", 78);
assert(s == "[78 ]");
free(s);
s = string::new_format("[%10d]", 78);
s = string::format(mem, "[%10d]", 78);
assert(s == "[ 78]");
free(s);
s = string::new_format("[%010d]", 78);
s = string::format(mem, "[%010d]", 78);
assert(s == "[0000000078]");
free(s);
s = string::new_format("[%+10d]", 78);
s = string::format(mem, "[%+10d]", 78);
assert(s == "[ +78]");
free(s);
s = string::new_format("[%-+10d]", 78);
s = string::format(mem, "[%-+10d]", 78);
assert(s == "[+78 ]");
free(s);
}
@@ -23,69 +23,69 @@ fn void printf_int()
fn void printf_a()
{
String s;
s = string::new_format("%08.2a", 234.125);
s = string::format(mem, "%08.2a", 234.125);
assert(s == "0x1.d4p+7", "got '%s'; want '0x1.d4p+7'", s);
free(s);
s = string::new_format("%a", 234.125);
s = string::format(mem, "%a", 234.125);
assert(s == "0x1.d44p+7", "got '%s'; want '0x1.d44p+7'", s);
free(s);
s = string::new_format("%A", 234.125);
s = string::format(mem, "%A", 234.125);
assert(s == "0X1.D44P+7", "got '%s'; want '0X1.D44P+7'", s);
free(s);
s = string::new_format("%20a", 234.125);
s = string::format(mem, "%20a", 234.125);
assert(s == " 0x1.d44p+7", "got '%s'; want ' 0x1.d44p+7'", s);
free(s);
s = string::new_format("%-20a", 234.125);
s = string::format(mem, "%-20a", 234.125);
assert(s == "0x1.d44p+7 ", "got '%s'; want '0x1.d44p+7 '", s);
free(s);
s = string::new_format("%-20s", "hello world");
s = string::format(mem, "%-20s", "hello world");
assert(s == "hello world ", "got '%s'; want 'hello world '", s);
free(s);
s = string::new_format("%20s", "hello world");
s = string::format(mem, "%20s", "hello world");
assert(s == " hello world", "got '%s'; want ' hello world'", s);
free(s);
String str = "hello!";
s = string::new_format("%-20s", str);
s = string::format(mem, "%-20s", str);
assert(s == "hello! ", "got '%s'; want 'hello! '", s);
free(s);
s = string::new_format("%20s", str);
s = string::format(mem, "%20s", str);
assert(s == " hello!", "got '%s'; want ' hello!'", s);
free(s);
int[2] a = { 12, 23 };
s = string::new_format("%-20s", a);
s = string::format(mem, "%-20s", a);
assert(s == "[12, 23] ", "got '%s'; want '[12, 23] '", s);
free(s);
s = string::new_format("%20s", a);
s = string::format(mem, "%20s", a);
assert(s == " [12, 23]", "got '%s'; want ' [12, 23]'", s);
free(s);
s = string::new_format("%-20s", a[..]);
s = string::format(mem, "%-20s", a[..]);
assert(s == "[12, 23] ", "got '%s'; want '[12, 23] '", s);
free(s);
s = string::new_format("%20s", a[..]);
s = string::format(mem, "%20s", a[..]);
assert(s == " [12, 23]", "got '%s'; want ' [12, 23]'", s);
free(s);
float[2] f = { 12.0, 23.0 };
s = string::new_format("%-24s", f);
s = string::format(mem, "%-24s", f);
assert(s == "[12.000000, 23.000000] ", "got '%s'; want '[12.000000, 23.000000] '", s);
free(s);
s = string::new_format("%24s", f);
s = string::format(mem, "%24s", f);
assert(s == " [12.000000, 23.000000]", "got '%s'; want ' [12.000000, 23.000000]'", s);
free(s);
int[<2>] vec = { 12, 23 };
s = string::new_format("%-20s", vec);
s = string::format(mem, "%-20s", vec);
assert(s == "[<12, 23>] ", "got '%s'; want '[<12, 23>] '", s);
free(s);
s = string::new_format("%20s", vec);
s = string::format(mem, "%20s", vec);
assert(s == " [<12, 23>]", "got '%s'; want ' [<12, 23>]'", s);
free(s);
String ss = "hello world";
s = string::new_format("%.4s %.5s", ss, ss);
s = string::format(mem, "%.4s %.5s", ss, ss);
assert(s == "hell hello", "got '%s'; want 'hell hello'", s);
free(s);
}
@@ -100,17 +100,17 @@ fn void printf_enum()
{
String s;
s = string::new_format("%s", PrintfTest.ENUMA);
s = string::format(mem, "%s", PrintfTest.ENUMA);
assert(s == "ENUMA", "got '%s'; want 'ENUMA'", s);
free(s);
s = string::new_format("%s", PrintfTest.ENUMB);
s = string::format(mem, "%s", PrintfTest.ENUMB);
assert(s == "ENUMB", "got '%s'; want 'ENUMB'", s);
free(s);
s = string::new_format("%d", PrintfTest.ENUMA);
s = string::format(mem, "%d", PrintfTest.ENUMA);
assert(s == "0", "got '%s'; want '0'", s);
free(s);
s = string::new_format("%d", PrintfTest.ENUMB);
s = string::format(mem, "%d", PrintfTest.ENUMB);
assert(s == "1", "got '%s'; want '1'", s);
free(s);
}

2
test/unit/stdlib/io/scanner.c3
View File

@@ -1,7 +1,7 @@
module std::io @test;
import std::collections::list;
def Results = List(<String>);
def Results = List{String};
struct ScanTest
{