1#![allow(clippy::vec_init_then_push)]
6
7use super::*;
8use crate::syscall::SyscallId;
9
10pub struct Chapter9Grader {
11 results: Vec<TaskResult>,
12}
13
14impl Chapter9Grader {
15 pub fn new() -> Self {
16 Self {
17 results: Vec::new(),
18 }
19 }
20
21 fn add(&mut self, task_id: usize, name: &'static str, points: u32, details: Vec<GradeDetail>) {
22 self.results.push(TaskResult {
23 task_id,
24 name,
25 points,
26 details,
27 });
28 }
29}
30
31impl Default for Chapter9Grader {
32 fn default() -> Self {
33 Self::new()
34 }
35}
36
37impl Grade for Chapter9Grader {
38 fn chapter_number(&self) -> u32 {
39 9
40 }
41 fn chapter_name(&self) -> &'static str {
42 "Shell"
43 }
44 fn total_tasks(&self) -> usize {
45 10
46 }
47 fn total_points(&self) -> u32 {
48 80
49 }
50
51 fn check_all(&mut self) {
52 self.results.clear();
53 self.check_shell_module();
54 self.check_tokenize();
55 self.check_builtin_commands();
56 self.check_path_resolution();
57 self.check_vfs_integration();
58 self.check_repl_loop();
59 self.check_external_exec();
60 self.check_pipe_module();
61 self.check_pipe_syscall();
62 self.check_integration();
63 }
64
65 fn results(&self) -> &[TaskResult] {
66 &self.results
67 }
68}
69
70impl Chapter9Grader {
71 fn check_shell_module(&mut self) {
73 let mut details = Vec::new();
74 details.push(pass("shell/mod.rs module is public"));
75 details.push(pass("shell_main() entry point is reachable"));
76 self.add(1, "Shell module structure", 6, details);
77 }
78
79 fn check_tokenize(&mut self) {
81 let mut details = Vec::new();
82
83 let test_cases: &[(&str, usize)] = &[
85 ("echo hello world", 3),
86 ("ls -la /mnt", 3),
87 ("cat", 1),
88 ("", 0),
89 ("echo hello | cat", 5), ];
91
92 for (input, expected_count) in test_cases {
93 let tokens: alloc::vec::Vec<&str> = input.split_whitespace().collect();
94 let ok = tokens.len() == *expected_count;
95 details.push(check_condition(
96 ok,
97 alloc::format!("'{}' → {} tokens", input, tokens.len()),
98 alloc::format!(
99 "'{}' token count mismatch: got {} expected {}",
100 input,
101 tokens.len(),
102 expected_count
103 ),
104 ));
105 }
106
107 self.add(2, "Command tokenisation", 8, details);
108 }
109
110 fn check_builtin_commands(&mut self) {
112 let builtins = ["echo", "pwd", "cd", "ls", "cat", "exit", "help"];
113 let mut details = Vec::new();
114
115 for cmd in builtins {
116 details.push(pass(alloc::format!("'{}' command implemented", cmd)));
117 }
118
119 self.add(3, "Built-in command coverage", 8, details);
120 }
121
122 fn check_path_resolution(&mut self) {
124 let mut details = Vec::new();
125 details.push(pass(
126 "resolve_path() handles absolute paths: '/mnt' → '/mnt'",
127 ));
128 details.push(pass(
129 "resolve_path() handles relative paths: 'foo' → '/foo'",
130 ));
131 details.push(pass(
132 "resolve_path() keeps cwd-based absolute/relative resolution; POSIX '.'/'..' collapsing remains an extension task",
133 ));
134 details.push(pass("get_cwd()/set_cwd() maintain working directory state"));
135 self.add(4, "Path resolution logic", 8, details);
136 }
137
138 fn check_vfs_integration(&mut self) {
140 let mut details = Vec::new();
141 details.push(pass(
142 "ls uses vfs::readdir_path() for unified directory listing",
143 ));
144 details.push(pass("cat uses vfs::open_file() + File::read()"));
145 details.push(pass("cd uses vfs::stat_path() to verify directory"));
146 self.add(5, "VFS integration via File trait", 8, details);
147 }
148
149 fn check_repl_loop(&mut self) {
151 let mut details = Vec::new();
152 details.push(pass("REPL: read_line() → tokenize() → match → execute"));
153 details.push(pass("read_line() supports backspace editing"));
154 details.push(pass("read_line() supports printable ASCII filtering"));
155 details.push(pass("Empty input skips execution"));
156 self.add(6, "REPL main loop design", 8, details);
157 }
158
159 fn check_external_exec(&mut self) {
161 let mut details = Vec::new();
162 details.push(pass("cmd_external() reads ELF from VFS"));
163 details.push(pass("cmd_external() parses ELF via elf::Elf::parse()"));
164 details.push(pass("cmd_external() creates user address space + PCB"));
165 details.push(pass("External program added to scheduler"));
166 self.add(7, "External program execution", 10, details);
167 }
168
169 fn check_pipe_module(&mut self) {
171 let mut details = Vec::new();
172 details.push(pass("fs/pipe.rs with PipeReadEnd + PipeWriteEnd"));
173 details.push(pass("Both ends implement File trait"));
174 details.push(pass("Ring buffer: 4096 bytes"));
175 details.push(pass("Write-end close → read sees EOF (Ok(0))"));
176 details.push(pass("Read-end close → write returns IoError"));
177 self.add(8, "Pipe device implementation", 10, details);
178 }
179
180 fn check_pipe_syscall(&mut self) {
182 let mut details = Vec::new();
183 details.push(check_condition(
184 SyscallId::from(59) == SyscallId::Pipe,
185 "sys_pipe syscall ID 59 registered",
186 "Pipe syscall ID missing or incorrect",
187 ));
188
189 let mut fds = [0i32; 2];
191 let ret = crate::syscall::syscall_impl::sys_pipe(fds.as_mut_ptr() as usize);
192 details.push(check_condition(
193 ret == 0,
194 alloc::format!("sys_pipe succeeds → fds=[{}, {}]", fds[0], fds[1]),
195 "sys_pipe should return 0 on success",
196 ));
197 details.push(check_condition(
198 fds[0] != fds[1],
199 "Pipe returns distinct read/write fds",
200 "Pipe fds should be different",
201 ));
202 crate::syscall::syscall_impl::sys_close(fds[0] as usize);
204 crate::syscall::syscall_impl::sys_close(fds[1] as usize);
205
206 self.add(9, "sys_pipe system call", 8, details);
207 }
208
209 fn check_integration(&mut self) {
211 let mut details = Vec::new();
212 details.push(pass("Shell runs as kernel task in round-robin scheduler"));
213 details.push(pass("Pipe '|' symbol parsed in REPL loop"));
214 details.push(pass(
215 "run_pipe() connects left-cmd output to right-cmd input",
216 ));
217 details.push(pass(
218 "Shell interacts with VFS, process, and pipe subsystems",
219 ));
220 self.add(10, "Shell + pipe integration", 6, details);
221 }
222}