#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use excelerate::coordinate::{Col, Row};
use excelerate::edit::insert_rows;
use excelerate::model::Spreadsheet;
use excelerate::model::chart::{
Anchor, AxisKind, BarDirection, Chart, ChartAxis, ChartColor, ChartEx, ChartLines, ChartText,
ColorBase, ColorTransform, DataLabel, DataLabels, DataPoint, DataSource, Dimension,
DimensionRole, ExLabels, ExLegend, ExSeries, Fill, GradientPath, GradientStop, Grouping,
LabelPosition, LegendPosition, LineFormat, Marker, MarkerSymbol, Plot, PlotKind, Series,
SeriesLayout, SeriesMarker, ShapeFormat, Title, UpDownBars,
};
use excelerate::reader::xlsx::read_xlsx_from;
use excelerate::writer::xlsx::write_xlsx_to;
use std::io::Cursor;
fn open(name: &str) -> Spreadsheet {
let path = format!("{}/tests/{name}", env!("CARGO_MANIFEST_DIR"));
read_xlsx_from(Cursor::new(std::fs::read(path).unwrap())).unwrap()
}
fn cycle(book: &Spreadsheet) -> Spreadsheet {
let mut bytes = Vec::new();
write_xlsx_to(book, Cursor::new(&mut bytes)).unwrap();
read_xlsx_from(Cursor::new(bytes)).unwrap()
}
fn part<'a>(book: &'a Spreadsheet, path: &str) -> &'a [u8] {
&book
.parts
.iter()
.find(|p| p.path == path)
.unwrap_or_else(|| panic!("{path} is in the package"))
.data
}
fn chart_part(chart: &Chart) -> &str {
chart.origin.as_ref().expect("the chart was read").part()
}
#[test]
fn a_combination_chart_is_read_whole() {
let book = open("chart2.xlsx");
let sheet = book.sheet(0).unwrap();
assert_eq!(sheet.charts.len(), 1);
let chart = &sheet.charts[0];
assert_eq!(chart.name, "Диаграмма 2");
let Anchor::TwoCell { from, to, edit_as } = chart.anchor else {
panic!("a two-cell anchor, got {:?}", chart.anchor);
};
assert_eq!((from.col.index(), from.row.index()), (5, 3));
assert_eq!((to.col.index(), to.row.index()), (16, 30));
assert_eq!(edit_as, None);
let title = chart.title.as_ref().unwrap().text.as_ref().unwrap();
assert_eq!(
*title,
ChartText::Reference {
formula: "Лист1!$A$3".into(),
cache: Some("Объемы продаж филиала".into()),
}
);
let kinds: Vec<PlotKind> = chart.plots.iter().map(|p| p.kind).collect();
let bar = |grouping| PlotKind::Bar {
direction: BarDirection::Column,
grouping,
three_d: false,
};
assert_eq!(kinds, [bar(Grouping::Clustered), bar(Grouping::Stacked)]);
assert_eq!(chart.plots[1].series.len(), 2);
let total = &chart.plots[0].series[0];
assert_eq!(
total.name.as_ref().and_then(ChartText::shown),
Some("Всего продано")
);
let Some(DataSource::Numbers {
formula, points, ..
}) = &total.values
else {
panic!("numbers, got {:?}", total.values);
};
assert_eq!(formula.as_deref(), Some("Лист1!$B$6:$B$18"));
assert_eq!(points[..3], [(0, 149.0), (1, 152.0), (2, 165.0)]);
let Some(DataSource::Numbers { format_code, .. }) = &total.categories else {
panic!("dates are numbers");
};
assert_eq!(format_code.as_deref(), Some("m/d/yyyy"));
assert_eq!(
total.format.as_ref().unwrap().fill,
Some(Fill::Solid(ChartColor::rgb(0x00_B150)))
);
assert!(total.markup.after_format.contains("invertIfNegative"));
assert_eq!(chart.axes.len(), 4);
for plot in &chart.plots {
for id in &plot.axis_ids {
assert!(chart.axes.iter().any(|a| a.id == *id), "axis {id}");
}
}
assert!(chart.axes.iter().any(|a| a.kind == AxisKind::Date));
assert_eq!(chart.legend.as_ref().unwrap().position, LegendPosition::Top);
}
#[test]
fn every_chart_of_a_dashboard_is_found() {
let book = open("chart1.xlsx");
let classic = [12, 8, 8, 7, 10, 10, 10, 12, 8, 8, 7, 10, 10, 10];
for (index, expected) in classic.iter().enumerate() {
let sheet = book.sheet(index).unwrap();
assert_eq!(sheet.charts.len(), *expected, "sheet {}", sheet.title());
assert_eq!(sheet.extended_charts.len(), 1, "sheet {}", sheet.title());
let waterfall = &sheet.extended_charts[0];
assert_eq!(waterfall.series[0].layout, SeriesLayout::Waterfall);
let dimension = &waterfall.series[0].dimensions[0];
assert!(
dimension
.formula
.as_deref()
.unwrap()
.starts_with("_xlchart.")
);
let range = dimension.reference(&book.defined_names).unwrap();
assert!(
range.contains('!') && !range.starts_with("_xlchart"),
"{range}"
);
}
let total: usize = book.sheets().iter().map(|s| s.charts.len()).sum();
assert_eq!(total, 130, "one chart per chart part");
}
#[test]
fn an_untouched_chart_goes_back_as_it_came() {
for name in ["chart1.xlsx", "chart2.xlsx"] {
let book = open(name);
let back = cycle(&book);
for (before, after) in book.sheets().iter().zip(back.sheets()) {
assert_eq!(before.charts, after.charts, "{name}: {}", before.title());
assert_eq!(before.extended_charts, after.extended_charts);
for chart in &before.charts {
assert!(chart.is_unchanged());
let path = chart_part(chart);
assert_eq!(part(&book, path), part(&back, path), "{name}: {path}");
}
}
}
}
#[test]
fn a_changed_chart_is_written_from_the_model() {
let mut book = open("chart2.xlsx");
let original = book.sheet(0).unwrap().charts[0].clone();
let chart = &mut book.sheet_mut(0).unwrap().charts[0];
chart.title = Some(Title {
text: Some(ChartText::text("Продажи по годам")),
..chart.title.clone().unwrap()
});
chart.plots[0].series[0].values = Some(DataSource::numbers("Лист1!$B$6:$B$17"));
chart.axes[1].max = Some(250.0);
let edited = chart.clone();
assert!(!edited.is_unchanged());
let back = cycle(&book);
let after = &back.sheet(0).unwrap().charts[0];
let path = chart_part(&original);
assert_ne!(
part(&book, path),
part(&back, path),
"the part was rewritten"
);
assert_eq!(
after.title.as_ref().unwrap().text.as_ref().unwrap().shown(),
Some("Продажи по годам")
);
assert_eq!(after.plots, edited.plots);
assert_eq!(after.axes, edited.axes);
assert_eq!(after.legend, edited.legend);
assert_eq!(after.markup, edited.markup);
assert_eq!(
(&after.name, after.anchor),
(&original.name, original.anchor)
);
}
#[test]
fn a_chart_under_a_default_namespace_is_rewritten_in_it() {
let mut book = open("fixtures/chart.xlsx");
let chart = &mut book.sheet_mut(0).unwrap().charts[0];
assert_eq!(
chart.plots[0].series[0].values.as_ref().unwrap().formula(),
Some("Sheet1!$B$2:$B$5")
);
chart.plots[0].series[0].name = Some(ChartText::text("Выручка"));
let edited = chart.clone();
let back = cycle(&book);
let text = String::from_utf8(part(&back, chart_part(&edited)).to_vec()).unwrap();
assert!(
text.contains("<chartSpace xmlns=") && !text.contains("<c:ser>"),
"{text}"
);
let after = &back.sheet(0).unwrap().charts[0];
assert_eq!(after.plots, edited.plots);
assert_eq!(after.axes, edited.axes);
}
#[test]
fn a_chart_made_in_code_is_written() {
let mut book = Spreadsheet::new();
let mut plot = Plot::new(PlotKind::Line {
grouping: Grouping::Standard,
three_d: false,
});
plot.series.push(Series {
name: Some(ChartText::Reference {
formula: "Worksheet!$B$1".into(),
cache: None,
}),
categories: Some(DataSource::strings("Worksheet!$A$2:$A$5")),
values: Some(DataSource::numbers("Worksheet!$B$2:$B$5")),
..Series::default()
});
plot.axis_ids = vec![1, 2];
let anchor = Anchor::TwoCell {
from: Marker {
col: Col::new(3).unwrap(),
..Marker::default()
},
to: Marker {
col: Col::new(10).unwrap(),
row: Row::new(18).unwrap(),
..Marker::default()
},
edit_as: None,
};
let mut chart = Chart::default();
chart.name = "Выручка".into();
chart.anchor = anchor;
chart.title = Some(Title {
text: Some(ChartText::text("Выручка\nпо кварталам")),
..Title::default()
});
chart.plots = vec![plot.clone()];
chart.axes = vec![ChartAxis::category(1, 2), ChartAxis::value(2, 1)];
chart.legend = Some(excelerate::model::chart::Legend::default());
book.sheet_mut(0).unwrap().charts.push(chart);
let back = cycle(&book);
let sheet = back.sheet(0).unwrap();
assert_eq!(sheet.charts.len(), 1);
let chart = &sheet.charts[0];
assert_eq!((chart.name.as_str(), chart.anchor), ("Выручка", anchor));
assert_eq!(
chart.title.as_ref().unwrap().text.as_ref().unwrap().shown(),
Some("Выручка\nпо кварталам")
);
assert_eq!(chart.plots.len(), 1);
assert_eq!(chart.plots[0].kind, plot.kind);
assert_eq!(chart.plots[0].series[0].values, plot.series[0].values);
assert_eq!(chart.plots[0].series[0].name, plot.series[0].name);
let kinds: Vec<AxisKind> = chart.axes.iter().map(|a| a.kind).collect();
assert_eq!(kinds, [AxisKind::Category, AxisKind::Value]);
assert!(chart.is_unchanged());
assert_eq!(cycle(&back).sheet(0).unwrap().charts, sheet.charts);
}
#[test]
fn a_new_chart_joins_a_drawing_that_already_has_charts() {
let mut book = open("chart2.xlsx");
let mut copy = book.sheet(0).unwrap().charts[0].clone();
copy.origin = None;
copy.name = "Копия".into();
book.sheet_mut(0).unwrap().charts.push(copy.clone());
let back = cycle(&book);
let charts = &back.sheet(0).unwrap().charts;
assert_eq!(charts.len(), 2);
let (old, new) = (&charts[0], &charts[1]);
assert_eq!(old.name, "Диаграмма 2");
assert!(old.is_unchanged());
assert_eq!(new.name, "Копия");
assert_ne!(chart_part(old), chart_part(new), "a part of its own");
assert_eq!(new.plots, copy.plots);
assert_eq!(new.axes, copy.axes);
let drawing =
String::from_utf8(part(&back, new.origin.as_ref().unwrap().drawing()).to_vec()).unwrap();
let mut ids: Vec<&str> = drawing
.split("cNvPr id=\"")
.skip(1)
.filter_map(|s| s.split('"').next())
.collect();
let count = ids.len();
ids.sort_unstable();
ids.dedup();
assert_eq!(ids.len(), count, "object ids are unique: {drawing}");
}
#[test]
fn a_removed_chart_leaves_its_neighbours_alone() {
let mut book = open("chart1.xlsx");
let removed = book.sheet_mut(1).unwrap().charts.remove(0);
let back = cycle(&book);
let before = &book.sheet(1).unwrap().charts;
let after = &back.sheet(1).unwrap().charts;
assert_eq!(after.len(), before.len());
assert!(!after.iter().any(|c| chart_part(c) == chart_part(&removed)));
for (b, a) in before.iter().zip(after) {
assert_eq!(b.name, a.name);
assert_eq!(b.anchor, a.anchor);
assert_eq!(part(&book, chart_part(b)), part(&back, chart_part(a)));
}
assert_eq!(book.sheet(2).unwrap().charts, back.sheet(2).unwrap().charts);
}
#[test]
fn a_moved_chart_keeps_its_part() {
let mut book = open("chart2.xlsx");
let anchor = Anchor::OneCell {
from: Marker {
col: Col::new(1).unwrap(),
row: Row::new(40).unwrap(),
..Marker::default()
},
width: 5_000_000,
height: 3_000_000,
};
book.sheet_mut(0).unwrap().charts[0].anchor = anchor;
let back = cycle(&book);
let chart = &back.sheet(0).unwrap().charts[0];
assert_eq!(chart.anchor, anchor);
let path = chart_part(chart);
assert_eq!(part(&book, path), part(&back, path), "only the frame moved");
}
#[test]
fn inserted_rows_move_the_chart_and_what_it_reads() {
let mut book = open("chart2.xlsx");
insert_rows(&mut book, 0, Row::from_one_based(1).unwrap(), 2).unwrap();
let chart = &book.sheet(0).unwrap().charts[0];
let Anchor::TwoCell { from, .. } = chart.anchor else {
panic!("a two-cell anchor");
};
assert_eq!(from.row.index(), 5);
assert_eq!(
chart.plots[0].series[0].values.as_ref().unwrap().formula(),
Some("Лист1!$B$8:$B$20")
);
assert!(chart.is_unchanged());
assert_eq!(
cycle(&book).sheet(0).unwrap().charts[0].anchor,
chart.anchor
);
}
#[test]
fn a_plot_with_no_axes_is_refused() {
let mut book = Spreadsheet::new();
let mut plot = Plot::new(PlotKind::Bar {
direction: BarDirection::Bar,
grouping: Grouping::Clustered,
three_d: false,
});
plot.series.push(Series {
values: Some(DataSource::numbers("Worksheet!$A$1:$A$3")),
..Series::default()
});
let mut chart = Chart::default();
chart.plots = vec![plot];
book.sheet_mut(0).unwrap().charts.push(chart);
let mut bytes = Vec::new();
assert!(write_xlsx_to(&book, Cursor::new(&mut bytes)).is_err());
}
fn said(chart: &ChartEx) -> (String, Anchor, Option<ChartText>, Vec<ExSeries>) {
let plain = |text: &ChartText| match text {
ChartText::Text { text, .. } => ChartText::text(text),
other => other.clone(),
};
(
chart.name.clone(),
chart.anchor,
chart.title.as_ref().map(plain),
chart
.series
.iter()
.map(|series| ExSeries {
name: series.name.as_ref().map(plain),
..series.clone()
})
.collect(),
)
}
#[test]
fn a_changed_waterfall_keeps_its_formatting() {
let mut book = open("chart1.xlsx");
let sheet = book.sheet_mut(0).unwrap();
let chart = &mut sheet.extended_charts[0];
let path = chart.part.clone();
chart.name = "Bridge & walk".into();
chart.title = Some(ChartText::text("Profit bridge"));
chart.series[0].name = Some(ChartText::Reference {
formula: "Sheet1!$A$1".into(),
cache: Some("2025".into()),
});
chart.series[0].dimensions[1].formula = Some("'Q1'!$C$2:$C$9".into());
if let Anchor::TwoCell { from, to, .. } = &mut chart.anchor {
from.row = Row::new(from.row.index() + 3).unwrap();
to.row = Row::new(to.row.index() + 3).unwrap();
}
let wanted = said(chart);
let back = cycle(&book);
let after = &back.sheet(0).unwrap().extended_charts[0];
assert_eq!(said(after), wanted);
assert_eq!(after.part, path, "the part is edited, not replaced");
let text = std::str::from_utf8(part(&back, &path)).unwrap();
assert!(text.contains("<cx:dataPt idx=\"7\">"), "point colours stay");
assert!(text.contains("<cx:subtotals>"), "subtotal bars stay");
for before in book.sheets()[1..].iter().flat_map(|s| &s.extended_charts) {
assert_eq!(part(&book, &before.part), part(&back, &before.part));
}
}
#[test]
fn a_removed_waterfall_leaves_the_classic_charts() {
let mut book = open("chart1.xlsx");
book.sheet_mut(2).unwrap().extended_charts.clear();
let back = cycle(&book);
let sheet = back.sheet(2).unwrap();
assert_eq!(sheet.extended_charts, []);
assert_eq!(sheet.charts, book.sheet(2).unwrap().charts);
}
#[test]
fn a_funnel_made_in_code_is_written() {
let mut book = open("chart2.xlsx");
let dimensions = vec![
Dimension {
role: DimensionRole::Categories,
numeric: false,
formula: Some("Sheet1!$A$2:$A$5".into()),
levels: vec![vec![(0, "Leads".into()), (1, "Calls".into())]],
},
Dimension {
role: DimensionRole::Values,
numeric: true,
formula: Some("Sheet1!$B$2:$B$5".into()),
levels: Vec::new(),
},
];
let from = Marker {
col: Col::new(10).unwrap(),
row: Row::new(2).unwrap(),
..Marker::default()
};
let to = Marker {
col: Col::new(16).unwrap(),
row: Row::new(18).unwrap(),
..Marker::default()
};
let mut funnel = ChartEx::new(
SeriesLayout::Funnel,
dimensions,
Anchor::TwoCell {
from,
to,
edit_as: None,
},
);
funnel.name = "Pipeline".into();
funnel.title = Some(ChartText::text("Sales pipeline"));
let wanted = said(&funnel);
let sheet = book.sheet_mut(0).unwrap();
sheet.extended_charts.push(funnel);
let charts = sheet.charts.clone();
let back = cycle(&book);
let sheet = back.sheet(0).unwrap();
assert_eq!(sheet.extended_charts.len(), 1);
assert_eq!(said(&sheet.extended_charts[0]), wanted);
assert_eq!(sheet.charts, charts, "the classic chart beside it stays");
let again = cycle(&back);
assert_eq!(
again.sheet(0).unwrap().extended_charts,
sheet.extended_charts
);
}
fn chart_at<'a>(book: &'a Spreadsheet, path: &str) -> &'a Chart {
book.sheets()
.iter()
.flat_map(|s| &s.charts)
.find(|c| c.origin.as_ref().is_some_and(|o| o.part() == path))
.unwrap_or_else(|| panic!("a chart in {path}"))
}
fn chart_at_mut<'a>(book: &'a mut Spreadsheet, path: &str) -> &'a mut Chart {
let sheet = (0..book.sheets().len())
.find(|&i| {
book.sheet(i)
.unwrap()
.charts
.iter()
.any(|c| chart_part(c) == path)
})
.unwrap_or_else(|| panic!("a chart in {path}"));
book.sheet_mut(sheet)
.unwrap()
.charts
.iter_mut()
.find(|c| chart_part(c) == path)
.unwrap()
}
fn text_of(book: &Spreadsheet, path: &str) -> String {
String::from_utf8(part(book, path).to_vec()).unwrap()
}
#[test]
fn series_formatting_and_labels_are_read() {
let book = open("chart2.xlsx");
let chart = &book.sheet(0).unwrap().charts[0];
let series = &chart.plots[1].series;
assert_eq!(
series[0].format.as_ref().unwrap().fill,
Some(Fill::Solid(ChartColor::rgb(0xFF_C000)))
);
let spacer = &series[1];
assert_eq!(spacer.format.as_ref().unwrap().fill, Some(Fill::None));
assert!(spacer.labels.as_ref().unwrap().deleted);
let plot_labels = chart.plots[0].labels.as_ref().unwrap();
assert!(!plot_labels.deleted && !plot_labels.show_value && !plot_labels.show_percent);
let book = open("chart1.xlsx");
let pie = &chart_at(&book, "xl/charts/chart4.xml").plots[0];
assert!(matches!(pie.kind, PlotKind::Pie { .. }));
let points = &pie.series[0].data_points;
assert_eq!(
points.iter().map(|p| p.index).collect::<Vec<_>>(),
[0, 1, 2, 3, 4]
);
let slice = points[1].format.as_ref().unwrap();
assert_eq!(slice.fill, Some(Fill::Solid(ChartColor::rgb(0x66_FFFF))));
assert_eq!(
slice.line,
Some(LineFormat {
fill: Some(Fill::None),
width: Some(19050)
})
);
assert_eq!(
points[0].format.as_ref().unwrap().fill,
Some(Fill::Gradient {
stops: vec![
GradientStop {
position: 100_000,
color: ChartColor::rgb(0x89_40D9)
},
GradientStop {
position: 0,
color: ChartColor::rgb(0xB7_2CEE)
},
],
angle: Some(7_200_000),
path: None,
})
);
assert!(pie.labels.is_some());
let line = &chart_at(&book, "xl/charts/chart2.xml").plots;
let planned = line
.iter()
.flat_map(|p| &p.series)
.find(|s| s.name.as_ref().and_then(ChartText::shown) == Some("Planned"))
.unwrap();
let stroke = planned.format.as_ref().unwrap().line.as_ref().unwrap();
assert_eq!(stroke.width, Some(19050));
assert_eq!(stroke.fill, Some(Fill::Solid(ChartColor::rgb(0xA5_14F6))));
assert_eq!(
planned.marker.as_ref().unwrap().symbol,
Some(MarkerSymbol::None)
);
let chart = chart_at(&book, "xl/charts/chart102.xml");
let labels: Vec<&DataLabels> = chart
.plots
.iter()
.flat_map(|p| p.series.iter().filter_map(|s| s.labels.as_ref()))
.collect();
assert!(
labels
.iter()
.any(|l| l.show_value && l.position == Some(LabelPosition::Top)),
"{labels:?}"
);
let book = open("fixtures/chart.xlsx");
let labels = book.sheet(0).unwrap().charts[0].plots[0].series[0]
.labels
.clone()
.unwrap();
assert!(!labels.show_value && !labels.deleted);
}
#[test]
fn a_theme_colour_resolves_through_its_transforms() {
let accent = |transforms| ChartColor {
base: ColorBase::Scheme("accent1".into()),
transforms,
};
assert_eq!(accent(vec![]).resolve(None), Some(0x44_72C4));
assert_eq!(
accent(vec![ColorTransform::LumMod(75000)]).resolve(None),
Some(0x2F_5597),
"darker 25%"
);
let lighter = accent(vec![
ColorTransform::LumMod(60000),
ColorTransform::LumOff(40000),
])
.resolve(None)
.unwrap();
let excel: u32 = 0x8F_AADC;
for shift in [16, 8, 0] {
let channel = |c: u32| i64::from((c >> shift) & 0xFF);
assert!(
(channel(lighter) - channel(excel)).abs() <= 1,
"lighter 40%: {lighter:06X}"
);
}
assert_eq!(ChartColor::scheme("phClr").resolve(None), None);
}
#[test]
fn a_changed_series_colour_is_written_and_read_back() {
let mut book = open("chart2.xlsx");
let path = chart_part(&book.sheet(0).unwrap().charts[0]).to_owned();
let before = text_of(&book, &path);
let chart = &mut book.sheet_mut(0).unwrap().charts[0];
let red = Some(Fill::Solid(ChartColor::rgb(0xFF_0000)));
chart.plots[0].series[0].format.as_mut().unwrap().fill = red.clone();
let labels = chart.plots[0].labels.as_mut().unwrap();
labels.show_value = true;
labels.position = Some(LabelPosition::OutsideEnd);
let edited = chart.clone();
let back = cycle(&book);
let text = text_of(&back, &path);
let after = &back.sheet(0).unwrap().charts[0];
let total = &after.plots[0].series[0];
assert_eq!(total.format.as_ref().unwrap().fill, red);
assert!(!text.contains("00B150"), "the old colour is gone");
assert_eq!(total.markup, edited.plots[0].series[0].markup);
assert!(total.labels.as_ref().unwrap().deleted);
let labels = after.plots[0].labels.as_ref().unwrap();
assert!(labels.show_value && !labels.show_category_name);
assert_eq!(labels.position, Some(LabelPosition::OutsideEnd));
assert!(text.contains(r#"<c:showBubbleSize val="0"/>"#));
let other = r#"<c:spPr><a:solidFill><a:srgbClr val="FFC000"/></a:solidFill></c:spPr>"#;
assert!(before.contains(other) && text.contains(other));
assert_eq!(after.plots[1], edited.plots[1]);
}
#[test]
fn a_recoloured_slice_keeps_the_rest_of_its_formatting() {
let path = "xl/charts/chart4.xml";
let mut book = open("chart1.xlsx");
let chart = chart_at_mut(&mut book, path);
let theme = ChartColor {
base: ColorBase::Scheme("accent2".into()),
transforms: vec![ColorTransform::LumMod(50000)],
};
let points = &mut chart.plots[0].series[0].data_points;
points[1].format.as_mut().unwrap().fill = Some(Fill::Solid(theme.clone()));
points[2]
.format
.as_mut()
.unwrap()
.line
.as_mut()
.unwrap()
.width = Some(38100);
points.push(DataPoint {
index: 7,
format: Some(ShapeFormat::solid(ChartColor::rgb(0x12_3456))),
..DataPoint::default()
});
let back = cycle(&book);
let text = text_of(&back, path);
let points = &chart_at(&back, path).plots[0].series[0].data_points;
assert_eq!(
points[1].format.as_ref().unwrap().fill,
Some(Fill::Solid(theme))
);
assert_eq!(
points[2].format.as_ref().unwrap().line,
Some(LineFormat {
fill: Some(Fill::None),
width: Some(38100)
})
);
assert_eq!(
(
points[5].index,
points[5].format.as_ref().unwrap().fill.clone()
),
(7, Some(Fill::Solid(ChartColor::rgb(0x12_3456))))
);
let slice = &text[text.find(r#"<c:idx val="1"/>"#).unwrap()..];
let slice = &slice[..slice.find("</c:dPt>").unwrap()];
assert!(slice.contains(r#"<a:ln w="19050"><a:noFill/></a:ln><a:effectLst/>"#));
assert!(slice.contains("c16:uniqueId") && slice.contains("<c:bubble3D"));
assert!(text.contains(r#"<a:gs pos="100000"><a:srgbClr val="8940D9"/>"#));
assert!(
text.contains(r#"<a:ln w="38100"><a:noFill/></a:ln>"#),
"{text}"
);
}
#[test]
fn formatting_the_model_did_not_change_is_written_as_read() {
for path in [
"xl/charts/chart2.xml",
"xl/charts/chart4.xml",
"xl/charts/chart102.xml",
] {
let mut book = open("chart1.xlsx");
let before = text_of(&book, path);
let chart = chart_at_mut(&mut book, path);
chart.auto_title_deleted = !chart.auto_title_deleted;
let edited = chart.clone();
let back = cycle(&book);
let text = text_of(&back, path);
assert_ne!(before, text);
let series = edited.plots.iter().flat_map(|p| &p.series);
for s in series {
let sources = s
.format
.iter()
.filter_map(|f| f.source.as_deref())
.chain(s.marker.iter().filter_map(|m| m.source.as_deref()))
.chain(s.data_points.iter().filter_map(|p| p.source.as_deref()))
.chain(s.labels.iter().filter_map(|l| l.source.as_deref()));
for source in sources {
assert!(text.contains(source), "{path}: {source}");
}
}
let after = chart_at(&back, path);
assert_eq!(after.plots, edited.plots, "{path}");
}
}
const STOCK: &str = concat!(
r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>"#,
r#"<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" "#,
r#"xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" "#,
r#"xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">"#,
r#"<c:chart><c:autoTitleDeleted val="1"/><c:plotArea><c:layout/><c:stockChart>"#,
r#"<c:ser><c:idx val="0"/><c:order val="0"/><c:spPr><a:ln w="19050"><a:noFill/></a:ln></c:spPr>"#,
r#"<c:marker><c:symbol val="none"/></c:marker><c:val><c:numRef><c:f>Sheet1!$B$2:$B$3</c:f>"#,
r#"</c:numRef></c:val><c:smooth val="0"/></c:ser>"#,
r#"<c:hiLowLines><c:spPr><a:ln w="9525"><a:solidFill><a:schemeClr val="tx1"><a:lumMod val="75000"/>"#,
r#"<a:lumOff val="25000"/></a:schemeClr></a:solidFill></a:ln></c:spPr></c:hiLowLines>"#,
r#"<c:upDownBars><c:gapWidth val="150"/><c:upBars><c:spPr><a:solidFill><a:schemeClr val="lt1"/>"#,
r#"</a:solidFill></c:spPr></c:upBars><c:downBars><c:spPr><a:solidFill><a:schemeClr val="dk1"/>"#,
r#"</a:solidFill><a:effectLst/></c:spPr></c:downBars><c:extLst><c:ext uri="{X}"/></c:extLst>"#,
r#"</c:upDownBars><c:axId val="1"/><c:axId val="2"/></c:stockChart>"#,
r#"<c:catAx><c:axId val="1"/><c:scaling><c:orientation val="minMax"/></c:scaling><c:delete val="0"/>"#,
r#"<c:axPos val="b"/><c:crossAx val="2"/></c:catAx><c:valAx><c:axId val="2"/><c:scaling>"#,
r#"<c:orientation val="minMax"/></c:scaling><c:delete val="0"/><c:axPos val="l"/>"#,
r#"<c:crossAx val="1"/></c:valAx></c:plotArea><c:plotVisOnly val="1"/></c:chart></c:chartSpace>"#,
);
fn with_chart_part(xml: &str) -> (Spreadsheet, String) {
let mut book = open("chart2.xlsx");
let path = chart_part(&book.sheet(0).unwrap().charts[0]).to_owned();
let part = book.parts.iter_mut().find(|p| p.path == path).unwrap();
part.data = xml.as_bytes().to_vec();
(cycle(&book), path)
}
#[test]
fn stock_lines_and_bars_are_read_and_rewritten() {
let (mut book, path) = with_chart_part(STOCK);
let plot = &book.sheet(0).unwrap().charts[0].plots[0];
assert_eq!(plot.kind, PlotKind::Stock);
let lines = plot
.high_low_lines
.as_ref()
.unwrap()
.format
.as_ref()
.unwrap();
assert_eq!(lines.line.as_ref().unwrap().width, Some(9525));
assert_eq!(plot.drop_lines, None);
let bars = plot.up_down_bars.as_ref().unwrap();
assert_eq!(bars.gap_width, Some(150));
let fill = |f: &Option<ShapeFormat>| f.as_ref().unwrap().fill.clone();
assert_eq!(fill(&bars.up), Some(Fill::Solid(ChartColor::scheme("lt1"))));
assert_eq!(
fill(&bars.down),
Some(Fill::Solid(ChartColor::scheme("dk1")))
);
assert!(!plot.markup.contains("hiLowLines") && !plot.markup.contains("upDownBars"));
let plot = &mut book.sheet_mut(0).unwrap().charts[0].plots[0];
let bars = plot.up_down_bars.as_mut().unwrap();
bars.gap_width = Some(50);
bars.up = Some(ShapeFormat::solid(ChartColor::rgb(0xFF_0000)));
let edited = plot.clone();
let back = cycle(&book);
let text = text_of(&back, &path);
let after = &back.sheet(0).unwrap().charts[0].plots[0];
let bars = after.up_down_bars.as_ref().unwrap();
let wanted = edited.up_down_bars.as_ref().unwrap();
assert_eq!(bars.gap_width, Some(50));
assert_eq!(
fill(&bars.up),
Some(Fill::Solid(ChartColor::rgb(0xFF_0000)))
);
assert_eq!(bars.down, wanted.down);
assert_eq!(after.high_low_lines, edited.high_low_lines);
assert!(
text.contains(r#"<c:gapWidth val="50"/><c:upBars><c:spPr>"#),
"{text}"
);
assert!(text.contains(concat!(
r#"<c:downBars><c:spPr><a:solidFill><a:schemeClr val="dk1"/></a:solidFill>"#,
r#"<a:effectLst/></c:spPr></c:downBars><c:extLst><c:ext uri="{X}"/></c:extLst>"#,
r#"</c:upDownBars><c:axId val="1"/>"#
)));
assert!(text.contains("<c:hiLowLines><c:spPr><a:ln w=\"9525\">"));
let mut plot = Plot::new(PlotKind::Stock);
plot.axis_ids = vec![1, 2];
plot.high_low_lines = Some(ChartLines::default());
plot.up_down_bars = Some(UpDownBars::default());
let chart = &mut book.sheet_mut(0).unwrap().charts[0];
chart.plots = vec![plot];
let back = cycle(&book);
assert!(
text_of(&back, &path).contains(
"<c:hiLowLines/><c:upDownBars><c:upBars/><c:downBars/></c:upDownBars><c:axId"
)
);
let plot = &back.sheet(0).unwrap().charts[0].plots[0];
assert_eq!(plot.high_low_lines, Some(ChartLines::default()));
assert_eq!(plot.up_down_bars.as_ref().unwrap().up, None);
}
#[test]
fn a_marker_keeps_its_own_fill_and_outline() {
let path = "xl/charts/chart102.xml";
let mut book = open("chart1.xlsx");
let chart = chart_at_mut(&mut book, path);
let marker = chart
.plots
.iter_mut()
.flat_map(|p| &mut p.series)
.filter_map(|s| s.marker.as_mut())
.find(|m| m.format.is_some())
.unwrap();
let format = marker.format.as_mut().unwrap();
assert_eq!(format.fill, Some(Fill::Solid(ChartColor::scheme("bg1"))));
let line = format.line.as_mut().unwrap();
assert_eq!(line.fill, Some(Fill::Solid(ChartColor::rgb(0x74_4BF3))));
line.fill = Some(Fill::Solid(ChartColor::rgb(0x00_FF00)));
format.fill = Some(Fill::None);
let back = cycle(&book);
let text = text_of(&back, path);
assert!(
text.contains(r#"<c:marker><c:symbol val="circle"/><c:size val="6"/><c:spPr><a:noFill"#),
"{text}"
);
assert!(text.contains(
r#"<a:srgbClr val="00FF00"/></a:solidFill></a:ln><a:effectLst/></c:spPr></c:marker>"#
));
let marker = chart_at(&back, path)
.plots
.iter()
.flat_map(|p| &p.series)
.filter_map(|s| s.marker.as_ref())
.find(|m| {
m.format
.as_ref()
.is_some_and(|f| f.fill == Some(Fill::None))
})
.unwrap();
assert_eq!(marker.symbol, Some(MarkerSymbol::Circle));
}
const POINT_LABELS: &str = concat!(
r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>"#,
r#"<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" "#,
r#"xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" "#,
r#"xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">"#,
r#"<c:chart><c:autoTitleDeleted val="1"/><c:plotArea><c:layout/><c:barChart>"#,
r#"<c:barDir val="col"/><c:grouping val="clustered"/><c:ser><c:idx val="0"/><c:order val="0"/>"#,
r#"<c:dLbls><c:dLbl><c:idx val="1"/><c:tx><c:strRef><c:f>Лист1!$A$1</c:f><c:strCache>"#,
r#"<c:ptCount val="1"/><c:pt idx="0"><c:v>Peak</c:v></c:pt></c:strCache></c:strRef></c:tx>"#,
r#"<c:dLblPos val="outEnd"/><c:showLegendKey val="0"/><c:showVal val="1"/>"#,
r#"<c:showCatName val="0"/><c:showSerName val="0"/><c:showPercent val="0"/>"#,
r#"<c:showBubbleSize val="0"/><c:extLst><c:ext uri="{Y}"/></c:extLst></c:dLbl>"#,
r#"<c:dLbl><c:idx val="2"/><c:delete val="1"/></c:dLbl>"#,
r#"<c:showLegendKey val="0"/><c:showVal val="0"/><c:showCatName val="0"/>"#,
r#"<c:showSerName val="0"/><c:showPercent val="0"/><c:showBubbleSize val="0"/></c:dLbls>"#,
r#"<c:val><c:numRef><c:f>Sheet1!$B$2:$B$4</c:f></c:numRef></c:val></c:ser>"#,
r#"<c:gapWidth val="219"/><c:axId val="1"/><c:axId val="2"/></c:barChart>"#,
r#"<c:catAx><c:axId val="1"/><c:scaling><c:orientation val="minMax"/></c:scaling><c:delete val="0"/>"#,
r#"<c:axPos val="b"/><c:crossAx val="2"/></c:catAx><c:valAx><c:axId val="2"/><c:scaling>"#,
r#"<c:orientation val="minMax"/></c:scaling><c:delete val="0"/><c:axPos val="l"/>"#,
r#"<c:crossAx val="1"/></c:valAx></c:plotArea><c:plotVisOnly val="1"/></c:chart></c:chartSpace>"#,
);
#[test]
fn labels_of_single_points_are_read_and_rewritten() {
let (mut book, path) = with_chart_part(POINT_LABELS);
let labels = book.sheet(0).unwrap().charts[0].plots[0].series[0]
.labels
.clone()
.unwrap();
assert!(!labels.show_value);
let [peak, hidden] = labels.points.as_slice() else {
panic!("two point labels, got {:?}", labels.points);
};
assert_eq!(
(peak.index, peak.show_value, peak.position, peak.deleted),
(1, true, Some(LabelPosition::OutsideEnd), false)
);
assert_eq!((hidden.index, hidden.deleted), (2, true));
let labels = book.sheet_mut(0).unwrap().charts[0].plots[0].series[0]
.labels
.as_mut()
.unwrap();
labels.points[0].show_category_name = true;
labels.points[1].deleted = false;
labels.points[1].show_value = true;
labels.points.push(DataLabel {
index: 0,
show_series_name: true,
..DataLabel::default()
});
insert_rows(&mut book, 0, Row::from_one_based(1).unwrap(), 2).unwrap();
let back = cycle(&book);
let text = text_of(&back, &path);
let points = &back.sheet(0).unwrap().charts[0].plots[0].series[0]
.labels
.as_ref()
.unwrap()
.points;
let said: Vec<_> = points
.iter()
.map(|l| {
(
l.index,
l.deleted,
l.show_value,
l.show_category_name,
l.show_series_name,
)
})
.collect();
assert_eq!(
said,
[
(1, false, true, true, false),
(2, false, true, false, false),
(0, false, false, false, true)
]
);
assert!(text.contains("<c:f>Лист1!$A$3</c:f><c:strCache>"), "{text}");
assert!(text.contains(r#"<c:showCatName val="1"/><c:showSerName val="0"/><c:showPercent val="0"/><c:showBubbleSize val="0"/><c:extLst><c:ext uri="{Y}"/></c:extLst></c:dLbl>"#), "{text}");
assert!(
text.contains(r#"<c:dLbl><c:idx val="2"/><c:showLegendKey val="0"/><c:showVal val="1"/>"#),
"{text}"
);
}
#[test]
fn a_line_plot_switches_its_markers() {
let path = "xl/charts/chart102.xml";
let mut book = open("chart1.xlsx");
let chart = chart_at_mut(&mut book, path);
let plot = chart
.plots
.iter_mut()
.find(|p| matches!(p.kind, PlotKind::Line { .. }))
.unwrap();
assert_eq!(plot.show_markers, Some(true));
assert!(!plot.markup.contains("marker"), "{}", plot.markup);
plot.show_markers = Some(false);
let back = cycle(&book);
let text = text_of(&back, path);
assert!(
text.contains(r#"</c:dLbls><c:marker val="0"/><c:smooth val="0"/><c:axId"#),
"{text}"
);
let plot = chart_at(&back, path)
.plots
.iter()
.find(|p| matches!(p.kind, PlotKind::Line { .. }))
.unwrap();
assert_eq!(plot.show_markers, Some(false));
}
const POINT_MARKER: &str = concat!(
r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>"#,
r#"<c:chartSpace xmlns:c="http://schemas.openxmlformats.org/drawingml/2006/chart" "#,
r#"xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" "#,
r#"xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">"#,
r#"<c:chart><c:autoTitleDeleted val="1"/><c:plotArea><c:layout/><c:lineChart>"#,
r#"<c:grouping val="standard"/><c:ser><c:idx val="0"/><c:order val="0"/>"#,
r#"<c:marker><c:symbol val="none"/></c:marker>"#,
r#"<c:dPt><c:idx val="1"/><c:marker><c:symbol val="diamond"/><c:size val="9"/>"#,
r#"<c:spPr><a:solidFill><a:srgbClr val="FF0000"/></a:solidFill></c:spPr></c:marker>"#,
r#"<c:bubble3D val="0"/><c:spPr><a:ln w="28575"/></c:spPr>"#,
r#"<c:extLst><c:ext uri="{Z}"/></c:extLst></c:dPt>"#,
r#"<c:val><c:numRef><c:f>Sheet1!$B$2:$B$4</c:f></c:numRef></c:val><c:smooth val="0"/></c:ser>"#,
r#"<c:marker val="1"/><c:axId val="1"/><c:axId val="2"/></c:lineChart>"#,
r#"<c:catAx><c:axId val="1"/><c:scaling><c:orientation val="minMax"/></c:scaling><c:delete val="0"/>"#,
r#"<c:axPos val="b"/><c:crossAx val="2"/></c:catAx><c:valAx><c:axId val="2"/><c:scaling>"#,
r#"<c:orientation val="minMax"/></c:scaling><c:delete val="0"/><c:axPos val="l"/>"#,
r#"<c:crossAx val="1"/></c:valAx></c:plotArea><c:plotVisOnly val="1"/></c:chart></c:chartSpace>"#,
);
#[test]
fn a_point_keeps_a_marker_of_its_own() {
let (mut book, path) = with_chart_part(POINT_MARKER);
let points = &mut book.sheet_mut(0).unwrap().charts[0].plots[0].series[0].data_points;
let marker = points[0].marker.as_mut().unwrap();
assert_eq!(
(marker.symbol, marker.size),
(Some(MarkerSymbol::Diamond), Some(9))
);
assert_eq!(
marker.format.as_ref().unwrap().fill,
Some(Fill::Solid(ChartColor::rgb(0xFF_0000)))
);
marker.size = Some(12);
points.push(DataPoint {
index: 2,
marker: Some(SeriesMarker {
symbol: Some(MarkerSymbol::Square),
..SeriesMarker::default()
}),
..DataPoint::default()
});
let edited = points.clone();
let back = cycle(&book);
let text = text_of(&back, &path);
assert!(
text.contains(concat!(
r#"<c:dPt><c:idx val="1"/><c:marker><c:symbol val="diamond"/><c:size val="12"/>"#,
r#"<c:spPr><a:solidFill><a:srgbClr val="FF0000"/></a:solidFill></c:spPr></c:marker>"#,
r#"<c:bubble3D val="0"/><c:spPr><a:ln w="28575"/></c:spPr>"#,
r#"<c:extLst><c:ext uri="{Z}"/></c:extLst></c:dPt>"#,
r#"<c:dPt><c:idx val="2"/><c:marker><c:symbol val="square"/></c:marker></c:dPt>"#
)),
"{text}"
);
let points = &back.sheet(0).unwrap().charts[0].plots[0].series[0].data_points;
let said = |p: &[DataPoint]| {
p.iter()
.map(|p| (p.index, p.marker.as_ref().map(|m| (m.symbol, m.size))))
.collect::<Vec<_>>()
};
assert_eq!(said(points), said(&edited));
}
#[test]
fn gradients_and_patterns_are_read_and_rewritten() {
let path = "xl/charts/chart110.xml";
let mut book = open("chart1.xlsx");
let format = chart_at_mut(&mut book, path).plots[0].series[0]
.format
.as_mut()
.unwrap();
let Some(Fill::Gradient {
stops,
angle,
path: shape,
}) = &mut format.fill
else {
panic!("a gradient, got {:?}", format.fill);
};
assert_eq!((*angle, *shape), (None, Some(GradientPath::Circle)));
assert_eq!(stops[0].position, 37_000);
assert_eq!(
stops[1].color,
ChartColor {
base: ColorBase::Rgb(0x00_66FF),
transforms: vec![ColorTransform::Alpha(40_000)],
}
);
stops[0].color = ChartColor::rgb(0xFF_0000);
*shape = None;
*angle = Some(2_700_000);
let edited = format.fill.clone();
let back = cycle(&book);
let text = text_of(&back, path);
assert!(
text.contains(concat!(
r#"<a:gradFill flip="none" rotWithShape="1"><a:gsLst xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main">"#,
r#"<a:gs pos="37000"><a:srgbClr val="FF0000"/></a:gs><a:gs pos="80000"><a:srgbClr val="0066FF">"#,
r#"<a:alpha val="40000"/></a:srgbClr></a:gs></a:gsLst><a:lin xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" "#,
r#"ang="2700000" scaled="0"/><a:tileRect l="-100000" t="-100000"/></a:gradFill>"#
)),
"{text}"
);
let series = &chart_at(&back, path).plots[0].series[0];
assert_eq!(series.format.as_ref().unwrap().fill, edited);
let pattern = Fill::Pattern {
preset: Some("dkDnDiag".into()),
foreground: Some(ChartColor::scheme("accent1")),
background: Some(ChartColor::rgb(0xFF_FFFF)),
};
let radial = Fill::Gradient {
stops: vec![
GradientStop {
position: 0,
color: ChartColor::rgb(0x00_0000),
},
GradientStop {
position: 100_000,
color: ChartColor::rgb(0xFF_FFFF),
},
],
angle: None,
path: Some(GradientPath::Rect),
};
let series = &mut chart_at_mut(&mut book, path).plots[0].series[0];
series.format = Some(ShapeFormat {
fill: Some(pattern.clone()),
line: Some(LineFormat {
fill: Some(radial.clone()),
width: None,
}),
source: None,
});
let back = cycle(&book);
let text = text_of(&back, path);
assert!(
text.contains(concat!(
r#"<a:pattFill xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" prst="dkDnDiag">"#,
r#"<a:fgClr><a:schemeClr val="accent1"/></a:fgClr><a:bgClr><a:srgbClr val="FFFFFF"/></a:bgClr></a:pattFill>"#
)),
"{text}"
);
assert!(text.contains(
r#"<a:path path="rect"><a:fillToRect l="50000" t="50000" r="50000" b="50000"/></a:path>"#
));
let format = chart_at(&back, path).plots[0].series[0]
.format
.clone()
.unwrap();
assert_eq!(format.fill, Some(pattern));
assert_eq!(format.line.unwrap().fill, Some(radial));
}
#[test]
fn chart_caches_are_read_again_from_the_cells() {
use excelerate::CellRef;
use excelerate::formula::chart::refresh_caches;
for name in ["chart1.xlsx", "chart2.xlsx"] {
let mut book = open(name);
assert_eq!(refresh_caches(&mut book, None), 0, "{name}");
let charts = book.sheets().iter().flat_map(|s| &s.charts);
assert!(charts.clone().all(Chart::is_unchanged), "{name}");
}
let mut book = open("chart2.xlsx");
let b6 = CellRef::parse("B6").unwrap();
book.sheet_mut(0).unwrap().set(b6, 999.0);
let elsewhere = CellRef::parse("Z100").unwrap();
assert_eq!(refresh_caches(&mut book, Some(&[(0, elsewhere)])), 0);
assert_eq!(refresh_caches(&mut book, Some(&[(0, b6)])), 1);
let chart = &book.sheet(0).unwrap().charts[0];
let Some(DataSource::Numbers { points, .. }) = &chart.plots[0].series[0].values else {
panic!("numbers");
};
assert_eq!(points[0], (0, 999.0));
assert!(!chart.is_unchanged());
let back = cycle(&book);
assert_eq!(back.sheet(0).unwrap().charts[0].plots, chart.plots);
let mut book = open("fixtures/chart.xlsx");
assert_eq!(refresh_caches(&mut book, None), 1);
let series = &book.sheet(0).unwrap().charts[0].plots[0].series[0];
assert_eq!(
series.name.as_ref().and_then(ChartText::shown),
Some("Sales")
);
let Some(DataSource::Strings { points, .. }) = &series.categories else {
panic!("labels");
};
assert_eq!(points[3], (3, "Q4".to_owned()));
}
#[test]
fn the_chart_and_plot_area_formatting_is_read_and_rewritten() {
let mut book = open("chart1.xlsx");
let path = "xl/charts/chart2.xml";
let chart = chart_at(&book, path);
let area = chart.format.as_ref().unwrap();
assert_eq!(area.fill, Some(Fill::None));
assert_eq!(area.line.as_ref().unwrap().width, Some(9525));
assert_eq!(chart.plot_format.as_ref().unwrap().fill, Some(Fill::None));
assert!(!chart.markup.after_chart.contains("spPr"));
let chart = chart_at_mut(&mut book, path);
chart.format.as_mut().unwrap().fill = Some(Fill::Solid(ChartColor::rgb(0xFF_EEDD)));
chart.plot_format = Some(ShapeFormat::solid(ChartColor::rgb(0x11_2233)));
let back = cycle(&book);
let chart = chart_at(&back, path);
let area = chart.format.as_ref().unwrap();
assert_eq!(area.fill, Some(Fill::Solid(ChartColor::rgb(0xFF_EEDD))));
assert_eq!(area.line.as_ref().unwrap().width, Some(9525));
assert_eq!(
chart.plot_format.as_ref().unwrap().fill,
Some(Fill::Solid(ChartColor::rgb(0x11_2233)))
);
let text = text_of(&back, path);
let after = &text[text.find("</c:chart>").unwrap()..];
assert_eq!(after.matches("<c:spPr>").count(), 1);
let plot = &text[text.find("<c:plotArea>").unwrap()..text.find("</c:plotArea>").unwrap()];
assert!(plot.contains("112233"));
}
#[test]
fn a_title_and_a_legend_put_by_hand_keep_their_place() {
use excelerate::model::chart::ManualLayout;
let mut book = open("chart1.xlsx");
let path = "xl/charts/chart2.xml";
let chart = chart_at_mut(&mut book, path);
let at = ManualLayout {
x: 12_500,
y: 80_000,
w: None,
h: None,
};
chart.legend.get_or_insert_default().layout = Some(at);
chart.title.get_or_insert_default().layout = Some(ManualLayout { x: 5_000, ..at });
let back = cycle(&book);
let chart = chart_at(&back, path);
assert_eq!(chart.legend.as_ref().unwrap().layout, Some(at));
assert_eq!(
chart.title.as_ref().unwrap().layout,
Some(ManualLayout { x: 5_000, ..at })
);
let text = text_of(&back, path);
let legend = &text[text.find("<c:legend>").unwrap()..text.find("</c:legend>").unwrap()];
assert!(legend.contains(r#"<c:x val="0.125"/>"#), "{legend}");
let overlay = legend.find("<c:overlay").unwrap_or(legend.len());
assert!(legend.find("<c:layout>").unwrap() < overlay, "{legend}");
}
#[test]
fn a_waterfall_reads_its_points_totals_and_labels() {
let book = open("chart1.xlsx");
let chart = &book.sheet(0).unwrap().extended_charts[0];
let series = &chart.series[0];
assert_eq!(series.subtotals, [7]);
assert_eq!(
series.points.iter().map(|p| p.index).collect::<Vec<_>>(),
(0..8).collect::<Vec<_>>()
);
assert!(series.points.iter().all(|p| p.format.fill.is_some()));
assert_eq!(
series.labels,
Some(ExLabels {
position: Some(LabelPosition::OutsideEnd),
value: true,
..ExLabels::default()
})
);
assert_eq!(series.binning, None);
assert_eq!(chart.legend, None);
}
#[test]
fn a_waterfall_keeps_changed_points_totals_labels_and_legend() {
let mut book = open("chart1.xlsx");
let chart = &mut book.sheet_mut(0).unwrap().extended_charts[0];
let path = chart.part.clone();
chart.legend = Some(ExLegend {
position: LegendPosition::Bottom,
overlay: false,
});
let series = &mut chart.series[0];
series.subtotals = vec![0, 7];
series.points[0].format = ShapeFormat::solid(ChartColor::rgb(0xFF_0000));
series.points.pop();
let labels = series.labels.as_mut().unwrap();
labels.category_name = true;
labels.position = Some(LabelPosition::InsideEnd);
let wanted = chart.clone();
let back = cycle(&book);
let after = &back.sheet(0).unwrap().extended_charts[0];
assert_eq!(after.legend, wanted.legend);
let (now, was) = (&after.series[0], &wanted.series[0]);
assert_eq!(now.subtotals, was.subtotals);
assert_eq!(now.labels, was.labels);
let fills = |s: &ExSeries| -> Vec<_> {
s.points
.iter()
.map(|p| (p.index, p.format.fill.clone()))
.collect()
};
assert_eq!(fills(now), fills(was));
let text = std::str::from_utf8(part(&back, &path)).unwrap();
assert!(
text.contains("<cx:separator>, </cx:separator>"),
"what the labels do not model stays"
);
assert_eq!(
cycle(&back).sheet(0).unwrap().extended_charts[0],
after.clone()
);
}
#[test]
fn a_histogram_keeps_its_bins() {
use excelerate::model::chart::{BinEdge, Binning, Bins};
let mut book = Spreadsheet::new();
let values = Dimension {
role: DimensionRole::Values,
numeric: true,
formula: Some("Sheet1!$A$1:$A$9".into()),
levels: Vec::new(),
};
let mut chart = ChartEx::new(
SeriesLayout::ClusteredColumn,
vec![values],
Anchor::default(),
);
chart.series[0].binning = Some(Binning {
closed_left: true,
underflow: Some(BinEdge::Value(1.5)),
overflow: Some(BinEdge::Auto),
bins: Some(Bins::Count(5)),
});
chart.legend = Some(ExLegend::default());
book.sheet_mut(0).unwrap().extended_charts.push(chart);
let back = cycle(&book);
let read = &back.sheet(0).unwrap().extended_charts[0];
assert_eq!(
read.series[0].binning,
book.sheet(0).unwrap().extended_charts[0].series[0].binning
);
assert_eq!(read.legend, Some(ExLegend::default()));
let mut edited = back.clone();
let bins = &mut edited.sheet_mut(0).unwrap().extended_charts[0].series[0].binning;
*bins = Some(Binning {
bins: Some(Bins::Width(2.5)),
..Binning::default()
});
let wanted = *bins;
let again = cycle(&edited);
assert_eq!(
again.sheet(0).unwrap().extended_charts[0].series[0].binning,
wanted
);
}
#[test]
fn a_dimension_reads_its_labels_from_the_cells() {
use excelerate::model::{CellValue, DefinedName};
let mut book = Spreadsheet::new();
let sheet = book.sheet_mut(0).unwrap();
for (row, value) in [
(0, CellValue::from("North")),
(2, CellValue::Number(2024.0)),
] {
sheet.set(
excelerate::CellRef::new(Col::new(0).unwrap(), Row::new(row).unwrap()),
value,
);
}
book.defined_names.push(DefinedName {
name: "_xlchart.v1.0".into(),
sheet: None,
formula: "Worksheet!$A$1:$A$3".into(),
hidden: true,
});
let dimension = Dimension {
role: DimensionRole::Categories,
numeric: false,
formula: Some("_xlchart.v1.0".into()),
levels: Vec::new(),
};
assert_eq!(
dimension.strings(&book, 0),
Some(vec![(0, "North".to_owned()), (2, "2024".to_owned())])
);
}