Skip to content

Commit b9eb473

Browse files
rbonifaciorbonifacio
committed
[refactor] Move eval test cases to 'expression_eval.rs'
1 parent 0c05389 commit b9eb473

1 file changed

Lines changed: 0 additions & 276 deletions

File tree

‎src/interpreter/statement_execute.rs‎

Lines changed: 0 additions & 276 deletions
Original file line numberDiff line numberDiff line change
@@ -470,282 +470,6 @@ mod tests {
470470
}
471471
}
472472

473-
mod list_value_tests {
474-
use super::*;
475-
476-
#[test]
477-
fn test_val_declaration_with_integer_list() {
478-
let env = create_test_env();
479-
480-
let list_expr = Expression::ListValue(vec![
481-
Expression::CInt(1),
482-
Expression::CInt(2),
483-
Expression::CInt(3),
484-
]);
485-
486-
let val_decl =
487-
Statement::ValDeclaration("numbers".to_string(), Box::new(list_expr.clone()));
488-
489-
let result_env = execute(val_decl, &env);
490-
491-
assert!(result_env.is_ok());
492-
let final_env = result_env.unwrap();
493-
494-
let numbers_value = final_env.lookup(&"numbers".to_string());
495-
assert!(numbers_value.is_some());
496-
let (is_mutable, numbers_expr) = numbers_value.unwrap();
497-
assert_eq!(numbers_expr, list_expr);
498-
assert!(!is_mutable); // val should be immutable
499-
}
500-
501-
#[test]
502-
fn test_var_declaration_with_string_list() {
503-
let env = create_test_env();
504-
505-
let list_expr = Expression::ListValue(vec![
506-
Expression::CString("hello".to_string()),
507-
Expression::CString("world".to_string()),
508-
Expression::CString("test".to_string()),
509-
]);
510-
511-
let var_decl =
512-
Statement::VarDeclaration("words".to_string(), Box::new(list_expr.clone()));
513-
514-
let result_env = execute(var_decl, &env);
515-
516-
assert!(result_env.is_ok());
517-
let final_env = result_env.unwrap();
518-
519-
let words_value = final_env.lookup(&"words".to_string());
520-
assert!(words_value.is_some());
521-
let (is_mutable, words_expr) = words_value.unwrap();
522-
assert_eq!(words_expr, list_expr);
523-
assert!(is_mutable); // var should be mutable
524-
}
525-
526-
#[test]
527-
fn test_empty_list_declaration() {
528-
let env = create_test_env();
529-
530-
let empty_list = Expression::ListValue(vec![]);
531-
532-
let val_decl =
533-
Statement::ValDeclaration("empty".to_string(), Box::new(empty_list.clone()));
534-
535-
let result_env = execute(val_decl, &env);
536-
537-
assert!(result_env.is_ok());
538-
let final_env = result_env.unwrap();
539-
540-
let empty_value = final_env.lookup(&"empty".to_string());
541-
assert!(empty_value.is_some());
542-
let (is_mutable, empty_expr) = empty_value.unwrap();
543-
assert_eq!(empty_expr, empty_list);
544-
assert!(!is_mutable); // val should be immutable
545-
}
546-
547-
#[test]
548-
fn test_boolean_list_declaration() {
549-
let env = create_test_env();
550-
551-
let bool_list = Expression::ListValue(vec![
552-
Expression::CTrue,
553-
Expression::CFalse,
554-
Expression::CTrue,
555-
]);
556-
557-
let var_decl =
558-
Statement::VarDeclaration("flags".to_string(), Box::new(bool_list.clone()));
559-
560-
let result_env = execute(var_decl, &env);
561-
562-
assert!(result_env.is_ok());
563-
let final_env = result_env.unwrap();
564-
565-
let flags_value = final_env.lookup(&"flags".to_string());
566-
assert!(flags_value.is_some());
567-
let (is_mutable, flags_expr) = flags_value.unwrap();
568-
assert_eq!(flags_expr, bool_list);
569-
assert!(is_mutable); // var should be mutable
570-
}
571-
572-
#[test]
573-
fn test_real_number_list_declaration() {
574-
let env = create_test_env();
575-
576-
let real_list = Expression::ListValue(vec![
577-
Expression::CReal(1.5),
578-
Expression::CReal(2.7),
579-
Expression::CReal(3.14159),
580-
]);
581-
582-
let val_decl =
583-
Statement::ValDeclaration("reals".to_string(), Box::new(real_list.clone()));
584-
585-
let result_env = execute(val_decl, &env);
586-
587-
assert!(result_env.is_ok());
588-
let final_env = result_env.unwrap();
589-
590-
let reals_value = final_env.lookup(&"reals".to_string());
591-
assert!(reals_value.is_some());
592-
let (is_mutable, reals_expr) = reals_value.unwrap();
593-
assert_eq!(reals_expr, real_list);
594-
assert!(!is_mutable); // val should be immutable
595-
}
596-
597-
#[test]
598-
fn test_mixed_type_list_declaration() {
599-
let env = create_test_env();
600-
601-
// Note: This test assumes the language allows mixed-type lists
602-
// If the type checker restricts this, this test might fail at type-check time
603-
let mixed_list = Expression::ListValue(vec![
604-
Expression::CInt(42),
605-
Expression::CString("hello".to_string()),
606-
Expression::CTrue,
607-
Expression::CReal(3.14),
608-
]);
609-
610-
let var_decl =
611-
Statement::VarDeclaration("mixed".to_string(), Box::new(mixed_list.clone()));
612-
613-
let result_env = execute(var_decl, &env);
614-
615-
assert!(result_env.is_ok());
616-
let final_env = result_env.unwrap();
617-
618-
let mixed_value = final_env.lookup(&"mixed".to_string());
619-
assert!(mixed_value.is_some());
620-
let (is_mutable, mixed_expr) = mixed_value.unwrap();
621-
assert_eq!(mixed_expr, mixed_list);
622-
assert!(is_mutable); // var should be mutable
623-
}
624-
625-
#[test]
626-
fn test_list_with_evaluated_expressions() {
627-
let env = create_test_env();
628-
629-
// List containing expressions that need to be evaluated
630-
let expr_list = Expression::ListValue(vec![
631-
Expression::Add(Box::new(Expression::CInt(1)), Box::new(Expression::CInt(2))), // 3
632-
Expression::Mul(Box::new(Expression::CInt(2)), Box::new(Expression::CInt(4))), // 8
633-
Expression::Sub(
634-
Box::new(Expression::CInt(10)),
635-
Box::new(Expression::CInt(5)),
636-
), // 5
637-
]);
638-
639-
let val_decl = Statement::ValDeclaration("computed".to_string(), Box::new(expr_list));
640-
641-
let result_env = execute(val_decl, &env);
642-
643-
assert!(result_env.is_ok());
644-
let final_env = result_env.unwrap();
645-
646-
let computed_value = final_env.lookup(&"computed".to_string());
647-
assert!(computed_value.is_some());
648-
let (is_mutable, computed_expr) = computed_value.unwrap();
649-
650-
// The expressions should be evaluated when the list is created
651-
let expected_list = Expression::ListValue(vec![
652-
Expression::CInt(3),
653-
Expression::CInt(8),
654-
Expression::CInt(5),
655-
]);
656-
657-
assert_eq!(computed_expr, expected_list);
658-
assert!(!is_mutable); // val should be immutable
659-
}
660-
661-
#[test]
662-
fn test_single_element_list() {
663-
let env = create_test_env();
664-
665-
let single_list = Expression::ListValue(vec![Expression::CInt(42)]);
666-
667-
let var_decl =
668-
Statement::VarDeclaration("singleton".to_string(), Box::new(single_list.clone()));
669-
670-
let result_env = execute(var_decl, &env);
671-
672-
assert!(result_env.is_ok());
673-
let final_env = result_env.unwrap();
674-
675-
let singleton_value = final_env.lookup(&"singleton".to_string());
676-
assert!(singleton_value.is_some());
677-
let (is_mutable, singleton_expr) = singleton_value.unwrap();
678-
assert_eq!(singleton_expr, single_list);
679-
assert!(is_mutable); // var should be mutable
680-
}
681-
682-
#[test]
683-
fn test_nested_list_declaration() {
684-
let env = create_test_env();
685-
686-
// Create nested lists
687-
let inner_list1 = Expression::ListValue(vec![Expression::CInt(1), Expression::CInt(2)]);
688-
let inner_list2 = Expression::ListValue(vec![Expression::CInt(3), Expression::CInt(4)]);
689-
690-
let nested_list = Expression::ListValue(vec![inner_list1.clone(), inner_list2.clone()]);
691-
692-
let val_decl =
693-
Statement::ValDeclaration("nested".to_string(), Box::new(nested_list.clone()));
694-
695-
let result_env = execute(val_decl, &env);
696-
697-
assert!(result_env.is_ok());
698-
let final_env = result_env.unwrap();
699-
700-
let nested_value = final_env.lookup(&"nested".to_string());
701-
assert!(nested_value.is_some());
702-
let (is_mutable, nested_expr) = nested_value.unwrap();
703-
assert_eq!(nested_expr, nested_list);
704-
assert!(!is_mutable); // val should be immutable
705-
}
706-
707-
#[test]
708-
fn test_list_reassignment() {
709-
let env = create_test_env();
710-
711-
// First declare a mutable list variable
712-
let original_list =
713-
Expression::ListValue(vec![Expression::CInt(1), Expression::CInt(2)]);
714-
715-
let var_decl =
716-
Statement::VarDeclaration("list".to_string(), Box::new(original_list.clone()));
717-
718-
let env_with_list = execute(var_decl, &env).unwrap();
719-
720-
// Verify the original value
721-
let list_value = env_with_list.lookup(&"list".to_string());
722-
assert!(list_value.is_some());
723-
let (is_mutable, list_expr) = list_value.unwrap();
724-
assert_eq!(list_expr, original_list);
725-
assert!(is_mutable);
726-
727-
// Now reassign with a new list
728-
let new_list = Expression::ListValue(vec![
729-
Expression::CInt(10),
730-
Expression::CInt(20),
731-
Expression::CInt(30),
732-
]);
733-
734-
let assignment = Statement::Assignment("list".to_string(), Box::new(new_list.clone()));
735-
736-
let result_env = execute(assignment, &env_with_list);
737-
738-
assert!(result_env.is_ok());
739-
let final_env = result_env.unwrap();
740-
741-
let final_list_value = final_env.lookup(&"list".to_string());
742-
assert!(final_list_value.is_some());
743-
let (is_still_mutable, final_list_expr) = final_list_value.unwrap();
744-
assert_eq!(final_list_expr, new_list);
745-
assert!(is_still_mutable);
746-
}
747-
}
748-
749473
mod for_statement_tests {
750474
use super::*;
751475

0 commit comments

Comments
 (0)