impl error message for invalid testcases

Author: dvishal485

src/handlers/execution.rs

@@ -49,6 +49,12 @@ pub struct RuntimeError {
     pub std_output: Vec<String>,
 }
 
+#[derive(Debug, Deserialize)]
+pub struct WrongTestcase {
+    pub invalid_testcase: bool,
+    pub runtime_error: String,
+}
+
 #[derive(Debug, Deserialize)]
 pub struct LimitExceeded {
     pub status_code: u8,
@@ -69,6 +75,24 @@ pub struct LimitExceeded {
     pub state: String,
 }
 
+impl fmt::Display for WrongTestcase {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let seperator = "-------------------------------";
+        write!(
+            f,
+            "{}\n{}\n{}",
+            if self.invalid_testcase {
+                "Invalid Testcase!"
+            } else {
+                "Unknown Error!"
+            }
+            .red()
+            .bold(),
+            seperator.yellow(),
+            self.runtime_error
+        )
+    }
+}
 impl fmt::Display for LimitExceeded {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let seperator = "-------------------------------";

src/handlers/utils.rs

@@ -24,6 +24,7 @@ pub enum ExecutionResult {
     CompileError(CompileError),
     RuntimeError(RuntimeError),
     LimitExceeded(LimitExceeded),
+    WrongTestcase(WrongTestcase),
     PendingResult(PendingResult),
     Unknown(Unknown),
 }

src/utils.rs

@@ -39,34 +39,34 @@ pub(crate) fn execute_testcases<P: AsRef<Path>>(
                 ExecutionResult::PendingResult(pending) => {
                     bail!(pending.state);
                 }
+                ExecutionResult::WrongTestcase(wrong_testcase) => bail!(wrong_testcase),
                 ExecutionResult::Unknown(_) => {
                     bail!("Unknown");
                 }
             }
         }
-        None => {
-            match lc.execute_default(&code_file)? {
-                ExecutionResult::Success(result) => {
-                    println!("{}", result);
-                    return Ok((result.is_correct(), code_file));
-                }
-                ExecutionResult::LimitExceeded(limit_exceeded) => {
-                    bail!(limit_exceeded);
-                }
-                ExecutionResult::CompileError(compile_error) => {
-                    bail!(compile_error);
-                }
-                ExecutionResult::RuntimeError(runtime_error) => {
-                    bail!(runtime_error);
-                }
-                ExecutionResult::PendingResult(pending) => {
-                    bail!(pending.state);
-                }
-                ExecutionResult::Unknown(_) => {
-                    bail!("Unknown error");
-                }
+        None => match lc.execute_default(&code_file)? {
+            ExecutionResult::Success(result) => {
+                println!("{}", result);
+                return Ok((result.is_correct(), code_file));
             }
-        }
+            ExecutionResult::LimitExceeded(limit_exceeded) => {
+                bail!(limit_exceeded);
+            }
+            ExecutionResult::CompileError(compile_error) => {
+                bail!(compile_error);
+            }
+            ExecutionResult::RuntimeError(runtime_error) => {
+                bail!(runtime_error);
+            }
+            ExecutionResult::PendingResult(pending) => {
+                bail!(pending.state);
+            }
+            ExecutionResult::WrongTestcase(wrong_testcase) => bail!(wrong_testcase),
+            ExecutionResult::Unknown(_) => {
+                bail!("Unknown error");
+            }
+        },
     }
 }