Initial project import

tools/v/vlib/io/fs/fs_test.v

@@ -0,0 +1,216 @@
+module fs
+
+import io
+import os
+
+struct MockInfo {
+	name_     string
+	size_     u64
+	mode_     os.FileMode
+	mod_time_ i64
+}
+
+fn (info MockInfo) name() string {
+	return info.name_
+}
+
+fn (info MockInfo) size() u64 {
+	return info.size_
+}
+
+fn (info MockInfo) mode() os.FileMode {
+	return info.mode_
+}
+
+fn (info MockInfo) mod_time() i64 {
+	return info.mod_time_
+}
+
+fn (info MockInfo) is_dir() bool {
+	return info.mode_.typ == .directory
+}
+
+struct MockFile {
+	data  []u8
+	info_ MockInfo
+mut:
+	offset  int
+	entries []DirEntry
+}
+
+fn (mut file MockFile) read(mut buf []u8) !int {
+	if file.offset >= file.data.len {
+		return io.Eof{}
+	}
+	read := copy(mut buf, file.data[file.offset..])
+	file.offset += read
+	return read
+}
+
+fn (file MockFile) stat() !FileInfo {
+	return file.info_
+}
+
+fn (mut file MockFile) close() {}
+
+fn (mut file MockFile) read_dir(n int) ![]DirEntry {
+	if n <= 0 || n >= file.entries.len {
+		return file.entries.clone()
+	}
+	return file.entries[..n].clone()
+}
+
+struct FallbackFS {}
+
+fn (filesystem FallbackFS) open(name string) !File {
+	match name {
+		'notes.txt' {
+			return File(MockFile{
+				data:  'fallback'.bytes()
+				info_: MockInfo{
+					name_:     'notes.txt'
+					size_:     u64('fallback'.len)
+					mode_:     os.FileMode{
+						typ: .regular
+					}
+					mod_time_: 101
+				}
+			})
+		}
+		'dir' {
+			return File(MockFile{
+				info_:   MockInfo{
+					name_: 'dir'
+					mode_: os.FileMode{
+						typ: .directory
+					}
+				}
+				entries: [
+					file_info_to_dir_entry(MockInfo{
+						name_: 'b.txt'
+						mode_: os.FileMode{
+							typ: .regular
+						}
+					}),
+					file_info_to_dir_entry(MockInfo{
+						name_: 'a.txt'
+						mode_: os.FileMode{
+							typ: .regular
+						}
+					}),
+				]
+			})
+		}
+		else {
+			return error('missing ${name}')
+		}
+	}
+}
+
+struct OptimizedFS {}
+
+fn (filesystem OptimizedFS) open(name string) !File {
+	return error('unexpected open for ${name}')
+}
+
+fn (filesystem OptimizedFS) read_file(name string) ![]u8 {
+	return 'optimized'.bytes()
+}
+
+fn (filesystem OptimizedFS) read_dir(name string) ![]DirEntry {
+	return [
+		file_info_to_dir_entry(MockInfo{
+			name_: 'z.txt'
+			mode_: os.FileMode{
+				typ: .regular
+			}
+		}),
+		file_info_to_dir_entry(MockInfo{
+			name_: 'm.txt'
+			mode_: os.FileMode{
+				typ: .regular
+			}
+		}),
+	]
+}
+
+fn (filesystem OptimizedFS) stat(name string) !FileInfo {
+	return MockInfo{
+		name_:     name
+		size_:     42
+		mode_:     os.FileMode{
+			typ: .regular
+		}
+		mod_time_: 202
+	}
+}
+
+fn entry_names(entries []DirEntry) []string {
+	mut names := []string{cap: entries.len}
+	for entry in entries {
+		names << entry.name()
+	}
+	return names
+}
+
+fn test_valid_path() {
+	assert valid_path('.')
+	assert valid_path('alpha')
+	assert valid_path('alpha/beta')
+	assert valid_path(r'alpha\beta')
+	assert !valid_path('')
+	assert !valid_path('/alpha')
+	assert !valid_path('alpha/')
+	assert !valid_path('alpha//beta')
+	assert !valid_path('alpha/./beta')
+	assert !valid_path('alpha/../beta')
+}
+
+fn test_file_info_to_dir_entry() {
+	info := MockInfo{
+		name_:     'subdir'
+		size_:     12
+		mode_:     os.FileMode{
+			typ: .directory
+		}
+		mod_time_: 303
+	}
+	entry := file_info_to_dir_entry(info)
+	assert entry.name() == 'subdir'
+	assert entry.is_dir()
+	assert entry.typ() == .directory
+	assert entry.info()!.mod_time() == 303
+}
+
+fn test_read_file_uses_open_fallback() {
+	data := read_file(FallbackFS{}, 'notes.txt')!
+	assert data == 'fallback'.bytes()
+}
+
+fn test_read_file_uses_read_file_fs_when_available() {
+	data := read_file(OptimizedFS{}, 'notes.txt')!
+	assert data == 'optimized'.bytes()
+}
+
+fn test_read_dir_uses_open_fallback_and_sorts() {
+	entries := read_dir(FallbackFS{}, 'dir')!
+	assert entry_names(entries) == ['a.txt', 'b.txt']
+}
+
+fn test_read_dir_uses_read_dir_fs_when_available() {
+	entries := read_dir(OptimizedFS{}, 'dir')!
+	assert entry_names(entries) == ['m.txt', 'z.txt']
+}
+
+fn test_stat_uses_open_fallback() {
+	info := stat(FallbackFS{}, 'notes.txt')!
+	assert info.name() == 'notes.txt'
+	assert info.size() == u64('fallback'.len)
+}
+
+fn test_stat_uses_stat_fs_when_available() {
+	info := stat(OptimizedFS{}, 'notes.txt')!
+	assert info.name() == 'notes.txt'
+	assert info.size() == 42
+	assert info.mod_time() == 202
+}