use decy_parser::parser::Expression;
use decy_parser::CParser;
#[test]
fn test_parse_simple_pointer_field_access() {
let parser = CParser::new().expect("Parser creation failed");
let source = r#"
struct Node {
int value;
};
int get_value(struct Node* node) {
return node->value;
}
"#;
let ast = parser.parse(source).expect("Parsing should succeed");
assert_eq!(ast.functions().len(), 1, "Should parse one function");
let func = &ast.functions()[0];
assert_eq!(func.name, "get_value");
if let decy_parser::parser::Statement::Return(Some(expr)) = &func.body[0] {
match expr {
Expression::PointerFieldAccess { pointer, field } => {
assert!(
matches!(**pointer, Expression::Variable(_)),
"Pointer should be a variable"
);
assert_eq!(field, "value", "Field name should be 'value'");
}
_ => panic!("Expected PointerFieldAccess expression, got {:?}", expr),
}
} else {
panic!("Expected return statement with expression");
}
}
#[test]
fn test_parse_nested_pointer_field_access() {
let parser = CParser::new().expect("Parser creation failed");
let source = r#"
struct Point {
int x;
int y;
};
struct Rectangle {
struct Point top_left;
struct Point bottom_right;
};
int get_x(struct Rectangle* r) {
return r->bottom_right.x;
}
"#;
let ast = parser.parse(source).expect("Parsing should succeed");
let func = &ast.functions()[0];
assert_eq!(func.name, "get_x");
if let decy_parser::parser::Statement::Return(Some(expr)) = &func.body[0] {
match expr {
Expression::FieldAccess { object, field } => {
assert_eq!(field, "x", "Final field should be 'x'");
assert!(
matches!(**object, Expression::PointerFieldAccess { .. }),
"Object should be PointerFieldAccess"
);
}
_ => panic!("Expected nested FieldAccess, got {:?}", expr),
}
} else {
panic!("Expected return statement");
}
}
#[test]
fn test_pointer_vs_direct_field_access() {
let parser = CParser::new().expect("Parser creation failed");
let source = r#"
struct Data {
int value;
};
int compare(struct Data obj, struct Data* ptr) {
int a = obj.value; // Direct field access
int b = ptr->value; // Pointer field access
return a + b;
}
"#;
let ast = parser.parse(source).expect("Parsing should succeed");
let func = &ast.functions()[0];
assert_eq!(func.body.len(), 3, "Should have 3 statements (2 decls + return)");
if let decy_parser::parser::Statement::VariableDeclaration { initializer: Some(expr), .. } =
&func.body[0]
{
assert!(
matches!(expr, Expression::FieldAccess { .. }),
"First access should be FieldAccess (obj.value)"
);
}
if let decy_parser::parser::Statement::VariableDeclaration { initializer: Some(expr), .. } =
&func.body[1]
{
assert!(
matches!(expr, Expression::PointerFieldAccess { .. }),
"Second access should be PointerFieldAccess (ptr->value)"
);
}
}
#[test]
fn test_parse_pointer_field_in_assignment() {
let parser = CParser::new().expect("Parser creation failed");
let source = r#"
struct Node {
int value;
struct Node* next;
};
void traverse(struct Node* head) {
head = head->next;
}
"#;
let ast = parser.parse(source).expect("Parsing should succeed");
let func = &ast.functions()[0];
assert_eq!(func.name, "traverse");
if let decy_parser::parser::Statement::Assignment { value, .. } = &func.body[0] {
assert!(
matches!(value, Expression::PointerFieldAccess { .. }),
"Assignment value should be PointerFieldAccess"
);
} else {
panic!("Expected assignment statement");
}
}
#[test]
fn test_parse_chained_pointer_field_access() {
let parser = CParser::new().expect("Parser creation failed");
let source = r#"
struct Node {
int value;
struct Node* next;
};
int get_next_value(struct Node* node) {
return node->next->value;
}
"#;
let ast = parser.parse(source).expect("Parsing should succeed");
let func = &ast.functions()[0];
if let decy_parser::parser::Statement::Return(Some(expr)) = &func.body[0] {
match expr {
Expression::PointerFieldAccess { pointer, field } => {
assert_eq!(field, "value", "Final field should be 'value'");
assert!(
matches!(**pointer, Expression::PointerFieldAccess { .. }),
"Pointer should be another PointerFieldAccess (node->next)"
);
}
_ => panic!("Expected chained PointerFieldAccess, got {:?}", expr),
}
}
}