diff options
Diffstat (limited to 'src/Fsys.zig')
| -rw-r--r-- | src/Fsys.zig | 582 |
1 files changed, 582 insertions, 0 deletions
diff --git a/src/Fsys.zig b/src/Fsys.zig new file mode 100644 index 0000000..224087b --- /dev/null +++ b/src/Fsys.zig @@ -0,0 +1,582 @@ +//! A blocking 9P2000 client: one connection to one tree, its calls made +//! one at a time from one thread, each waiting for its answer +//! (plan9port's lib9pclient `CFsys`). `Client` speaks the protocol; this +//! adds the socket, the fids and the server's words. A refusal is +//! `error.Refused` and `said()` is what the server said: the string a +//! mount would have turned into an errno. +//! +//! Paths are slash-separated names from the tree's root ("pane/3/body"). +//! The walk to a path goes out with the request that uses it, in one +//! write (a walk never parks, so the request always follows it), and a +//! fid is let go of without waiting for the answer: an open, a stat or a +//! remove costs one round trip. The buffers are in the struct +//! (2 × `msize`): an `Fsys` stays where it is while it is used. +const std = @import("std"); +const Io = std.Io; +const c9 = @import("root.zig"); +const wire = @import("wire.zig"); +const client = @import("client.zig"); +const transport = @import("transport.zig"); +const post = @import("post.zig"); +const fs = @import("fs.zig"); +const Client = client.Client; +const Stat = wire.Stat; +const Qid = wire.Qid; +const max_welem = wire.max_welem; + +const Fsys = @This(); + +/// The largest message asked for; the server may answer less. +pub const msize: u32 = 65536; + +pub const Error = error{ + /// The server refused: `said()` holds its words. + Refused, + /// The connection ended. + Hangup, + /// The server broke the protocol, or a request could not be made + /// (a name with a slash or longer than a message). + Botch, +}; + +io: Io, +stream: Io.net.Stream, +cl: Client, +in: [msize]u8, +out: [msize]u8, +next_fid: u32, +/// Clunks sent and not waited for, a bit per tag: their answers are +/// dropped as they come. +unwaited: u32, +/// The walk sent ahead of the request that uses its fid, and the names +/// it asked for: `rpc` checks its answer on the way to the request's. +walk_tag: u16, +walk_asked: usize, +words: [fs.errmax]u8, +words_len: usize, + +/// Speaks 9P on `stream`, which is this one's from here (`close`), on a +/// refusal too: the version, then an attach as `uname` to the tree's root. +pub fn init(f: *Fsys, io: Io, stream: Io.net.Stream, uname: []const u8) Error!void { + f.io = io; + f.stream = stream; + f.cl = .init(.{ .in = &f.in, .out = &f.out }); + f.next_fid = 1; + f.unwaited = 0; + f.walk_tag = wire.notag; + f.walk_asked = 0; + f.words_len = 0; + errdefer f.close(); + const v = (try f.rpc(.{ .version = .{ .msize = msize } })).version; + if (!std.mem.eql(u8, v.version, "9P2000")) return f.refuse("the server does not speak 9P2000"); + _ = try f.rpc(.{ .attach = .{ .fid = 0, .uname = uname } }); +} + +pub const DialError = error{ + /// Not `unix!PATH`, `tcp!HOST!PORT`, an absolute path or a legal name. + BadAddress, + /// $XDG_RUNTIME_DIR is unset, so there is no registry to find a name in. + NotRuntimeDir, +} || Error || Io.net.IpAddress.ConnectError || Io.net.UnixAddress.ConnectError || Io.net.UnixAddress.InitError; + +/// Dials `dest` and attaches (`init`). `unix!PATH`, or a path starting +/// with a slash, is a Unix socket; `tcp!HOST!PORT` a numeric address; +/// anything else a name posted in the registry (`post`), which may name +/// an entry of a subdirectory: `pardes/main` is +/// `$XDG_RUNTIME_DIR/9p/pardes/main`. +pub fn dial(f: *Fsys, io: Io, env: post.Env, dest: []const u8, uname: []const u8) DialError!void { + var buf: [transport.sun_path_len]u8 = undefined; + const address: transport.Address = if (std.mem.startsWith(u8, dest, "tcp!")) blk: { + const bang = std.mem.lastIndexOfScalar(u8, dest, '!').?; + if (bang < 5) return error.BadAddress; + const port = std.fmt.parseInt(u16, dest[bang + 1 ..], 10) catch return error.BadAddress; + break :blk .{ .tcp = Io.net.IpAddress.parse(dest[4..bang], port) catch return error.BadAddress }; + } else if (std.mem.startsWith(u8, dest, "unix!") or std.mem.startsWith(u8, dest, "/")) blk: { + const path = if (dest[0] == '/') dest else dest["unix!".len..]; + break :blk .{ .unix = std.fmt.bufPrintSentinel(&buf, "{s}", .{path}, 0) catch return error.BadAddress }; + } else blk: { + var it = std.mem.splitScalar(u8, dest, '/'); + while (it.next()) |name| if (!post.legalName(name)) return error.BadAddress; + var dir_buf: [transport.sun_path_len]u8 = undefined; + const dir = post.registryDir(env, &dir_buf) catch |err| switch (err) { + error.NotRuntimeDir => return error.NotRuntimeDir, + else => return error.BadAddress, + }; + break :blk .{ .unix = std.fmt.bufPrintSentinel(&buf, "{s}/{s}", .{ dir, dest }, 0) catch return error.BadAddress }; + }; + try f.init(io, try transport.connect(io, address), uname); +} + +/// Hangs up: the server lets go of every fid. +pub fn close(f: *Fsys) void { + f.stream.close(f.io); +} + +/// The server's words for the last `error.Refused`. +pub fn said(f: *const Fsys) []const u8 { + return f.words[0..f.words_len]; +} + +pub const Opened = struct { fid: u32, qid: Qid, iounit: u32 }; + +/// Opens `path` with `mode` (`cloud9.oread`, `owrite`, `ordwr`, with +/// `otrunc` and the rest): its fid, which `clunk` lets go of. +pub fn open(f: *Fsys, path: []const u8, mode: u8) Error!Opened { + const fid = try f.walkAhead(path); + errdefer f.clunk(fid); + const o = (try f.rpc(.{ .open = .{ .fid = fid, .mode = mode } })).open; + return .{ .fid = fid, .qid = o.qid, .iounit = o.iounit }; +} + +/// Creates `path` in its directory with `perm` (`cloud9.dmdir` for a +/// directory) and opens it with `mode`. +pub fn create(f: *Fsys, path: []const u8, perm: u32, mode: u8) Error!Opened { + const trimmed = std.mem.trim(u8, path, "/"); + const slash = std.mem.lastIndexOfScalar(u8, trimmed, '/'); + const fid = try f.walkAhead(if (slash) |s| trimmed[0..s] else ""); + errdefer f.clunk(fid); + const name = if (slash) |s| trimmed[s + 1 ..] else trimmed; + const c = (try f.rpc(.{ .create = .{ .fid = fid, .name = name, .perm = perm, .mode = mode } })).create; + return .{ .fid = fid, .qid = c.qid, .iounit = c.iounit }; +} + +/// Removes `path`. +pub fn remove(f: *Fsys, path: []const u8) Error!void { + // The fid is gone whatever the answer. + _ = try f.rpc(.{ .remove = .{ .fid = try f.walkAhead(path) } }); +} + +/// The stat of `path`; its strings are good until the next call. +pub fn stat(f: *Fsys, path: []const u8) Error!Stat { + const fid = try f.walkAhead(path); + defer f.clunk(fid); + return (try f.rpc(.{ .stat = .{ .fid = fid } })).stat; +} + +/// One Tread of up to `count` bytes (and the message size) at `offset`: +/// the bytes, good until the next call; none at the end. +pub fn read(f: *Fsys, fid: u32, offset: u64, count: u32) Error![]const u8 { + return (try f.rpc(.{ .read = .{ .fid = fid, .offset = offset, .count = @min(count, f.cl.maxRead()) } })).read; +} + +/// One Twrite of as much of `bytes` as a message holds: the count written. +pub fn write(f: *Fsys, fid: u32, offset: u64, bytes: []const u8) Error!u32 { + const n = @min(bytes.len, f.cl.maxWrite()); + return (try f.rpc(.{ .write = .{ .fid = fid, .offset = offset, .data = bytes[0..n] } })).write; +} + +/// Lets go of `fid`, without waiting for the answer. +pub fn clunk(f: *Fsys, fid: u32) void { + const tag = f.cl.submit(.{ .clunk = .{ .fid = fid } }) catch return; + if (tag < 32) f.unwaited |= @as(u32, 1) << @intCast(tag); + f.ship() catch {}; +} + +/// The file at `path`, read from the start until a read comes back +/// empty, into `out`, flushed after each answer: a file whose reads the +/// server parks (an event file) streams as it comes. +pub fn readFile(f: *Fsys, path: []const u8, out: *Io.Writer) (Error || Io.Writer.Error)!void { + const o = try f.open(path, c9.oread); + defer f.clunk(o.fid); + try f.drain(o, out); +} + +/// `bytes` as the whole of the file at `path`, as `>` would put them: +/// opened truncated, written in as many writes as it takes. +pub fn writeFile(f: *Fsys, path: []const u8, bytes: []const u8) Error!void { + const o = try f.open(path, c9.owrite | c9.otrunc); + defer f.clunk(o.fid); + try f.put(o, bytes); +} + +/// Writes `request` to `path` and reads the answer on the same open from +/// the start, into `out` (as `readFile`): Plan 9's write, seek 0, read of +/// /net/cs. An answer that never ends (a log written `follow`) streams +/// until the server hangs up. +pub fn ask(f: *Fsys, path: []const u8, request: []const u8, out: *Io.Writer) (Error || Io.Writer.Error)!void { + const o = try f.open(path, c9.ordwr); + defer f.clunk(o.fid); + try f.put(o, request); + try f.drain(o, out); +} + +/// Directory entries as a directory read answers them: `next` decodes +/// them one at a time (their strings borrow the bytes). +pub const Entries = struct { + bytes: []const u8, + pos: usize = 0, + + pub fn next(e: *Entries) Error!?Stat { + if (e.pos == e.bytes.len) return null; + if (e.bytes.len - e.pos < 2) return error.Botch; + const len = 2 + @as(usize, std.mem.readInt(u16, e.bytes[e.pos..][0..2], .little)); + if (len > e.bytes.len - e.pos) return error.Botch; + defer e.pos += len; + return Stat.decode(e.bytes[e.pos..][0..len]) catch error.Botch; + } +}; + +// ---- internals ---- + +/// Writes all of `bytes` from the start, in writes no larger than the +/// open's iounit. +fn put(f: *Fsys, o: Opened, bytes: []const u8) Error!void { + var done: usize = 0; + while (done < bytes.len) { + const chunk = bytes[done..][0..@min(bytes.len - done, if (o.iounit != 0) o.iounit else bytes.len)]; + const n = try f.write(o.fid, done, chunk); + if (n == 0) return f.refuse("short write"); + done += n; + } +} + +/// Reads from the start until a read comes back empty, each answer into +/// `out` and flushed. +fn drain(f: *Fsys, o: Opened, out: *Io.Writer) (Error || Io.Writer.Error)!void { + var at: u64 = 0; + while (true) { + const data = try f.read(o.fid, at, if (o.iounit != 0) o.iounit else msize); + if (data.len == 0) return; + try out.writeAll(data); + try out.flush(); + at += data.len; + } +} + +/// A new fid for `path`. Its walk (the last 16 names of it) is sent and +/// not waited for: the next `rpc` sends its request behind it and checks +/// its answer first. Names before the last 16 are walked a round trip +/// each, the fid stepping from itself. +fn walkAhead(f: *Fsys, path: []const u8) Error!u32 { + f.words_len = 0; + const fid = f.next_fid; + f.next_fid = if (fid == std.math.maxInt(u32) - 1) 1 else fid + 1; + var it = std.mem.tokenizeScalar(u8, path, '/'); + var from: u32 = 0; + while (true) { + var names: [max_welem][]const u8 = undefined; + var n: usize = 0; + while (n < names.len) : (n += 1) names[n] = it.next() orelse break; + if (it.peek() == null) { + f.walk_tag = f.cl.submit(.{ .walk = .{ .fid = from, .newfid = fid, .names = names[0..n] } }) catch return error.Botch; + f.walk_asked = n; + return fid; + } + const w = f.rpc(.{ .walk = .{ .fid = from, .newfid = fid, .names = names[0..n] } }) catch |err| { + if (from != 0) f.clunk(fid); + return err; + }; + if (w.walk.nwqid < n) { + if (from != 0) f.clunk(fid); + return f.refuse(fs.errString(fs.E.NOENT)); + } + from = fid; + } +} + +/// Sends what the client holds, then reads until `req` is answered. On +/// the way, the answer of a walk sent ahead is checked (a refusal or a +/// walk short of its names is this call's refusal: the request behind it +/// had no fid) and those of unwaited clunks are dropped. +fn rpc(f: *Fsys, req: Client.Request) Error!Client.Result { + if (f.walk_tag == wire.notag) f.words_len = 0; + const tag = f.cl.submit(req) catch { + // A request that cannot be made (a name too long for a message): + // the walk ahead of it still goes, its answer not waited for. + if (f.walk_tag < 32) f.unwaited |= @as(u32, 1) << @intCast(f.walk_tag); + f.walk_tag = wire.notag; + return error.Botch; + }; + try f.ship(); + while (true) { + const done = try f.next(); + if (f.walk_tag != wire.notag and done.tag == f.walk_tag) { + f.walk_tag = wire.notag; + switch (done.result) { + .fail => |words| f.keep(words), + .walk => |w| if (w.nwqid < f.walk_asked) f.keep(fs.errString(fs.E.NOENT)), + else => return error.Botch, + } + continue; + } + if (done.tag == tag) { + if (f.words_len != 0) return error.Refused; + return switch (done.result) { + .fail => |words| f.refuse(words), + else => done.result, + }; + } + if (done.tag < 32 and f.unwaited & @as(u32, 1) << @intCast(done.tag) != 0) { + f.unwaited &= ~(@as(u32, 1) << @intCast(done.tag)); + continue; + } + return error.Botch; + } +} + +/// The next answer, read from the socket as it takes; its slices are +/// good until the next. +fn next(f: *Fsys) Error!Client.Done { + while (true) { + if (f.cl.take()) |done| return done; + if (f.cl.dead) return error.Botch; + // take() found no whole frame and the client has dropped the last + // one, so the free end of its input is where the next bytes go + // (what `push` would copy them to). + var room = [1][]u8{f.cl.in[f.cl.in_len..]}; + if (room[0].len == 0) return error.Botch; + const n = f.stream.read(f.io, &room) catch return error.Hangup; + if (n == 0) return error.Hangup; + f.cl.in_len += n; + } +} + +fn ship(f: *Fsys) Error!void { + var w = f.stream.writer(f.io, &.{}); + const bytes = f.cl.output(); + w.interface.writeAll(bytes) catch return error.Hangup; + f.cl.wrote(bytes.len); +} + +/// Keeps `words` as the refusal, unless one is kept already (the walk's, +/// before the request it failed). +fn keep(f: *Fsys, words: []const u8) void { + if (f.words_len != 0) return; + f.words_len = @min(words.len, f.words.len); + @memcpy(f.words[0..f.words_len], words[0..f.words_len]); +} + +fn refuse(f: *Fsys, words: []const u8) error{Refused} { + f.keep(words); + return error.Refused; +} + +// ---- tests: against cloud9's own engine, served by `serve.Runner` ---- + +const testing = std.testing; +const TestTree = @import("TestTree.zig"); + +const no_env = [_:null]?[*:0]const u8{}; + +const Dest = enum { unix, tcp }; + +fn dialed(t: *TestTree, dest: Dest) !*Fsys { + const f = try testing.allocator.create(Fsys); + errdefer testing.allocator.destroy(f); + var buf: [128]u8 = undefined; + const address = switch (dest) { + .unix => try std.fmt.bufPrint(&buf, "unix!{s}", .{t.unix}), + .tcp => try std.fmt.bufPrint(&buf, "tcp!127.0.0.1!{d}", .{t.tcp.getPort()}), + }; + try f.dial(testing.io, &no_env, address, "glenda"); + return f; +} + +fn hangUp(f: *Fsys) void { + f.close(); + testing.allocator.destroy(f); +} + +fn readAll(f: *Fsys, path: []const u8) ![]u8 { + var out: Io.Writer.Allocating = .init(testing.allocator); + errdefer out.deinit(); + try f.readFile(path, &out.writer); + return out.toOwnedSlice(); +} + +test "fsys: whole files, stats and walks over a Unix socket and TCP" { + const t = try testing.allocator.create(TestTree); + defer testing.allocator.destroy(t); + try t.start(); + defer t.stop(); + for ([_]Dest{ .unix, .tcp }) |dest| { + const f = try dialed(t, dest); + defer hangUp(f); + const readme = try readAll(f, "README"); + defer testing.allocator.free(readme); + try testing.expectEqualStrings(TestTree.readme, readme); + // Longer than a message (the server's is 8192): read on to the end. + const big = try readAll(f, "/big"); + defer testing.allocator.free(big); + try testing.expectEqual(TestTree.big_len, big.len); + for (big, 0..) |b, i| if (b != TestTree.bigByte(i)) return error.TestUnexpectedResult; + try testing.expectEqualStrings("deep", (try f.stat("sub/deep")).name); + try testing.expectEqual(@as(u64, TestTree.readme.len), (try f.stat("README")).length); + // More names than a walk carries: the first 16 a round trip of their own. + try testing.expectEqualStrings("deep", (try f.stat("sub/../sub/../sub/../sub/../sub/../sub/../sub/../sub/../sub/../sub/deep")).name); + try testing.expectError(error.Refused, f.stat("nowhere")); + try testing.expectEqualStrings("No such file or directory", f.said()); + // A walk short of its names is refused in the same words. + try testing.expectError(error.Refused, f.stat("sub/nowhere")); + try testing.expectEqualStrings("No such file or directory", f.said()); + try testing.expectError(error.Refused, f.stat("sub/../sub/../sub/../sub/../sub/../sub/../sub/../sub/../sub/../nowhere/deep")); + // Refusals leave the connection as good as before. + try testing.expectEqualStrings("README", (try f.stat("README")).name); + } +} + +test "fsys: a refused write's words reach the caller" { + const t = try testing.allocator.create(TestTree); + defer testing.allocator.destroy(t); + try t.start(); + defer t.stop(); + const f = try dialed(t, .unix); + defer hangUp(f); + try testing.expectError(error.Refused, f.writeFile("ctl", "bogus\n")); + try testing.expectEqualStrings("unknown command: bogus", f.said()); + try f.writeFile("ctl", "ok\n"); + const ctl = try readAll(f, "ctl"); + defer testing.allocator.free(ctl); + try testing.expectEqualStrings("ok\n", ctl); + try testing.expectError(error.Refused, f.writeFile("README", "x")); + try testing.expectEqualStrings("permission denied", f.said()); +} + +test "fsys: a short read is not the end of the file" { + const t = try testing.allocator.create(TestTree); + defer testing.allocator.destroy(t); + try t.start(); + defer t.stop(); + const f = try dialed(t, .unix); + defer hangUp(f); + const short = try readAll(f, "short"); + defer testing.allocator.free(short); + try testing.expectEqualStrings("a short answer, three bytes a read", short); + // One Tread is one answer, a short one included. + const o = try f.open("short", c9.oread); + defer f.clunk(o.fid); + try testing.expectEqualStrings("a s", try f.read(o.fid, 0, 100)); +} + +test "fsys: ask reads the answer on the open it wrote, from the start" { + const t = try testing.allocator.create(TestTree); + defer testing.allocator.destroy(t); + try t.start(); + defer t.stop(); + const f = try dialed(t, .unix); + defer hangUp(f); + var out: Io.Writer.Allocating = .init(testing.allocator); + defer out.deinit(); + try f.ask("echo", "hello\n", &out.writer); + try testing.expectEqualStrings("heard hello\n", out.written()); +} + +test "fsys: a read the server holds streams three chunks, then its end" { + const t = try testing.allocator.create(TestTree); + defer testing.allocator.destroy(t); + try t.start(); + defer t.stop(); + const f = try dialed(t, .unix); + defer hangUp(f); + const Feeder = struct { + fn run(tree: *TestTree) anyerror!void { + for ([_][]const u8{ "new 1\n", "del 2\n", "new 3\n", "" }) |chunk| try tree.feed(chunk); + } + }; + var feeder = try testing.io.concurrent(Feeder.run, .{t}); + defer _ = feeder.cancel(testing.io) catch {}; + // Each chunk is flushed as it comes: a writer that marks its flushes. + const Marked = struct { + w: Io.Writer, + marks: [8]usize = undefined, + n: usize = 0, + fn flush(w: *Io.Writer) Io.Writer.Error!void { + const m: *@This() = @fieldParentPtr("w", w); + m.marks[m.n] = w.end; + m.n += 1; + } + }; + var store: [64]u8 = undefined; + var marked: Marked = .{ .w = .{ .vtable = &.{ .drain = Io.Writer.fixedDrain, .flush = Marked.flush }, .buffer = &store } }; + const out = &marked.w; + try f.ask("event", "follow\n", out); + try testing.expectEqualStrings("new 1\ndel 2\nnew 3\n", out.buffered()); + try testing.expectEqualSlices(usize, &.{ 6, 12, 18 }, marked.marks[0..marked.n]); + try feeder.await(testing.io); +} + +test "fsys: a server that goes away mid-read is a hangup" { + const t = try testing.allocator.create(TestTree); + defer testing.allocator.destroy(t); + try t.start(); + defer t.stop(); + const f = try dialed(t, .unix); + defer hangUp(f); + const Feeder = struct { + fn run(tree: *TestTree) anyerror!void { + try tree.feed("first\n"); + try tree.feed(null); + } + }; + var feeder = try testing.io.concurrent(Feeder.run, .{t}); + defer _ = feeder.cancel(testing.io) catch {}; + var store: [64]u8 = undefined; + var out: Io.Writer = .fixed(&store); + try testing.expectError(error.Hangup, f.readFile("event", &out)); + try testing.expectEqualStrings("first\n", out.buffered()); + try feeder.await(testing.io); +} + +test "fsys: create, write, remove" { + const t = try testing.allocator.create(TestTree); + defer testing.allocator.destroy(t); + try t.start(); + defer t.stop(); + const f = try dialed(t, .unix); + defer hangUp(f); + const o = try f.create("/new", 0o600, c9.owrite); + try testing.expectEqual(@as(u32, 3), try f.write(o.fid, 0, "abc")); + f.clunk(o.fid); + try testing.expectError(error.Refused, f.create("new", 0o600, c9.owrite)); + try testing.expectEqualStrings("File exists", f.said()); + try f.remove("new"); + try testing.expectError(error.Refused, f.stat("new")); + try testing.expectError(error.Refused, f.remove("README")); + // A name no message holds is not sent, and the walk sent ahead of it + // does not stand in the way of the next call. + const long: [9000]u8 = @splat('x'); + try testing.expectError(error.Botch, f.create(&long, 0o600, c9.owrite)); + try testing.expectEqualStrings("README", (try f.stat("README")).name); +} + +test "fsys: a directory read decodes as entries" { + const t = try testing.allocator.create(TestTree); + defer testing.allocator.destroy(t); + try t.start(); + defer t.stop(); + const f = try dialed(t, .unix); + defer hangUp(f); + const o = try f.open("", c9.oread); + defer f.clunk(o.fid); + try testing.expect(o.qid.type & wire.qtdir != 0); + var names: [8][]const u8 = undefined; + var n: usize = 0; + var entries: Entries = .{ .bytes = try f.read(o.fid, 0, msize) }; + while (try entries.next()) |st| : (n += 1) names[n] = st.name; + try testing.expectEqual(@as(usize, 7), n); + try testing.expectEqualStrings("README", names[0]); + try testing.expectEqualStrings("sub", names[6]); +} + +test "fsys: dial by a name posted in the registry, and refuse a name that climbs out of it" { + var dir = testing.tmpDir(.{}); + defer dir.cleanup(); + var real: [std.fs.max_path_bytes]u8 = undefined; + const len = try dir.dir.realPath(testing.io, &real); + var var_buf: [std.fs.max_path_bytes + 32]u8 = undefined; + const runtime = try std.fmt.bufPrintSentinel(&var_buf, "XDG_RUNTIME_DIR={s}", .{real[0..len]}, 0); + const env = [_:null]?[*:0]const u8{runtime.ptr}; + const t = try testing.allocator.create(TestTree); + defer testing.allocator.destroy(t); + try t.start(); + defer t.stop(); + try t.runner.listenPosted(&env, "c9test", 4); + const f = try testing.allocator.create(Fsys); + defer testing.allocator.destroy(f); + try f.dial(testing.io, &env, "c9test", "glenda"); + defer f.close(); + try testing.expectEqualStrings("README", (try f.stat("README")).name); + var g: Fsys = undefined; + try testing.expectError(error.BadAddress, g.dial(testing.io, &env, "../c9test", "glenda")); + try testing.expectError(error.NotRuntimeDir, g.dial(testing.io, &no_env, "c9test", "glenda")); +} |
