use crate::grid::resolve_tracks;
use crate::Theme;
use crate::{arrange_node, measure_node, LayoutContext, Point, Size, SizeConstraint};
use k2f_core::{CellAlign, FixedSizeHint, GridTrack, LayoutHint, NodeContent, Pt, SemanticNode};
fn make_image(id: &str) -> SemanticNode {
SemanticNode {
id: id.to_string(),
role: "body".to_string(),
variant: None,
preserve_whitespace: None,
list_id: None,
depth: None,
marker_type: None,
content: NodeContent::Image {
src: id.to_string(),
width: Pt(100000),
height: Pt(100000),
},
modifiers: vec![],
layout: None,
..Default::default()
}
}
#[test]
fn test_grid_fr_remainder_distribution_is_stable() {
let tracks = vec![
GridTrack::Fr { fr: 1 },
GridTrack::Fr { fr: 1 },
GridTrack::Fr { fr: 1 },
];
let out = resolve_tracks(&tracks, Pt::ZERO, Pt(10)).unwrap();
assert_eq!(out, vec![Pt(4), Pt(3), Pt(3)]);
let out_with_gaps = resolve_tracks(&tracks, Pt(1), Pt(10)).unwrap();
assert_eq!(out_with_gaps, vec![Pt(3), Pt(3), Pt(2)]);
}
#[test]
fn test_grid_known_sizes_produce_expected_child_positions_and_cell_sizes() {
let fonts = crate::test_utils::test_fonts();
let theme = Theme::default();
let ctx = LayoutContext::new(&fonts, &theme);
let gap = 1000_i64; let gap_pt = Pt(gap as i128);
let columns = vec![GridTrack::Pt { pt: 10000 }, GridTrack::Pt { pt: 20000 }]; let rows = vec![GridTrack::Pt { pt: 30000 }, GridTrack::Pt { pt: 40000 }];
let container = SemanticNode {
id: "grid".to_string(),
role: "section".to_string(),
variant: None,
preserve_whitespace: None,
list_id: None,
depth: None,
marker_type: None,
content: NodeContent::Container {
children: vec![
make_image("a"),
make_image("b"),
make_image("c"),
make_image("d"),
],
},
modifiers: vec![],
layout: Some(LayoutHint::Grid {
columns,
rows,
gap,
row_gap: None,
column_gap: None,
cell_align: Some(CellAlign::default()),
size: Default::default(),
}),
..Default::default()
};
let measured = measure_node(&container, SizeConstraint::infinite(), &ctx).unwrap();
let start = Point::new(Pt(50000), Pt(60000)); let geo = arrange_node(&container, start, measured, &ctx).unwrap();
assert_eq!(geo.children.len(), 4);
assert_eq!(geo.children[0].x, start.x);
assert_eq!(geo.children[0].y, start.y);
assert_eq!(geo.children[0].width, Pt(10000));
assert_eq!(geo.children[0].height, Pt(30000));
assert_eq!(geo.children[1].x, start.x + Pt(10000) + gap_pt);
assert_eq!(geo.children[1].y, start.y);
assert_eq!(geo.children[1].width, Pt(20000));
assert_eq!(geo.children[1].height, Pt(30000));
assert_eq!(geo.children[2].x, start.x);
assert_eq!(geo.children[2].y, start.y + Pt(30000) + gap_pt);
assert_eq!(geo.children[2].width, Pt(10000));
assert_eq!(geo.children[2].height, Pt(40000));
assert_eq!(geo.children[3].x, start.x + Pt(10000) + gap_pt);
assert_eq!(geo.children[3].y, start.y + Pt(30000) + gap_pt);
assert_eq!(geo.children[3].width, Pt(20000));
assert_eq!(geo.children[3].height, Pt(40000));
}
#[test]
fn test_grid_fr_tracks_account_for_gaps_and_constraints() {
let fonts = crate::test_utils::test_fonts();
let theme = Theme::default();
let ctx = LayoutContext::new(&fonts, &theme);
let gap = 1_i64;
let gap_pt = Pt(gap as i128);
let columns = vec![GridTrack::Fr { fr: 1 }, GridTrack::Fr { fr: 2 }];
let rows = vec![GridTrack::Fr { fr: 1 }];
let container = SemanticNode {
id: "grid".to_string(),
role: "section".to_string(),
variant: None,
preserve_whitespace: None,
list_id: None,
depth: None,
marker_type: None,
content: NodeContent::Container {
children: vec![make_image("a"), make_image("b")],
},
modifiers: vec![],
layout: Some(LayoutHint::Grid {
columns,
rows,
gap,
row_gap: None,
column_gap: None,
cell_align: Some(CellAlign::default()),
size: Default::default(),
}),
..Default::default()
};
let constraint = SizeConstraint::new(Size::ZERO, Size::new(Pt(10), Pt(5)));
let measured = measure_node(&container, constraint, &ctx).unwrap();
assert_eq!(measured.width, Pt(10));
assert_eq!(measured.height, Pt(5));
let geo = arrange_node(&container, Point::ZERO, measured, &ctx).unwrap();
assert_eq!(geo.children.len(), 2);
assert_eq!(geo.children[0].x, Pt(0));
assert_eq!(geo.children[0].width, Pt(3));
assert_eq!(geo.children[1].x, Pt(3) + gap_pt);
assert_eq!(geo.children[1].width, Pt(6));
}
#[test]
fn test_grid_own_height_resolves_fr_rows_in_unbounded_flow() {
let fonts = crate::test_utils::test_fonts();
let theme = Theme::default();
let ctx = LayoutContext::new(&fonts, &theme);
let unbounded = LayoutHint::Grid {
columns: vec![GridTrack::Pt { pt: 100_000 }],
rows: vec![GridTrack::Fr { fr: 1 }, GridTrack::Pt { pt: 40_000 }],
gap: 0,
row_gap: None,
column_gap: None,
cell_align: None,
size: FixedSizeHint::default(),
};
let fail_node = SemanticNode {
id: "g_fail".into(),
role: "body".into(),
content: NodeContent::Container {
children: vec![make_image("a"), make_image("b")],
},
layout: Some(unbounded),
..Default::default()
};
let err = measure_node(&fail_node, SizeConstraint::infinite(), &ctx).unwrap_err();
assert!(
err.contains("Cannot resolve fr tracks"),
"expected fr failure, got {err}"
);
let fixed = LayoutHint::Grid {
columns: vec![GridTrack::Pt { pt: 100_000 }],
rows: vec![GridTrack::Fr { fr: 1 }, GridTrack::Pt { pt: 40_000 }],
gap: 0,
row_gap: None,
column_gap: None,
cell_align: Some(CellAlign::default()),
size: FixedSizeHint {
width: None,
height: Some(Pt(200_000)),
},
};
let ok_node = SemanticNode {
id: "g_ok".into(),
role: "body".into(),
content: NodeContent::Container {
children: vec![make_image("a"), make_image("b")],
},
layout: Some(fixed),
..Default::default()
};
let measured = measure_node(&ok_node, SizeConstraint::infinite(), &ctx).unwrap();
assert_eq!(measured.width, Pt(100_000));
assert_eq!(measured.height, Pt(200_000));
let geo = arrange_node(&ok_node, Point::ZERO, measured, &ctx).unwrap();
assert_eq!(geo.children.len(), 2);
assert_eq!(geo.children[0].height, Pt(160_000));
assert_eq!(geo.children[1].y, Pt(160_000));
assert_eq!(geo.children[1].height, Pt(40_000));
}
#[test]
fn test_grid_auto_fr_auto_rows_fill_fixed_height() {
let fonts = crate::test_utils::test_fonts();
let theme = Theme::default();
let ctx = LayoutContext::new(&fonts, &theme);
let header = make_image("h");
let body = make_image("b");
let footer = make_image("f");
let container = SemanticNode {
id: "g".to_string(),
role: "section".to_string(),
content: NodeContent::Container {
children: vec![header, body, footer],
},
layout: Some(LayoutHint::Grid {
columns: vec![GridTrack::Fr { fr: 1 }],
rows: vec![
GridTrack::Auto { auto: true },
GridTrack::Fr { fr: 1 },
GridTrack::Auto { auto: true },
],
gap: 0,
row_gap: None,
column_gap: None,
cell_align: Some(CellAlign::default()),
size: FixedSizeHint {
width: Some(Pt(100_000)),
height: Some(Pt(400_000)),
},
}),
..Default::default()
};
let measured = measure_node(&container, SizeConstraint::infinite(), &ctx).unwrap();
assert_eq!(measured.height, Pt(400_000));
let geo = arrange_node(&container, Point::ZERO, measured, &ctx).unwrap();
assert_eq!(geo.children.len(), 3);
assert_eq!(geo.children[0].height, Pt(100_000));
assert_eq!(geo.children[1].height, Pt(200_000));
assert_eq!(geo.children[2].height, Pt(100_000));
assert_eq!(geo.children[2].y, Pt(300_000));
}
#[test]
fn test_resolve_tracks_rejects_auto_without_intrinsics() {
let err = resolve_tracks(&[GridTrack::Auto { auto: true }], Pt::ZERO, Pt(100)).unwrap_err();
assert!(err.contains("auto"));
}
#[test]
fn test_grid_auto_rows_sum_when_height_unbounded() {
let fonts = crate::test_utils::test_fonts();
let theme = Theme::default();
let ctx = LayoutContext::new(&fonts, &theme);
let container = SemanticNode {
id: "g".to_string(),
role: "section".to_string(),
content: NodeContent::Container {
children: vec![make_image("a"), make_image("b")],
},
layout: Some(LayoutHint::Grid {
columns: vec![GridTrack::Fr { fr: 1 }],
rows: vec![
GridTrack::Auto { auto: true },
GridTrack::Auto { auto: true },
],
gap: 0,
row_gap: None,
column_gap: None,
cell_align: Some(CellAlign::default()),
size: FixedSizeHint {
width: Some(Pt(100_000)),
height: None,
},
}),
..Default::default()
};
let measured = measure_node(&container, SizeConstraint::infinite(), &ctx).unwrap();
assert_eq!(measured.height, Pt(200_000));
}
#[test]
fn test_grid_auto_plus_fr_fails_when_height_unbounded() {
let fonts = crate::test_utils::test_fonts();
let theme = Theme::default();
let ctx = LayoutContext::new(&fonts, &theme);
let container = SemanticNode {
id: "g".to_string(),
role: "section".to_string(),
content: NodeContent::Container {
children: vec![make_image("a"), make_image("b")],
},
layout: Some(LayoutHint::Grid {
columns: vec![GridTrack::Pt { pt: 100_000 }],
rows: vec![GridTrack::Auto { auto: true }, GridTrack::Fr { fr: 1 }],
gap: 0,
row_gap: None,
column_gap: None,
cell_align: Some(CellAlign::default()),
size: Default::default(),
}),
..Default::default()
};
let err = measure_node(&container, SizeConstraint::infinite(), &ctx).unwrap_err();
assert!(err.contains("infinite available size"));
}
#[test]
fn omitted_rows_one_auto_row_for_two_column_split() {
let fonts = crate::test_utils::test_fonts();
let theme = Theme::default();
let ctx = LayoutContext::new(&fonts, &theme);
let container = SemanticNode {
id: "g".to_string(),
role: "section".to_string(),
content: NodeContent::Container {
children: vec![make_image("a"), make_image("b")],
},
layout: Some(LayoutHint::Grid {
columns: vec![GridTrack::Fr { fr: 1 }, GridTrack::Fr { fr: 1 }],
rows: vec![],
gap: 0,
row_gap: None,
column_gap: None,
cell_align: Some(CellAlign::default()),
size: FixedSizeHint {
width: Some(Pt(200_000)),
height: None,
},
}),
..Default::default()
};
let measured = measure_node(&container, SizeConstraint::infinite(), &ctx).unwrap();
assert_eq!(measured.height, Pt(100_000));
let geo = arrange_node(&container, Point::ZERO, measured, &ctx).unwrap();
assert_eq!(geo.children.len(), 2);
assert_eq!(geo.children[0].y, Pt(0));
assert_eq!(geo.children[1].y, Pt(0));
}
#[test]
fn omitted_rows_two_auto_rows_for_four_children() {
let fonts = crate::test_utils::test_fonts();
let theme = Theme::default();
let ctx = LayoutContext::new(&fonts, &theme);
let container = SemanticNode {
id: "g".to_string(),
role: "section".to_string(),
content: NodeContent::Container {
children: vec![
make_image("a"),
make_image("b"),
make_image("c"),
make_image("d"),
],
},
layout: Some(LayoutHint::Grid {
columns: vec![GridTrack::Fr { fr: 1 }, GridTrack::Fr { fr: 1 }],
rows: vec![],
gap: 0,
row_gap: None,
column_gap: None,
cell_align: Some(CellAlign::default()),
size: FixedSizeHint {
width: Some(Pt(200_000)),
height: None,
},
}),
..Default::default()
};
let measured = measure_node(&container, SizeConstraint::infinite(), &ctx).unwrap();
assert_eq!(measured.height, Pt(200_000));
let geo = arrange_node(&container, Point::ZERO, measured, &ctx).unwrap();
assert_eq!(geo.children.len(), 4);
assert_eq!(geo.children[2].y, Pt(100_000));
}
fn make_text(id: &str, content: &str) -> SemanticNode {
SemanticNode {
id: id.to_string(),
role: "body".to_string(),
content: NodeContent::Text(content.to_string()),
..Default::default()
}
}
fn two_col_grid(children: Vec<SemanticNode>, columns: Vec<GridTrack>, width: i128) -> SemanticNode {
SemanticNode {
id: "g".to_string(),
role: "section".to_string(),
content: NodeContent::Container { children },
layout: Some(LayoutHint::Grid {
columns,
rows: vec![],
gap: 1000,
row_gap: None,
column_gap: None,
cell_align: Some(CellAlign::default()),
size: FixedSizeHint {
width: Some(Pt(width)),
height: None,
},
}),
..Default::default()
}
}
#[test]
fn two_auto_text_columns_do_not_overlap() {
let fonts = crate::test_utils::test_fonts();
let theme = Theme::default();
let ctx = LayoutContext::new(&fonts, &theme);
let long = "SETTLEMENT REFERENCE VALUE WITH TRACKING AND LARGE TYPE";
let container = two_col_grid(
vec![make_text("a", long), make_text("b", long)],
vec![
GridTrack::Auto { auto: true },
GridTrack::Auto { auto: true },
],
80_000,
);
let measured = measure_node(&container, SizeConstraint::infinite(), &ctx).unwrap();
let geo = arrange_node(&container, Point::ZERO, measured, &ctx).unwrap();
assert_eq!(geo.children.len(), 2);
let a = &geo.children[0];
let b = &geo.children[1];
assert!(
a.x + a.width <= b.x,
"auto columns overlap: left={}..{} right={}..{}",
a.x.0,
(a.x + a.width).0,
b.x.0,
(b.x + b.width).0
);
assert!(a.width.0 > 0 && b.width.0 > 0);
}
#[test]
fn fr_plus_short_auto_still_hugs_the_auto_column() {
let fonts = crate::test_utils::test_fonts();
let theme = Theme::default();
let ctx = LayoutContext::new(&fonts, &theme);
let container = two_col_grid(
vec![make_text("label", "Total"), make_text("val", "$48")],
vec![GridTrack::Fr { fr: 1 }, GridTrack::Auto { auto: true }],
200_000,
);
let measured = measure_node(&container, SizeConstraint::infinite(), &ctx).unwrap();
let geo = arrange_node(&container, Point::ZERO, measured, &ctx).unwrap();
let auto_w = geo.children[1].width;
let fr_w = geo.children[0].width;
assert!(
auto_w.0 < fr_w.0,
"auto should hug, fr should take leftover"
);
assert!(auto_w.0 > 0);
}