Skip to main content

sheetkit_core/
chart.rs

1//! Chart builder and management.
2//!
3//! Provides types for configuring charts and functions for building the
4//! corresponding XML structures (ChartSpace and drawing anchors).
5
6use sheetkit_xml::chart::{
7    Area3DChart, AreaChart, Bar3DChart, BarChart, BodyPr, BoolVal, BubbleChart, BubbleSeries,
8    CatAx, CategoryRef, Chart, ChartSpace, ChartTitle, DoughnutChart, HighLowLines, IntVal, Layout,
9    Legend, Line3DChart, LineChart, NumRef, OfPieChart, Paragraph, Pie3DChart, PieChart, PlotArea,
10    RadarChart, RichText, Run, Scaling, ScatterChart, ScatterSeries, SerAx, SerLines, Series,
11    SeriesText, StockChart, StrRef, StringVal, Surface3DChart, SurfaceChart, TitleTx, UintVal,
12    UpDownBars, ValAx, ValueRef, View3D,
13};
14use sheetkit_xml::drawing::{
15    AExt, CNvGraphicFramePr, CNvPr, ChartRef, ClientData, Graphic, GraphicData, GraphicFrame,
16    MarkerType, NvGraphicFramePr, Offset, TwoCellAnchor, WsDr, Xfrm,
17};
18use sheetkit_xml::namespaces;
19
20/// The chart type to render.
21#[derive(Debug, Clone, PartialEq)]
22pub enum ChartType {
23    /// Vertical bar chart (column).
24    Col,
25    /// Vertical bar chart, stacked.
26    ColStacked,
27    /// Vertical bar chart, percent stacked.
28    ColPercentStacked,
29    /// Horizontal bar chart.
30    Bar,
31    /// Horizontal bar chart, stacked.
32    BarStacked,
33    /// Horizontal bar chart, percent stacked.
34    BarPercentStacked,
35    /// Line chart.
36    Line,
37    /// Pie chart.
38    Pie,
39    /// Area chart.
40    Area,
41    /// Area chart, stacked.
42    AreaStacked,
43    /// Area chart, percent stacked.
44    AreaPercentStacked,
45    /// 3D area chart.
46    Area3D,
47    /// 3D area chart, stacked.
48    Area3DStacked,
49    /// 3D area chart, percent stacked.
50    Area3DPercentStacked,
51    /// 3D column chart.
52    Col3D,
53    /// 3D column chart, stacked.
54    Col3DStacked,
55    /// 3D column chart, percent stacked.
56    Col3DPercentStacked,
57    /// 3D horizontal bar chart.
58    Bar3D,
59    /// 3D horizontal bar chart, stacked.
60    Bar3DStacked,
61    /// 3D horizontal bar chart, percent stacked.
62    Bar3DPercentStacked,
63    /// Line chart, stacked.
64    LineStacked,
65    /// Line chart, percent stacked.
66    LinePercentStacked,
67    /// 3D line chart.
68    Line3D,
69    /// 3D pie chart.
70    Pie3D,
71    /// Doughnut chart.
72    Doughnut,
73    /// Scatter chart (markers only).
74    Scatter,
75    /// Scatter chart with straight lines.
76    ScatterLine,
77    /// Scatter chart with smooth lines.
78    ScatterSmooth,
79    /// Radar chart (standard).
80    Radar,
81    /// Radar chart with filled area.
82    RadarFilled,
83    /// Radar chart with markers.
84    RadarMarker,
85    /// Stock chart: High-Low-Close.
86    StockHLC,
87    /// Stock chart: Open-High-Low-Close.
88    StockOHLC,
89    /// Stock chart: Volume-High-Low-Close.
90    StockVHLC,
91    /// Stock chart: Volume-Open-High-Low-Close.
92    StockVOHLC,
93    /// Bubble chart.
94    Bubble,
95    /// Surface chart.
96    Surface,
97    /// 3D surface chart.
98    Surface3D,
99    /// Wireframe surface chart.
100    SurfaceWireframe,
101    /// Wireframe 3D surface chart.
102    SurfaceWireframe3D,
103    /// Combo chart: column + line.
104    ColLine,
105    /// Combo chart: column stacked + line.
106    ColLineStacked,
107    /// Combo chart: column percent stacked + line.
108    ColLinePercentStacked,
109    /// Pie-of-pie chart.
110    PieOfPie,
111    /// Bar-of-pie chart.
112    BarOfPie,
113    /// 3D cone column chart.
114    Col3DCone,
115    /// 3D cone column chart, stacked.
116    Col3DConeStacked,
117    /// 3D cone column chart, percent stacked.
118    Col3DConePercentStacked,
119    /// 3D pyramid column chart.
120    Col3DPyramid,
121    /// 3D pyramid column chart, stacked.
122    Col3DPyramidStacked,
123    /// 3D pyramid column chart, percent stacked.
124    Col3DPyramidPercentStacked,
125    /// 3D cylinder column chart.
126    Col3DCylinder,
127    /// 3D cylinder column chart, stacked.
128    Col3DCylinderStacked,
129    /// 3D cylinder column chart, percent stacked.
130    Col3DCylinderPercentStacked,
131    /// Contour chart (surface chart as 2D projection).
132    Contour,
133    /// Wireframe contour chart.
134    WireframeContour,
135    /// 3D bubble chart.
136    Bubble3D,
137}
138
139/// 3D view configuration for charts.
140#[derive(Debug, Clone, Default)]
141pub struct View3DConfig {
142    /// X-axis rotation angle in degrees.
143    pub rot_x: Option<i32>,
144    /// Y-axis rotation angle in degrees.
145    pub rot_y: Option<i32>,
146    /// Depth as a percentage (100 = normal depth).
147    pub depth_percent: Option<u32>,
148    /// Whether to use right angle axes.
149    pub right_angle_axes: Option<bool>,
150    /// Perspective angle in degrees.
151    pub perspective: Option<u32>,
152}
153
154/// Configuration for a chart.
155#[derive(Debug, Clone)]
156pub struct ChartConfig {
157    /// The type of chart.
158    pub chart_type: ChartType,
159    /// Optional chart title.
160    pub title: Option<String>,
161    /// Data series for the chart.
162    pub series: Vec<ChartSeries>,
163    /// Whether to show the legend.
164    pub show_legend: bool,
165    /// Optional 3D view settings (auto-populated for 3D chart types if not set).
166    pub view_3d: Option<View3DConfig>,
167}
168
169/// A single data series within a chart.
170#[derive(Debug, Clone)]
171pub struct ChartSeries {
172    /// Series name (a literal string or cell reference like `"Sheet1!$A$1"`).
173    pub name: String,
174    /// Category axis data range (e.g., `"Sheet1!$A$2:$A$6"`).
175    pub categories: String,
176    /// Value axis data range (e.g., `"Sheet1!$B$2:$B$6"`).
177    pub values: String,
178    /// X-axis values for scatter/bubble charts (e.g., `"Sheet1!$A$2:$A$6"`).
179    pub x_values: Option<String>,
180    /// Bubble sizes for bubble charts (e.g., `"Sheet1!$C$2:$C$6"`).
181    pub bubble_sizes: Option<String>,
182}
183
184/// Build a `ChartSpace` XML structure from a chart configuration.
185pub fn build_chart_xml(config: &ChartConfig) -> ChartSpace {
186    let title = config.title.as_ref().map(|t| build_chart_title(t));
187    let legend = if config.show_legend {
188        Some(Legend {
189            legend_pos: StringVal {
190                val: "b".to_string(),
191            },
192        })
193    } else {
194        None
195    };
196    let view_3d = build_view_3d(config);
197    let plot_area = build_plot_area(config);
198
199    ChartSpace {
200        chart: Chart {
201            title,
202            view_3d,
203            plot_area,
204            legend,
205            plot_vis_only: Some(BoolVal { val: true }),
206        },
207        ..ChartSpace::default()
208    }
209}
210
211/// Build a drawing XML structure containing a chart reference.
212pub fn build_drawing_with_chart(chart_ref_id: &str, from: MarkerType, to: MarkerType) -> WsDr {
213    build_drawing_with_chart_id(chart_ref_id, from, to, 2)
214}
215
216/// Build a drawing XML structure containing a chart reference with a unique
217/// non-visual drawing ID.
218pub fn build_drawing_with_chart_id(
219    chart_ref_id: &str,
220    from: MarkerType,
221    to: MarkerType,
222    object_id: u32,
223) -> WsDr {
224    let graphic_frame = GraphicFrame {
225        nv_graphic_frame_pr: NvGraphicFramePr {
226            c_nv_pr: CNvPr {
227                id: object_id,
228                name: format!("Chart {}", object_id.saturating_sub(1)),
229            },
230            c_nv_graphic_frame_pr: CNvGraphicFramePr {},
231        },
232        xfrm: Xfrm {
233            off: Offset { x: 0, y: 0 },
234            ext: AExt { cx: 0, cy: 0 },
235        },
236        graphic: Graphic {
237            graphic_data: GraphicData {
238                uri: namespaces::DRAWING_ML_CHART.to_string(),
239                chart: ChartRef {
240                    xmlns_c: namespaces::DRAWING_ML_CHART.to_string(),
241                    r_id: chart_ref_id.to_string(),
242                },
243            },
244        },
245    };
246    let anchor = TwoCellAnchor {
247        from,
248        to,
249        graphic_frame: Some(graphic_frame),
250        pic: None,
251        shape: None,
252        client_data: ClientData {},
253    };
254    WsDr {
255        two_cell_anchors: vec![anchor],
256        ..WsDr::default()
257    }
258}
259
260fn is_no_axis_chart(ct: &ChartType) -> bool {
261    matches!(
262        ct,
263        ChartType::Pie
264            | ChartType::Pie3D
265            | ChartType::Doughnut
266            | ChartType::PieOfPie
267            | ChartType::BarOfPie
268    )
269}
270
271fn is_3d_chart(ct: &ChartType) -> bool {
272    matches!(
273        ct,
274        ChartType::Area3D
275            | ChartType::Area3DStacked
276            | ChartType::Area3DPercentStacked
277            | ChartType::Col3D
278            | ChartType::Col3DStacked
279            | ChartType::Col3DPercentStacked
280            | ChartType::Bar3D
281            | ChartType::Bar3DStacked
282            | ChartType::Bar3DPercentStacked
283            | ChartType::Line3D
284            | ChartType::Pie3D
285            | ChartType::Surface3D
286            | ChartType::SurfaceWireframe3D
287            | ChartType::Col3DCone
288            | ChartType::Col3DConeStacked
289            | ChartType::Col3DConePercentStacked
290            | ChartType::Col3DPyramid
291            | ChartType::Col3DPyramidStacked
292            | ChartType::Col3DPyramidPercentStacked
293            | ChartType::Col3DCylinder
294            | ChartType::Col3DCylinderStacked
295            | ChartType::Col3DCylinderPercentStacked
296    )
297}
298
299fn needs_ser_ax(ct: &ChartType) -> bool {
300    matches!(
301        ct,
302        ChartType::Surface
303            | ChartType::Surface3D
304            | ChartType::SurfaceWireframe
305            | ChartType::SurfaceWireframe3D
306            | ChartType::Contour
307            | ChartType::WireframeContour
308    )
309}
310
311fn build_view_3d(config: &ChartConfig) -> Option<View3D> {
312    if let Some(v) = &config.view_3d {
313        return Some(View3D {
314            rot_x: v.rot_x.map(|val| IntVal { val }),
315            rot_y: v.rot_y.map(|val| IntVal { val }),
316            depth_percent: v.depth_percent.map(|val| UintVal { val }),
317            r_ang_ax: v.right_angle_axes.map(|val| BoolVal { val }),
318            perspective: v.perspective.map(|val| UintVal { val }),
319        });
320    }
321    if is_3d_chart(&config.chart_type) {
322        Some(View3D {
323            rot_x: Some(IntVal { val: 15 }),
324            rot_y: Some(IntVal { val: 20 }),
325            depth_percent: None,
326            r_ang_ax: Some(BoolVal { val: true }),
327            perspective: Some(UintVal { val: 30 }),
328        })
329    } else {
330        None
331    }
332}
333
334fn build_series_text(series: &ChartSeries) -> Option<SeriesText> {
335    if series.name.is_empty() {
336        None
337    } else if series.name.contains('!') {
338        Some(SeriesText {
339            str_ref: Some(StrRef {
340                f: series.name.clone(),
341            }),
342            v: None,
343        })
344    } else {
345        Some(SeriesText {
346            str_ref: None,
347            v: Some(series.name.clone()),
348        })
349    }
350}
351
352fn build_series(index: u32, series: &ChartSeries) -> Series {
353    let tx = build_series_text(series);
354    let cat = if series.categories.is_empty() {
355        None
356    } else {
357        Some(CategoryRef {
358            str_ref: Some(StrRef {
359                f: series.categories.clone(),
360            }),
361            num_ref: None,
362        })
363    };
364    let val = if series.values.is_empty() {
365        None
366    } else {
367        Some(ValueRef {
368            num_ref: Some(NumRef {
369                f: series.values.clone(),
370            }),
371        })
372    };
373    Series {
374        idx: UintVal { val: index },
375        order: UintVal { val: index },
376        tx,
377        cat,
378        val,
379    }
380}
381
382fn build_scatter_series(index: u32, series: &ChartSeries) -> ScatterSeries {
383    let tx = build_series_text(series);
384    let x_val = series
385        .x_values
386        .as_ref()
387        .or(if series.categories.is_empty() {
388            None
389        } else {
390            Some(&series.categories)
391        })
392        .map(|ref_str| CategoryRef {
393            str_ref: None,
394            num_ref: Some(NumRef { f: ref_str.clone() }),
395        });
396    let y_val = if series.values.is_empty() {
397        None
398    } else {
399        Some(ValueRef {
400            num_ref: Some(NumRef {
401                f: series.values.clone(),
402            }),
403        })
404    };
405    ScatterSeries {
406        idx: UintVal { val: index },
407        order: UintVal { val: index },
408        tx,
409        x_val,
410        y_val,
411    }
412}
413
414fn build_bubble_series(index: u32, series: &ChartSeries, is_3d: bool) -> BubbleSeries {
415    let tx = build_series_text(series);
416    let x_val = series
417        .x_values
418        .as_ref()
419        .or(if series.categories.is_empty() {
420            None
421        } else {
422            Some(&series.categories)
423        })
424        .map(|ref_str| CategoryRef {
425            str_ref: None,
426            num_ref: Some(NumRef { f: ref_str.clone() }),
427        });
428    let y_val = if series.values.is_empty() {
429        None
430    } else {
431        Some(ValueRef {
432            num_ref: Some(NumRef {
433                f: series.values.clone(),
434            }),
435        })
436    };
437    let bubble_size = series.bubble_sizes.as_ref().map(|ref_str| ValueRef {
438        num_ref: Some(NumRef { f: ref_str.clone() }),
439    });
440    BubbleSeries {
441        idx: UintVal { val: index },
442        order: UintVal { val: index },
443        tx,
444        x_val,
445        y_val,
446        bubble_size,
447        bubble_3d: if is_3d {
448            Some(BoolVal { val: true })
449        } else {
450            None
451        },
452    }
453}
454
455fn build_chart_title(text: &str) -> ChartTitle {
456    ChartTitle {
457        tx: TitleTx {
458            rich: RichText {
459                body_pr: BodyPr {},
460                paragraphs: vec![Paragraph {
461                    runs: vec![Run {
462                        t: text.to_string(),
463                    }],
464                }],
465            },
466        },
467    }
468}
469
470fn build_standard_axes() -> (Option<CatAx>, Option<ValAx>) {
471    (
472        Some(CatAx {
473            ax_id: UintVal { val: 1 },
474            scaling: Scaling {
475                orientation: StringVal {
476                    val: "minMax".to_string(),
477                },
478            },
479            delete: BoolVal { val: false },
480            ax_pos: StringVal {
481                val: "b".to_string(),
482            },
483            cross_ax: UintVal { val: 2 },
484        }),
485        Some(ValAx {
486            ax_id: UintVal { val: 2 },
487            scaling: Scaling {
488                orientation: StringVal {
489                    val: "minMax".to_string(),
490                },
491            },
492            delete: BoolVal { val: false },
493            ax_pos: StringVal {
494                val: "l".to_string(),
495            },
496            cross_ax: UintVal { val: 1 },
497        }),
498    )
499}
500
501fn build_ser_ax() -> SerAx {
502    SerAx {
503        ax_id: UintVal { val: 3 },
504        scaling: Scaling {
505            orientation: StringVal {
506                val: "minMax".to_string(),
507            },
508        },
509        delete: BoolVal { val: false },
510        ax_pos: StringVal {
511            val: "b".to_string(),
512        },
513        cross_ax: UintVal { val: 1 },
514    }
515}
516
517fn standard_ax_ids() -> Vec<UintVal> {
518    vec![UintVal { val: 1 }, UintVal { val: 2 }]
519}
520
521fn volume_ax_ids() -> Vec<UintVal> {
522    vec![UintVal { val: 1 }, UintVal { val: 3 }]
523}
524
525fn build_volume_val_ax() -> ValAx {
526    ValAx {
527        ax_id: UintVal { val: 3 },
528        scaling: Scaling {
529            orientation: StringVal {
530                val: "minMax".to_string(),
531            },
532        },
533        delete: BoolVal { val: false },
534        ax_pos: StringVal {
535            val: "r".to_string(),
536        },
537        cross_ax: UintVal { val: 1 },
538    }
539}
540
541fn surface_ax_ids() -> Vec<UintVal> {
542    vec![UintVal { val: 1 }, UintVal { val: 2 }, UintVal { val: 3 }]
543}
544
545fn build_plot_area(config: &ChartConfig) -> PlotArea {
546    let ct = &config.chart_type;
547    let no_axes = is_no_axis_chart(ct);
548    let (cat_ax, val_ax) = if no_axes {
549        (None, None)
550    } else {
551        build_standard_axes()
552    };
553    let ser_ax = if needs_ser_ax(ct) {
554        Some(build_ser_ax())
555    } else {
556        None
557    };
558    let ax_ids = if no_axes {
559        vec![]
560    } else if needs_ser_ax(ct) {
561        surface_ax_ids()
562    } else {
563        standard_ax_ids()
564    };
565
566    let xml_series: Vec<Series> = config
567        .series
568        .iter()
569        .enumerate()
570        .map(|(i, s)| build_series(i as u32, s))
571        .collect();
572
573    let mut plot_area = PlotArea {
574        layout: Some(Layout {}),
575        bar_chart: None,
576        bar_3d_chart: None,
577        line_chart: None,
578        line_3d_chart: None,
579        pie_chart: None,
580        pie_3d_chart: None,
581        doughnut_chart: None,
582        area_chart: None,
583        area_3d_chart: None,
584        scatter_chart: None,
585        bubble_chart: None,
586        radar_chart: None,
587        stock_chart: None,
588        surface_chart: None,
589        surface_3d_chart: None,
590        of_pie_chart: None,
591        cat_ax,
592        val_ax,
593        additional_val_axes: vec![],
594        ser_ax,
595    };
596
597    match ct {
598        ChartType::Col => {
599            plot_area.bar_chart = Some(BarChart {
600                bar_dir: StringVal { val: "col".into() },
601                grouping: StringVal {
602                    val: "clustered".into(),
603                },
604                series: xml_series,
605                ax_ids,
606            });
607        }
608        ChartType::ColStacked => {
609            plot_area.bar_chart = Some(BarChart {
610                bar_dir: StringVal { val: "col".into() },
611                grouping: StringVal {
612                    val: "stacked".into(),
613                },
614                series: xml_series,
615                ax_ids,
616            });
617        }
618        ChartType::ColPercentStacked => {
619            plot_area.bar_chart = Some(BarChart {
620                bar_dir: StringVal { val: "col".into() },
621                grouping: StringVal {
622                    val: "percentStacked".into(),
623                },
624                series: xml_series,
625                ax_ids,
626            });
627        }
628        ChartType::Bar => {
629            plot_area.bar_chart = Some(BarChart {
630                bar_dir: StringVal { val: "bar".into() },
631                grouping: StringVal {
632                    val: "clustered".into(),
633                },
634                series: xml_series,
635                ax_ids,
636            });
637        }
638        ChartType::BarStacked => {
639            plot_area.bar_chart = Some(BarChart {
640                bar_dir: StringVal { val: "bar".into() },
641                grouping: StringVal {
642                    val: "stacked".into(),
643                },
644                series: xml_series,
645                ax_ids,
646            });
647        }
648        ChartType::BarPercentStacked => {
649            plot_area.bar_chart = Some(BarChart {
650                bar_dir: StringVal { val: "bar".into() },
651                grouping: StringVal {
652                    val: "percentStacked".into(),
653                },
654                series: xml_series,
655                ax_ids,
656            });
657        }
658        ChartType::Line => {
659            plot_area.line_chart = Some(LineChart {
660                grouping: StringVal {
661                    val: "standard".into(),
662                },
663                series: xml_series,
664                ax_ids,
665            });
666        }
667        ChartType::LineStacked => {
668            plot_area.line_chart = Some(LineChart {
669                grouping: StringVal {
670                    val: "stacked".into(),
671                },
672                series: xml_series,
673                ax_ids,
674            });
675        }
676        ChartType::LinePercentStacked => {
677            plot_area.line_chart = Some(LineChart {
678                grouping: StringVal {
679                    val: "percentStacked".into(),
680                },
681                series: xml_series,
682                ax_ids,
683            });
684        }
685        ChartType::Line3D => {
686            plot_area.line_3d_chart = Some(Line3DChart {
687                grouping: StringVal {
688                    val: "standard".into(),
689                },
690                series: xml_series,
691                ax_ids,
692            });
693        }
694        ChartType::Pie => {
695            plot_area.pie_chart = Some(PieChart { series: xml_series });
696        }
697        ChartType::Pie3D => {
698            plot_area.pie_3d_chart = Some(Pie3DChart { series: xml_series });
699        }
700        ChartType::Doughnut => {
701            plot_area.doughnut_chart = Some(DoughnutChart {
702                series: xml_series,
703                hole_size: Some(UintVal { val: 50 }),
704            });
705        }
706        ChartType::Area => {
707            plot_area.area_chart = Some(AreaChart {
708                grouping: StringVal {
709                    val: "standard".into(),
710                },
711                series: xml_series,
712                ax_ids,
713            });
714        }
715        ChartType::AreaStacked => {
716            plot_area.area_chart = Some(AreaChart {
717                grouping: StringVal {
718                    val: "stacked".into(),
719                },
720                series: xml_series,
721                ax_ids,
722            });
723        }
724        ChartType::AreaPercentStacked => {
725            plot_area.area_chart = Some(AreaChart {
726                grouping: StringVal {
727                    val: "percentStacked".into(),
728                },
729                series: xml_series,
730                ax_ids,
731            });
732        }
733        ChartType::Area3D => {
734            plot_area.area_3d_chart = Some(Area3DChart {
735                grouping: StringVal {
736                    val: "standard".into(),
737                },
738                series: xml_series,
739                ax_ids,
740            });
741        }
742        ChartType::Area3DStacked => {
743            plot_area.area_3d_chart = Some(Area3DChart {
744                grouping: StringVal {
745                    val: "stacked".into(),
746                },
747                series: xml_series,
748                ax_ids,
749            });
750        }
751        ChartType::Area3DPercentStacked => {
752            plot_area.area_3d_chart = Some(Area3DChart {
753                grouping: StringVal {
754                    val: "percentStacked".into(),
755                },
756                series: xml_series,
757                ax_ids,
758            });
759        }
760        ChartType::Col3D => {
761            plot_area.bar_3d_chart = Some(Bar3DChart {
762                bar_dir: StringVal { val: "col".into() },
763                grouping: StringVal {
764                    val: "clustered".into(),
765                },
766                series: xml_series,
767                shape: None,
768                ax_ids,
769            });
770        }
771        ChartType::Col3DStacked => {
772            plot_area.bar_3d_chart = Some(Bar3DChart {
773                bar_dir: StringVal { val: "col".into() },
774                grouping: StringVal {
775                    val: "stacked".into(),
776                },
777                series: xml_series,
778                shape: None,
779                ax_ids,
780            });
781        }
782        ChartType::Col3DPercentStacked => {
783            plot_area.bar_3d_chart = Some(Bar3DChart {
784                bar_dir: StringVal { val: "col".into() },
785                grouping: StringVal {
786                    val: "percentStacked".into(),
787                },
788                series: xml_series,
789                shape: None,
790                ax_ids,
791            });
792        }
793        ChartType::Bar3D => {
794            plot_area.bar_3d_chart = Some(Bar3DChart {
795                bar_dir: StringVal { val: "bar".into() },
796                grouping: StringVal {
797                    val: "clustered".into(),
798                },
799                series: xml_series,
800                shape: None,
801                ax_ids,
802            });
803        }
804        ChartType::Bar3DStacked => {
805            plot_area.bar_3d_chart = Some(Bar3DChart {
806                bar_dir: StringVal { val: "bar".into() },
807                grouping: StringVal {
808                    val: "stacked".into(),
809                },
810                series: xml_series,
811                shape: None,
812                ax_ids,
813            });
814        }
815        ChartType::Bar3DPercentStacked => {
816            plot_area.bar_3d_chart = Some(Bar3DChart {
817                bar_dir: StringVal { val: "bar".into() },
818                grouping: StringVal {
819                    val: "percentStacked".into(),
820                },
821                series: xml_series,
822                shape: None,
823                ax_ids,
824            });
825        }
826        ChartType::Scatter => {
827            let ss: Vec<ScatterSeries> = config
828                .series
829                .iter()
830                .enumerate()
831                .map(|(i, s)| build_scatter_series(i as u32, s))
832                .collect();
833            plot_area.scatter_chart = Some(ScatterChart {
834                scatter_style: StringVal {
835                    val: "lineMarker".into(),
836                },
837                series: ss,
838                ax_ids,
839            });
840        }
841        ChartType::ScatterLine => {
842            let ss: Vec<ScatterSeries> = config
843                .series
844                .iter()
845                .enumerate()
846                .map(|(i, s)| build_scatter_series(i as u32, s))
847                .collect();
848            plot_area.scatter_chart = Some(ScatterChart {
849                scatter_style: StringVal { val: "line".into() },
850                series: ss,
851                ax_ids,
852            });
853        }
854        ChartType::ScatterSmooth => {
855            let ss: Vec<ScatterSeries> = config
856                .series
857                .iter()
858                .enumerate()
859                .map(|(i, s)| build_scatter_series(i as u32, s))
860                .collect();
861            plot_area.scatter_chart = Some(ScatterChart {
862                scatter_style: StringVal {
863                    val: "smoothMarker".into(),
864                },
865                series: ss,
866                ax_ids,
867            });
868        }
869        ChartType::Bubble => {
870            let bs: Vec<BubbleSeries> = config
871                .series
872                .iter()
873                .enumerate()
874                .map(|(i, s)| build_bubble_series(i as u32, s, false))
875                .collect();
876            plot_area.bubble_chart = Some(BubbleChart { series: bs, ax_ids });
877        }
878        ChartType::Bubble3D => {
879            let bs: Vec<BubbleSeries> = config
880                .series
881                .iter()
882                .enumerate()
883                .map(|(i, s)| build_bubble_series(i as u32, s, true))
884                .collect();
885            plot_area.bubble_chart = Some(BubbleChart { series: bs, ax_ids });
886        }
887        ChartType::Radar => {
888            plot_area.radar_chart = Some(RadarChart {
889                radar_style: StringVal {
890                    val: "standard".into(),
891                },
892                series: xml_series,
893                ax_ids,
894            });
895        }
896        ChartType::RadarFilled => {
897            plot_area.radar_chart = Some(RadarChart {
898                radar_style: StringVal {
899                    val: "filled".into(),
900                },
901                series: xml_series,
902                ax_ids,
903            });
904        }
905        ChartType::RadarMarker => {
906            plot_area.radar_chart = Some(RadarChart {
907                radar_style: StringVal {
908                    val: "marker".into(),
909                },
910                series: xml_series,
911                ax_ids,
912            });
913        }
914        ChartType::StockHLC => {
915            plot_area.stock_chart = Some(StockChart {
916                series: xml_series,
917                hi_low_lines: Some(HighLowLines {}),
918                up_down_bars: None,
919                ax_ids,
920            });
921        }
922        ChartType::StockOHLC => {
923            plot_area.stock_chart = Some(StockChart {
924                series: xml_series,
925                hi_low_lines: Some(HighLowLines {}),
926                up_down_bars: Some(UpDownBars {}),
927                ax_ids,
928            });
929        }
930        ChartType::StockVHLC | ChartType::StockVOHLC => {
931            let (volume_series, stock_series) = match xml_series.split_first() {
932                Some((volume, stock)) => (vec![volume.clone()], stock.to_vec()),
933                None => (vec![], vec![]),
934            };
935            plot_area.bar_chart = Some(BarChart {
936                bar_dir: StringVal { val: "col".into() },
937                grouping: StringVal {
938                    val: "clustered".into(),
939                },
940                series: volume_series,
941                ax_ids: volume_ax_ids(),
942            });
943            plot_area.additional_val_axes.push(build_volume_val_ax());
944            plot_area.stock_chart = Some(StockChart {
945                series: stock_series,
946                hi_low_lines: Some(HighLowLines {}),
947                up_down_bars: matches!(ct, ChartType::StockVOHLC).then_some(UpDownBars {}),
948                ax_ids,
949            });
950        }
951        ChartType::Surface => {
952            plot_area.surface_chart = Some(SurfaceChart {
953                wireframe: None,
954                series: xml_series,
955                ax_ids,
956            });
957        }
958        ChartType::SurfaceWireframe => {
959            plot_area.surface_chart = Some(SurfaceChart {
960                wireframe: Some(BoolVal { val: true }),
961                series: xml_series,
962                ax_ids,
963            });
964        }
965        ChartType::Surface3D => {
966            plot_area.surface_3d_chart = Some(Surface3DChart {
967                wireframe: None,
968                series: xml_series,
969                ax_ids,
970            });
971        }
972        ChartType::SurfaceWireframe3D => {
973            plot_area.surface_3d_chart = Some(Surface3DChart {
974                wireframe: Some(BoolVal { val: true }),
975                series: xml_series,
976                ax_ids,
977            });
978        }
979        ChartType::PieOfPie => {
980            plot_area.of_pie_chart = Some(OfPieChart {
981                of_pie_type: StringVal { val: "pie".into() },
982                series: xml_series,
983                ser_lines: Some(SerLines {}),
984            });
985        }
986        ChartType::BarOfPie => {
987            plot_area.of_pie_chart = Some(OfPieChart {
988                of_pie_type: StringVal { val: "bar".into() },
989                series: xml_series,
990                ser_lines: Some(SerLines {}),
991            });
992        }
993        ChartType::Col3DCone => {
994            plot_area.bar_3d_chart = Some(Bar3DChart {
995                bar_dir: StringVal { val: "col".into() },
996                grouping: StringVal {
997                    val: "clustered".into(),
998                },
999                series: xml_series,
1000                shape: Some(StringVal { val: "cone".into() }),
1001                ax_ids,
1002            });
1003        }
1004        ChartType::Col3DConeStacked => {
1005            plot_area.bar_3d_chart = Some(Bar3DChart {
1006                bar_dir: StringVal { val: "col".into() },
1007                grouping: StringVal {
1008                    val: "stacked".into(),
1009                },
1010                series: xml_series,
1011                shape: Some(StringVal { val: "cone".into() }),
1012                ax_ids,
1013            });
1014        }
1015        ChartType::Col3DConePercentStacked => {
1016            plot_area.bar_3d_chart = Some(Bar3DChart {
1017                bar_dir: StringVal { val: "col".into() },
1018                grouping: StringVal {
1019                    val: "percentStacked".into(),
1020                },
1021                series: xml_series,
1022                shape: Some(StringVal { val: "cone".into() }),
1023                ax_ids,
1024            });
1025        }
1026        ChartType::Col3DPyramid => {
1027            plot_area.bar_3d_chart = Some(Bar3DChart {
1028                bar_dir: StringVal { val: "col".into() },
1029                grouping: StringVal {
1030                    val: "clustered".into(),
1031                },
1032                series: xml_series,
1033                shape: Some(StringVal {
1034                    val: "pyramid".into(),
1035                }),
1036                ax_ids,
1037            });
1038        }
1039        ChartType::Col3DPyramidStacked => {
1040            plot_area.bar_3d_chart = Some(Bar3DChart {
1041                bar_dir: StringVal { val: "col".into() },
1042                grouping: StringVal {
1043                    val: "stacked".into(),
1044                },
1045                series: xml_series,
1046                shape: Some(StringVal {
1047                    val: "pyramid".into(),
1048                }),
1049                ax_ids,
1050            });
1051        }
1052        ChartType::Col3DPyramidPercentStacked => {
1053            plot_area.bar_3d_chart = Some(Bar3DChart {
1054                bar_dir: StringVal { val: "col".into() },
1055                grouping: StringVal {
1056                    val: "percentStacked".into(),
1057                },
1058                series: xml_series,
1059                shape: Some(StringVal {
1060                    val: "pyramid".into(),
1061                }),
1062                ax_ids,
1063            });
1064        }
1065        ChartType::Col3DCylinder => {
1066            plot_area.bar_3d_chart = Some(Bar3DChart {
1067                bar_dir: StringVal { val: "col".into() },
1068                grouping: StringVal {
1069                    val: "clustered".into(),
1070                },
1071                series: xml_series,
1072                shape: Some(StringVal {
1073                    val: "cylinder".into(),
1074                }),
1075                ax_ids,
1076            });
1077        }
1078        ChartType::Col3DCylinderStacked => {
1079            plot_area.bar_3d_chart = Some(Bar3DChart {
1080                bar_dir: StringVal { val: "col".into() },
1081                grouping: StringVal {
1082                    val: "stacked".into(),
1083                },
1084                series: xml_series,
1085                shape: Some(StringVal {
1086                    val: "cylinder".into(),
1087                }),
1088                ax_ids,
1089            });
1090        }
1091        ChartType::Col3DCylinderPercentStacked => {
1092            plot_area.bar_3d_chart = Some(Bar3DChart {
1093                bar_dir: StringVal { val: "col".into() },
1094                grouping: StringVal {
1095                    val: "percentStacked".into(),
1096                },
1097                series: xml_series,
1098                shape: Some(StringVal {
1099                    val: "cylinder".into(),
1100                }),
1101                ax_ids,
1102            });
1103        }
1104        ChartType::Contour => {
1105            plot_area.surface_chart = Some(SurfaceChart {
1106                wireframe: Some(BoolVal { val: false }),
1107                series: xml_series,
1108                ax_ids,
1109            });
1110        }
1111        ChartType::WireframeContour => {
1112            plot_area.surface_chart = Some(SurfaceChart {
1113                wireframe: Some(BoolVal { val: true }),
1114                series: xml_series,
1115                ax_ids,
1116            });
1117        }
1118        ChartType::ColLine | ChartType::ColLineStacked | ChartType::ColLinePercentStacked => {
1119            let grouping = match ct {
1120                ChartType::ColLineStacked => "stacked",
1121                ChartType::ColLinePercentStacked => "percentStacked",
1122                _ => "clustered",
1123            };
1124            let total = xml_series.len();
1125            let bar_count = total.div_ceil(2);
1126            let bar_series: Vec<Series> = xml_series.iter().take(bar_count).cloned().collect();
1127            let line_series: Vec<Series> = xml_series.iter().skip(bar_count).cloned().collect();
1128            plot_area.bar_chart = Some(BarChart {
1129                bar_dir: StringVal { val: "col".into() },
1130                grouping: StringVal {
1131                    val: grouping.into(),
1132                },
1133                series: bar_series,
1134                ax_ids: ax_ids.clone(),
1135            });
1136            plot_area.line_chart = Some(LineChart {
1137                grouping: StringVal {
1138                    val: "standard".into(),
1139                },
1140                series: line_series,
1141                ax_ids,
1142            });
1143        }
1144    }
1145
1146    plot_area
1147}
1148
1149#[cfg(test)]
1150mod tests {
1151    use super::*;
1152
1153    fn ss() -> Vec<ChartSeries> {
1154        vec![ChartSeries {
1155            name: "Revenue".into(),
1156            categories: "Sheet1!$A$2:$A$6".into(),
1157            values: "Sheet1!$B$2:$B$6".into(),
1158            x_values: None,
1159            bubble_sizes: None,
1160        }]
1161    }
1162
1163    fn mc(chart_type: ChartType) -> ChartConfig {
1164        ChartConfig {
1165            chart_type,
1166            title: None,
1167            series: ss(),
1168            show_legend: false,
1169            view_3d: None,
1170        }
1171    }
1172
1173    #[test]
1174    fn test_build_chart_xml_col() {
1175        let config = ChartConfig {
1176            chart_type: ChartType::Col,
1177            title: Some("Sales Chart".into()),
1178            series: ss(),
1179            show_legend: true,
1180            view_3d: None,
1181        };
1182        let cs = build_chart_xml(&config);
1183        assert!(cs.chart.title.is_some());
1184        assert!(cs.chart.legend.is_some());
1185        assert!(cs.chart.plot_area.bar_chart.is_some());
1186        assert!(cs.chart.plot_area.line_chart.is_none());
1187        assert!(cs.chart.plot_area.pie_chart.is_none());
1188        assert!(cs.chart.view_3d.is_none());
1189        let bar = cs.chart.plot_area.bar_chart.unwrap();
1190        assert_eq!(bar.bar_dir.val, "col");
1191        assert_eq!(bar.grouping.val, "clustered");
1192        assert_eq!(bar.series.len(), 1);
1193        assert_eq!(bar.ax_ids.len(), 2);
1194    }
1195
1196    #[test]
1197    fn test_build_chart_xml_bar() {
1198        let cs = build_chart_xml(&ChartConfig {
1199            chart_type: ChartType::Bar,
1200            title: None,
1201            series: vec![],
1202            show_legend: false,
1203            view_3d: None,
1204        });
1205        assert!(cs.chart.title.is_none());
1206        assert!(cs.chart.legend.is_none());
1207        let bar = cs.chart.plot_area.bar_chart.unwrap();
1208        assert_eq!(bar.bar_dir.val, "bar");
1209        assert_eq!(bar.grouping.val, "clustered");
1210    }
1211
1212    #[test]
1213    fn test_bar_stacked() {
1214        let cs = build_chart_xml(&mc(ChartType::BarStacked));
1215        let bar = cs.chart.plot_area.bar_chart.unwrap();
1216        assert_eq!(bar.bar_dir.val, "bar");
1217        assert_eq!(bar.grouping.val, "stacked");
1218    }
1219
1220    #[test]
1221    fn test_col_stacked() {
1222        let cs = build_chart_xml(&mc(ChartType::ColStacked));
1223        let bar = cs.chart.plot_area.bar_chart.unwrap();
1224        assert_eq!(bar.bar_dir.val, "col");
1225        assert_eq!(bar.grouping.val, "stacked");
1226    }
1227
1228    #[test]
1229    fn test_col_percent_stacked() {
1230        let cs = build_chart_xml(&mc(ChartType::ColPercentStacked));
1231        let bar = cs.chart.plot_area.bar_chart.unwrap();
1232        assert_eq!(bar.grouping.val, "percentStacked");
1233    }
1234
1235    #[test]
1236    fn test_bar_percent_stacked() {
1237        let cs = build_chart_xml(&mc(ChartType::BarPercentStacked));
1238        let bar = cs.chart.plot_area.bar_chart.unwrap();
1239        assert_eq!(bar.bar_dir.val, "bar");
1240        assert_eq!(bar.grouping.val, "percentStacked");
1241    }
1242
1243    #[test]
1244    fn test_line() {
1245        let cs = build_chart_xml(&ChartConfig {
1246            chart_type: ChartType::Line,
1247            title: Some("Trend".into()),
1248            series: vec![ChartSeries {
1249                name: "Sheet1!$A$1".into(),
1250                categories: "Sheet1!$A$2:$A$6".into(),
1251                values: "Sheet1!$B$2:$B$6".into(),
1252                x_values: None,
1253                bubble_sizes: None,
1254            }],
1255            show_legend: true,
1256            view_3d: None,
1257        });
1258        assert!(cs.chart.plot_area.line_chart.is_some());
1259        let line = cs.chart.plot_area.line_chart.unwrap();
1260        assert_eq!(line.grouping.val, "standard");
1261        assert_eq!(line.series.len(), 1);
1262        let tx = line.series[0].tx.as_ref().unwrap();
1263        assert!(tx.str_ref.is_some());
1264        assert!(tx.v.is_none());
1265    }
1266
1267    #[test]
1268    fn test_pie() {
1269        let cs = build_chart_xml(&ChartConfig {
1270            chart_type: ChartType::Pie,
1271            title: Some("Distribution".into()),
1272            series: vec![ChartSeries {
1273                name: "Data".into(),
1274                categories: "Sheet1!$A$2:$A$6".into(),
1275                values: "Sheet1!$B$2:$B$6".into(),
1276                x_values: None,
1277                bubble_sizes: None,
1278            }],
1279            show_legend: true,
1280            view_3d: None,
1281        });
1282        assert!(cs.chart.plot_area.pie_chart.is_some());
1283        assert!(cs.chart.plot_area.cat_ax.is_none());
1284        assert!(cs.chart.plot_area.val_ax.is_none());
1285        let pie = cs.chart.plot_area.pie_chart.unwrap();
1286        let tx = pie.series[0].tx.as_ref().unwrap();
1287        assert!(tx.str_ref.is_none());
1288        assert_eq!(tx.v.as_deref(), Some("Data"));
1289    }
1290
1291    #[test]
1292    fn test_no_legend() {
1293        let cs = build_chart_xml(&mc(ChartType::Col));
1294        assert!(cs.chart.legend.is_none());
1295    }
1296
1297    #[test]
1298    fn test_axes_present_for_non_pie() {
1299        let cs = build_chart_xml(&mc(ChartType::Line));
1300        assert!(cs.chart.plot_area.cat_ax.is_some());
1301        assert!(cs.chart.plot_area.val_ax.is_some());
1302    }
1303
1304    #[test]
1305    fn test_drawing_with_chart() {
1306        let from = MarkerType {
1307            col: 1,
1308            col_off: 0,
1309            row: 1,
1310            row_off: 0,
1311        };
1312        let to = MarkerType {
1313            col: 10,
1314            col_off: 0,
1315            row: 15,
1316            row_off: 0,
1317        };
1318        let dr = build_drawing_with_chart("rId1", from, to);
1319        assert_eq!(dr.two_cell_anchors.len(), 1);
1320        let anchor = &dr.two_cell_anchors[0];
1321        assert!(anchor.graphic_frame.is_some());
1322        assert_eq!(anchor.from.col, 1);
1323        assert_eq!(anchor.to.col, 10);
1324        let gf = anchor.graphic_frame.as_ref().unwrap();
1325        assert_eq!(gf.graphic.graphic_data.chart.r_id, "rId1");
1326    }
1327
1328    #[test]
1329    fn test_series_literal_name() {
1330        let s = ChartSeries {
1331            name: "MyName".into(),
1332            categories: "Sheet1!$A$2:$A$6".into(),
1333            values: "Sheet1!$B$2:$B$6".into(),
1334            x_values: None,
1335            bubble_sizes: None,
1336        };
1337        let xs = build_series(0, &s);
1338        let tx = xs.tx.as_ref().unwrap();
1339        assert!(tx.str_ref.is_none());
1340        assert_eq!(tx.v.as_deref(), Some("MyName"));
1341    }
1342
1343    #[test]
1344    fn test_series_cell_ref_name() {
1345        let s = ChartSeries {
1346            name: "Sheet1!$C$1".into(),
1347            categories: "".into(),
1348            values: "Sheet1!$B$2:$B$6".into(),
1349            x_values: None,
1350            bubble_sizes: None,
1351        };
1352        let xs = build_series(0, &s);
1353        let tx = xs.tx.as_ref().unwrap();
1354        assert!(tx.str_ref.is_some());
1355        assert!(tx.v.is_none());
1356        assert!(xs.cat.is_none());
1357    }
1358
1359    #[test]
1360    fn test_series_empty_name() {
1361        let s = ChartSeries {
1362            name: "".into(),
1363            categories: "Sheet1!$A$2:$A$6".into(),
1364            values: "Sheet1!$B$2:$B$6".into(),
1365            x_values: None,
1366            bubble_sizes: None,
1367        };
1368        let xs = build_series(0, &s);
1369        assert!(xs.tx.is_none());
1370    }
1371
1372    #[test]
1373    fn test_multiple_series() {
1374        let cs = build_chart_xml(&ChartConfig {
1375            chart_type: ChartType::Col,
1376            title: None,
1377            series: vec![
1378                ChartSeries {
1379                    name: "A".into(),
1380                    categories: "Sheet1!$A$2:$A$6".into(),
1381                    values: "Sheet1!$B$2:$B$6".into(),
1382                    x_values: None,
1383                    bubble_sizes: None,
1384                },
1385                ChartSeries {
1386                    name: "B".into(),
1387                    categories: "Sheet1!$A$2:$A$6".into(),
1388                    values: "Sheet1!$C$2:$C$6".into(),
1389                    x_values: None,
1390                    bubble_sizes: None,
1391                },
1392            ],
1393            show_legend: true,
1394            view_3d: None,
1395        });
1396        let bar = cs.chart.plot_area.bar_chart.unwrap();
1397        assert_eq!(bar.series.len(), 2);
1398        assert_eq!(bar.series[0].idx.val, 0);
1399        assert_eq!(bar.series[1].idx.val, 1);
1400    }
1401
1402    #[test]
1403    fn test_area_chart() {
1404        let cs = build_chart_xml(&mc(ChartType::Area));
1405        assert!(cs.chart.plot_area.area_chart.is_some());
1406        let a = cs.chart.plot_area.area_chart.unwrap();
1407        assert_eq!(a.grouping.val, "standard");
1408        assert_eq!(a.ax_ids.len(), 2);
1409        assert!(cs.chart.view_3d.is_none());
1410    }
1411
1412    #[test]
1413    fn test_area_stacked() {
1414        let cs = build_chart_xml(&mc(ChartType::AreaStacked));
1415        assert_eq!(
1416            cs.chart.plot_area.area_chart.unwrap().grouping.val,
1417            "stacked"
1418        );
1419    }
1420
1421    #[test]
1422    fn test_area_percent_stacked() {
1423        let cs = build_chart_xml(&mc(ChartType::AreaPercentStacked));
1424        assert_eq!(
1425            cs.chart.plot_area.area_chart.unwrap().grouping.val,
1426            "percentStacked"
1427        );
1428    }
1429
1430    #[test]
1431    fn test_area_3d() {
1432        let cs = build_chart_xml(&mc(ChartType::Area3D));
1433        assert!(cs.chart.view_3d.is_some());
1434        assert_eq!(
1435            cs.chart.plot_area.area_3d_chart.unwrap().grouping.val,
1436            "standard"
1437        );
1438    }
1439
1440    #[test]
1441    fn test_area_3d_stacked() {
1442        let cs = build_chart_xml(&mc(ChartType::Area3DStacked));
1443        assert!(cs.chart.view_3d.is_some());
1444        assert_eq!(
1445            cs.chart.plot_area.area_3d_chart.unwrap().grouping.val,
1446            "stacked"
1447        );
1448    }
1449
1450    #[test]
1451    fn test_area_3d_percent_stacked() {
1452        let cs = build_chart_xml(&mc(ChartType::Area3DPercentStacked));
1453        assert!(cs.chart.view_3d.is_some());
1454        assert_eq!(
1455            cs.chart.plot_area.area_3d_chart.unwrap().grouping.val,
1456            "percentStacked"
1457        );
1458    }
1459
1460    #[test]
1461    fn test_col_3d() {
1462        let cs = build_chart_xml(&mc(ChartType::Col3D));
1463        assert!(cs.chart.view_3d.is_some());
1464        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
1465        assert_eq!(b.bar_dir.val, "col");
1466        assert_eq!(b.grouping.val, "clustered");
1467    }
1468
1469    #[test]
1470    fn test_col_3d_stacked() {
1471        let cs = build_chart_xml(&mc(ChartType::Col3DStacked));
1472        assert_eq!(
1473            cs.chart.plot_area.bar_3d_chart.unwrap().grouping.val,
1474            "stacked"
1475        );
1476    }
1477
1478    #[test]
1479    fn test_col_3d_percent_stacked() {
1480        let cs = build_chart_xml(&mc(ChartType::Col3DPercentStacked));
1481        assert_eq!(
1482            cs.chart.plot_area.bar_3d_chart.unwrap().grouping.val,
1483            "percentStacked"
1484        );
1485    }
1486
1487    #[test]
1488    fn test_bar_3d() {
1489        let cs = build_chart_xml(&mc(ChartType::Bar3D));
1490        assert!(cs.chart.view_3d.is_some());
1491        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
1492        assert_eq!(b.bar_dir.val, "bar");
1493        assert_eq!(b.grouping.val, "clustered");
1494    }
1495
1496    #[test]
1497    fn test_bar_3d_stacked() {
1498        let cs = build_chart_xml(&mc(ChartType::Bar3DStacked));
1499        assert_eq!(
1500            cs.chart.plot_area.bar_3d_chart.unwrap().grouping.val,
1501            "stacked"
1502        );
1503    }
1504
1505    #[test]
1506    fn test_bar_3d_percent_stacked() {
1507        let cs = build_chart_xml(&mc(ChartType::Bar3DPercentStacked));
1508        assert_eq!(
1509            cs.chart.plot_area.bar_3d_chart.unwrap().grouping.val,
1510            "percentStacked"
1511        );
1512    }
1513
1514    #[test]
1515    fn test_line_stacked() {
1516        let cs = build_chart_xml(&mc(ChartType::LineStacked));
1517        assert_eq!(
1518            cs.chart.plot_area.line_chart.unwrap().grouping.val,
1519            "stacked"
1520        );
1521    }
1522
1523    #[test]
1524    fn test_line_percent_stacked() {
1525        let cs = build_chart_xml(&mc(ChartType::LinePercentStacked));
1526        assert_eq!(
1527            cs.chart.plot_area.line_chart.unwrap().grouping.val,
1528            "percentStacked"
1529        );
1530    }
1531
1532    #[test]
1533    fn test_line_3d() {
1534        let cs = build_chart_xml(&mc(ChartType::Line3D));
1535        assert!(cs.chart.view_3d.is_some());
1536        assert!(cs.chart.plot_area.line_3d_chart.is_some());
1537    }
1538
1539    #[test]
1540    fn test_pie_3d() {
1541        let cs = build_chart_xml(&mc(ChartType::Pie3D));
1542        assert!(cs.chart.view_3d.is_some());
1543        assert!(cs.chart.plot_area.pie_3d_chart.is_some());
1544        assert!(cs.chart.plot_area.cat_ax.is_none());
1545    }
1546
1547    #[test]
1548    fn test_doughnut() {
1549        let cs = build_chart_xml(&mc(ChartType::Doughnut));
1550        assert!(cs.chart.plot_area.doughnut_chart.is_some());
1551        assert!(cs.chart.plot_area.cat_ax.is_none());
1552        let d = cs.chart.plot_area.doughnut_chart.unwrap();
1553        assert_eq!(d.hole_size.as_ref().unwrap().val, 50);
1554    }
1555
1556    #[test]
1557    fn test_scatter() {
1558        let cs = build_chart_xml(&ChartConfig {
1559            chart_type: ChartType::Scatter,
1560            title: None,
1561            series: vec![ChartSeries {
1562                name: "XY".into(),
1563                categories: "Sheet1!$A$2:$A$6".into(),
1564                values: "Sheet1!$B$2:$B$6".into(),
1565                x_values: None,
1566                bubble_sizes: None,
1567            }],
1568            show_legend: false,
1569            view_3d: None,
1570        });
1571        let sc = cs.chart.plot_area.scatter_chart.unwrap();
1572        assert_eq!(sc.scatter_style.val, "lineMarker");
1573        assert_eq!(sc.series.len(), 1);
1574        let s = &sc.series[0];
1575        assert_eq!(
1576            s.x_val.as_ref().unwrap().num_ref.as_ref().unwrap().f,
1577            "Sheet1!$A$2:$A$6"
1578        );
1579        assert_eq!(
1580            s.y_val.as_ref().unwrap().num_ref.as_ref().unwrap().f,
1581            "Sheet1!$B$2:$B$6"
1582        );
1583    }
1584
1585    #[test]
1586    fn test_scatter_explicit_x() {
1587        let cs = build_chart_xml(&ChartConfig {
1588            chart_type: ChartType::Scatter,
1589            title: None,
1590            series: vec![ChartSeries {
1591                name: "".into(),
1592                categories: "Sheet1!$A$2:$A$6".into(),
1593                values: "Sheet1!$B$2:$B$6".into(),
1594                x_values: Some("Sheet1!$D$2:$D$6".into()),
1595                bubble_sizes: None,
1596            }],
1597            show_legend: false,
1598            view_3d: None,
1599        });
1600        let s = &cs.chart.plot_area.scatter_chart.unwrap().series[0];
1601        assert_eq!(
1602            s.x_val.as_ref().unwrap().num_ref.as_ref().unwrap().f,
1603            "Sheet1!$D$2:$D$6"
1604        );
1605    }
1606
1607    #[test]
1608    fn test_scatter_line() {
1609        let cs = build_chart_xml(&mc(ChartType::ScatterLine));
1610        assert_eq!(
1611            cs.chart.plot_area.scatter_chart.unwrap().scatter_style.val,
1612            "line"
1613        );
1614    }
1615
1616    #[test]
1617    fn test_scatter_smooth() {
1618        let cs = build_chart_xml(&mc(ChartType::ScatterSmooth));
1619        assert_eq!(
1620            cs.chart.plot_area.scatter_chart.unwrap().scatter_style.val,
1621            "smoothMarker"
1622        );
1623    }
1624
1625    #[test]
1626    fn test_bubble() {
1627        let cs = build_chart_xml(&ChartConfig {
1628            chart_type: ChartType::Bubble,
1629            title: None,
1630            series: vec![ChartSeries {
1631                name: "B".into(),
1632                categories: "Sheet1!$A$2:$A$6".into(),
1633                values: "Sheet1!$B$2:$B$6".into(),
1634                x_values: None,
1635                bubble_sizes: Some("Sheet1!$C$2:$C$6".into()),
1636            }],
1637            show_legend: false,
1638            view_3d: None,
1639        });
1640        let b = cs.chart.plot_area.bubble_chart.unwrap();
1641        assert_eq!(b.series.len(), 1);
1642        assert_eq!(
1643            b.series[0]
1644                .bubble_size
1645                .as_ref()
1646                .unwrap()
1647                .num_ref
1648                .as_ref()
1649                .unwrap()
1650                .f,
1651            "Sheet1!$C$2:$C$6"
1652        );
1653    }
1654
1655    #[test]
1656    fn test_radar() {
1657        let cs = build_chart_xml(&mc(ChartType::Radar));
1658        assert_eq!(
1659            cs.chart.plot_area.radar_chart.unwrap().radar_style.val,
1660            "standard"
1661        );
1662    }
1663
1664    #[test]
1665    fn test_radar_filled() {
1666        let cs = build_chart_xml(&mc(ChartType::RadarFilled));
1667        assert_eq!(
1668            cs.chart.plot_area.radar_chart.unwrap().radar_style.val,
1669            "filled"
1670        );
1671    }
1672
1673    #[test]
1674    fn test_radar_marker() {
1675        let cs = build_chart_xml(&mc(ChartType::RadarMarker));
1676        assert_eq!(
1677            cs.chart.plot_area.radar_chart.unwrap().radar_style.val,
1678            "marker"
1679        );
1680    }
1681
1682    #[test]
1683    fn test_stock_hlc() {
1684        let cs = build_chart_xml(&mc(ChartType::StockHLC));
1685        assert!(cs.chart.plot_area.stock_chart.is_some());
1686    }
1687
1688    #[test]
1689    fn test_stock_ohlc() {
1690        let cs = build_chart_xml(&mc(ChartType::StockOHLC));
1691        assert!(cs.chart.plot_area.stock_chart.is_some());
1692    }
1693
1694    #[test]
1695    fn test_stock_vhlc() {
1696        let cs = build_chart_xml(&mc(ChartType::StockVHLC));
1697        assert!(cs.chart.plot_area.stock_chart.is_some());
1698    }
1699
1700    #[test]
1701    fn test_stock_vohlc() {
1702        let cs = build_chart_xml(&mc(ChartType::StockVOHLC));
1703        assert!(cs.chart.plot_area.stock_chart.is_some());
1704    }
1705
1706    #[test]
1707    fn test_surface() {
1708        let cs = build_chart_xml(&mc(ChartType::Surface));
1709        assert!(cs.chart.plot_area.surface_chart.is_some());
1710        assert!(cs.chart.plot_area.ser_ax.is_some());
1711        let sf = cs.chart.plot_area.surface_chart.unwrap();
1712        assert!(sf.wireframe.is_none());
1713        assert_eq!(sf.ax_ids.len(), 3);
1714    }
1715
1716    #[test]
1717    fn test_surface_wireframe() {
1718        let cs = build_chart_xml(&mc(ChartType::SurfaceWireframe));
1719        let sf = cs.chart.plot_area.surface_chart.unwrap();
1720        assert!(sf.wireframe.as_ref().unwrap().val);
1721        assert_eq!(sf.ax_ids.len(), 3);
1722    }
1723
1724    #[test]
1725    fn test_surface_3d() {
1726        let cs = build_chart_xml(&mc(ChartType::Surface3D));
1727        assert!(cs.chart.view_3d.is_some());
1728        assert!(cs.chart.plot_area.surface_3d_chart.is_some());
1729        assert!(cs.chart.plot_area.ser_ax.is_some());
1730    }
1731
1732    #[test]
1733    fn test_surface_wireframe_3d() {
1734        let cs = build_chart_xml(&mc(ChartType::SurfaceWireframe3D));
1735        assert!(cs.chart.view_3d.is_some());
1736        let sf = cs.chart.plot_area.surface_3d_chart.unwrap();
1737        assert!(sf.wireframe.as_ref().unwrap().val);
1738    }
1739
1740    #[test]
1741    fn test_col_line_combo() {
1742        let cs = build_chart_xml(&ChartConfig {
1743            chart_type: ChartType::ColLine,
1744            title: None,
1745            series: vec![
1746                ChartSeries {
1747                    name: "A".into(),
1748                    categories: "Sheet1!$A$2:$A$6".into(),
1749                    values: "Sheet1!$B$2:$B$6".into(),
1750                    x_values: None,
1751                    bubble_sizes: None,
1752                },
1753                ChartSeries {
1754                    name: "B".into(),
1755                    categories: "Sheet1!$A$2:$A$6".into(),
1756                    values: "Sheet1!$C$2:$C$6".into(),
1757                    x_values: None,
1758                    bubble_sizes: None,
1759                },
1760            ],
1761            show_legend: true,
1762            view_3d: None,
1763        });
1764        assert!(cs.chart.plot_area.bar_chart.is_some());
1765        assert!(cs.chart.plot_area.line_chart.is_some());
1766        let bar = cs.chart.plot_area.bar_chart.unwrap();
1767        assert_eq!(bar.grouping.val, "clustered");
1768        assert_eq!(bar.series.len(), 1);
1769        assert_eq!(cs.chart.plot_area.line_chart.unwrap().series.len(), 1);
1770    }
1771
1772    #[test]
1773    fn test_col_line_stacked_combo() {
1774        let cs = build_chart_xml(&ChartConfig {
1775            chart_type: ChartType::ColLineStacked,
1776            title: None,
1777            series: vec![
1778                ChartSeries {
1779                    name: "A".into(),
1780                    categories: "".into(),
1781                    values: "Sheet1!$B$2:$B$6".into(),
1782                    x_values: None,
1783                    bubble_sizes: None,
1784                },
1785                ChartSeries {
1786                    name: "B".into(),
1787                    categories: "".into(),
1788                    values: "Sheet1!$C$2:$C$6".into(),
1789                    x_values: None,
1790                    bubble_sizes: None,
1791                },
1792                ChartSeries {
1793                    name: "C".into(),
1794                    categories: "".into(),
1795                    values: "Sheet1!$D$2:$D$6".into(),
1796                    x_values: None,
1797                    bubble_sizes: None,
1798                },
1799            ],
1800            show_legend: false,
1801            view_3d: None,
1802        });
1803        let bar = cs.chart.plot_area.bar_chart.unwrap();
1804        assert_eq!(bar.grouping.val, "stacked");
1805        assert_eq!(bar.series.len(), 2);
1806        assert_eq!(cs.chart.plot_area.line_chart.unwrap().series.len(), 1);
1807    }
1808
1809    #[test]
1810    fn test_col_line_percent_stacked_combo() {
1811        let cs = build_chart_xml(&ChartConfig {
1812            chart_type: ChartType::ColLinePercentStacked,
1813            title: None,
1814            series: vec![ChartSeries {
1815                name: "A".into(),
1816                categories: "".into(),
1817                values: "Sheet1!$B$2:$B$6".into(),
1818                x_values: None,
1819                bubble_sizes: None,
1820            }],
1821            show_legend: false,
1822            view_3d: None,
1823        });
1824        let bar = cs.chart.plot_area.bar_chart.unwrap();
1825        assert_eq!(bar.grouping.val, "percentStacked");
1826        assert_eq!(bar.series.len(), 1);
1827        assert_eq!(cs.chart.plot_area.line_chart.unwrap().series.len(), 0);
1828    }
1829
1830    #[test]
1831    fn test_view_3d_explicit() {
1832        let cs = build_chart_xml(&ChartConfig {
1833            chart_type: ChartType::Col3D,
1834            title: None,
1835            series: vec![],
1836            show_legend: false,
1837            view_3d: Some(View3DConfig {
1838                rot_x: Some(30),
1839                rot_y: Some(40),
1840                depth_percent: Some(200),
1841                right_angle_axes: Some(false),
1842                perspective: Some(10),
1843            }),
1844        });
1845        let v = cs.chart.view_3d.unwrap();
1846        assert_eq!(v.rot_x.unwrap().val, 30);
1847        assert_eq!(v.rot_y.unwrap().val, 40);
1848        assert_eq!(v.depth_percent.unwrap().val, 200);
1849        assert!(!v.r_ang_ax.unwrap().val);
1850        assert_eq!(v.perspective.unwrap().val, 10);
1851    }
1852
1853    #[test]
1854    fn test_view_3d_auto_defaults() {
1855        let cs = build_chart_xml(&mc(ChartType::Col3D));
1856        let v = cs.chart.view_3d.unwrap();
1857        assert_eq!(v.rot_x.unwrap().val, 15);
1858        assert_eq!(v.rot_y.unwrap().val, 20);
1859        assert!(v.r_ang_ax.unwrap().val);
1860        assert_eq!(v.perspective.unwrap().val, 30);
1861    }
1862
1863    #[test]
1864    fn test_non_3d_no_view() {
1865        let cs = build_chart_xml(&mc(ChartType::Col));
1866        assert!(cs.chart.view_3d.is_none());
1867    }
1868
1869    #[test]
1870    fn test_chart_type_enum_coverage() {
1871        let types = [
1872            ChartType::Col,
1873            ChartType::ColStacked,
1874            ChartType::ColPercentStacked,
1875            ChartType::Bar,
1876            ChartType::BarStacked,
1877            ChartType::BarPercentStacked,
1878            ChartType::Line,
1879            ChartType::Pie,
1880            ChartType::Area,
1881            ChartType::AreaStacked,
1882            ChartType::AreaPercentStacked,
1883            ChartType::Area3D,
1884            ChartType::Area3DStacked,
1885            ChartType::Area3DPercentStacked,
1886            ChartType::Col3D,
1887            ChartType::Col3DStacked,
1888            ChartType::Col3DPercentStacked,
1889            ChartType::Bar3D,
1890            ChartType::Bar3DStacked,
1891            ChartType::Bar3DPercentStacked,
1892            ChartType::LineStacked,
1893            ChartType::LinePercentStacked,
1894            ChartType::Line3D,
1895            ChartType::Pie3D,
1896            ChartType::Doughnut,
1897            ChartType::Scatter,
1898            ChartType::ScatterLine,
1899            ChartType::ScatterSmooth,
1900            ChartType::Radar,
1901            ChartType::RadarFilled,
1902            ChartType::RadarMarker,
1903            ChartType::StockHLC,
1904            ChartType::StockOHLC,
1905            ChartType::StockVHLC,
1906            ChartType::StockVOHLC,
1907            ChartType::Bubble,
1908            ChartType::Surface,
1909            ChartType::Surface3D,
1910            ChartType::SurfaceWireframe,
1911            ChartType::SurfaceWireframe3D,
1912            ChartType::ColLine,
1913            ChartType::ColLineStacked,
1914            ChartType::ColLinePercentStacked,
1915            ChartType::PieOfPie,
1916            ChartType::BarOfPie,
1917            ChartType::Col3DCone,
1918            ChartType::Col3DConeStacked,
1919            ChartType::Col3DConePercentStacked,
1920            ChartType::Col3DPyramid,
1921            ChartType::Col3DPyramidStacked,
1922            ChartType::Col3DPyramidPercentStacked,
1923            ChartType::Col3DCylinder,
1924            ChartType::Col3DCylinderStacked,
1925            ChartType::Col3DCylinderPercentStacked,
1926            ChartType::Contour,
1927            ChartType::WireframeContour,
1928            ChartType::Bubble3D,
1929        ];
1930        for ct in &types {
1931            let _ = build_chart_xml(&ChartConfig {
1932                chart_type: ct.clone(),
1933                title: None,
1934                series: vec![],
1935                show_legend: false,
1936                view_3d: None,
1937            });
1938        }
1939    }
1940
1941    #[test]
1942    fn test_scatter_empty_categories() {
1943        let cs = build_chart_xml(&ChartConfig {
1944            chart_type: ChartType::Scatter,
1945            title: None,
1946            series: vec![ChartSeries {
1947                name: "".into(),
1948                categories: "".into(),
1949                values: "Sheet1!$B$2:$B$6".into(),
1950                x_values: None,
1951                bubble_sizes: None,
1952            }],
1953            show_legend: false,
1954            view_3d: None,
1955        });
1956        let s = &cs.chart.plot_area.scatter_chart.unwrap().series[0];
1957        assert!(s.x_val.is_none());
1958        assert!(s.y_val.is_some());
1959    }
1960
1961    #[test]
1962    fn test_bubble_no_sizes() {
1963        let cs = build_chart_xml(&ChartConfig {
1964            chart_type: ChartType::Bubble,
1965            title: None,
1966            series: vec![ChartSeries {
1967                name: "".into(),
1968                categories: "Sheet1!$A$2:$A$6".into(),
1969                values: "Sheet1!$B$2:$B$6".into(),
1970                x_values: None,
1971                bubble_sizes: None,
1972            }],
1973            show_legend: false,
1974            view_3d: None,
1975        });
1976        assert!(cs.chart.plot_area.bubble_chart.unwrap().series[0]
1977            .bubble_size
1978            .is_none());
1979    }
1980
1981    #[test]
1982    fn test_pie_of_pie() {
1983        let cs = build_chart_xml(&mc(ChartType::PieOfPie));
1984        assert!(cs.chart.plot_area.of_pie_chart.is_some());
1985        assert!(cs.chart.plot_area.cat_ax.is_none());
1986        assert!(cs.chart.plot_area.val_ax.is_none());
1987        let op = cs.chart.plot_area.of_pie_chart.unwrap();
1988        assert_eq!(op.of_pie_type.val, "pie");
1989        assert!(op.ser_lines.is_some());
1990        assert_eq!(op.series.len(), 1);
1991    }
1992
1993    #[test]
1994    fn test_bar_of_pie() {
1995        let cs = build_chart_xml(&mc(ChartType::BarOfPie));
1996        assert!(cs.chart.plot_area.of_pie_chart.is_some());
1997        assert!(cs.chart.plot_area.cat_ax.is_none());
1998        let op = cs.chart.plot_area.of_pie_chart.unwrap();
1999        assert_eq!(op.of_pie_type.val, "bar");
2000        assert!(op.ser_lines.is_some());
2001    }
2002
2003    #[test]
2004    fn test_col_3d_cone() {
2005        let cs = build_chart_xml(&mc(ChartType::Col3DCone));
2006        assert!(cs.chart.view_3d.is_some());
2007        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2008        assert_eq!(b.bar_dir.val, "col");
2009        assert_eq!(b.grouping.val, "clustered");
2010        assert_eq!(b.shape.as_ref().unwrap().val, "cone");
2011    }
2012
2013    #[test]
2014    fn test_col_3d_cone_stacked() {
2015        let cs = build_chart_xml(&mc(ChartType::Col3DConeStacked));
2016        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2017        assert_eq!(b.grouping.val, "stacked");
2018        assert_eq!(b.shape.as_ref().unwrap().val, "cone");
2019    }
2020
2021    #[test]
2022    fn test_col_3d_cone_percent_stacked() {
2023        let cs = build_chart_xml(&mc(ChartType::Col3DConePercentStacked));
2024        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2025        assert_eq!(b.grouping.val, "percentStacked");
2026        assert_eq!(b.shape.as_ref().unwrap().val, "cone");
2027    }
2028
2029    #[test]
2030    fn test_col_3d_pyramid() {
2031        let cs = build_chart_xml(&mc(ChartType::Col3DPyramid));
2032        assert!(cs.chart.view_3d.is_some());
2033        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2034        assert_eq!(b.bar_dir.val, "col");
2035        assert_eq!(b.grouping.val, "clustered");
2036        assert_eq!(b.shape.as_ref().unwrap().val, "pyramid");
2037    }
2038
2039    #[test]
2040    fn test_col_3d_pyramid_stacked() {
2041        let cs = build_chart_xml(&mc(ChartType::Col3DPyramidStacked));
2042        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2043        assert_eq!(b.grouping.val, "stacked");
2044        assert_eq!(b.shape.as_ref().unwrap().val, "pyramid");
2045    }
2046
2047    #[test]
2048    fn test_col_3d_pyramid_percent_stacked() {
2049        let cs = build_chart_xml(&mc(ChartType::Col3DPyramidPercentStacked));
2050        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2051        assert_eq!(b.grouping.val, "percentStacked");
2052        assert_eq!(b.shape.as_ref().unwrap().val, "pyramid");
2053    }
2054
2055    #[test]
2056    fn test_col_3d_cylinder() {
2057        let cs = build_chart_xml(&mc(ChartType::Col3DCylinder));
2058        assert!(cs.chart.view_3d.is_some());
2059        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2060        assert_eq!(b.bar_dir.val, "col");
2061        assert_eq!(b.grouping.val, "clustered");
2062        assert_eq!(b.shape.as_ref().unwrap().val, "cylinder");
2063    }
2064
2065    #[test]
2066    fn test_col_3d_cylinder_stacked() {
2067        let cs = build_chart_xml(&mc(ChartType::Col3DCylinderStacked));
2068        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2069        assert_eq!(b.grouping.val, "stacked");
2070        assert_eq!(b.shape.as_ref().unwrap().val, "cylinder");
2071    }
2072
2073    #[test]
2074    fn test_col_3d_cylinder_percent_stacked() {
2075        let cs = build_chart_xml(&mc(ChartType::Col3DCylinderPercentStacked));
2076        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2077        assert_eq!(b.grouping.val, "percentStacked");
2078        assert_eq!(b.shape.as_ref().unwrap().val, "cylinder");
2079    }
2080
2081    #[test]
2082    fn test_contour() {
2083        let cs = build_chart_xml(&mc(ChartType::Contour));
2084        assert!(cs.chart.plot_area.surface_chart.is_some());
2085        assert!(cs.chart.plot_area.ser_ax.is_some());
2086        let sf = cs.chart.plot_area.surface_chart.unwrap();
2087        assert!(!sf.wireframe.as_ref().unwrap().val);
2088        assert_eq!(sf.ax_ids.len(), 3);
2089    }
2090
2091    #[test]
2092    fn test_wireframe_contour() {
2093        let cs = build_chart_xml(&mc(ChartType::WireframeContour));
2094        assert!(cs.chart.plot_area.surface_chart.is_some());
2095        assert!(cs.chart.plot_area.ser_ax.is_some());
2096        let sf = cs.chart.plot_area.surface_chart.unwrap();
2097        assert!(sf.wireframe.as_ref().unwrap().val);
2098        assert_eq!(sf.ax_ids.len(), 3);
2099    }
2100
2101    #[test]
2102    fn test_bubble_3d() {
2103        let cs = build_chart_xml(&ChartConfig {
2104            chart_type: ChartType::Bubble3D,
2105            title: None,
2106            series: vec![ChartSeries {
2107                name: "B3D".into(),
2108                categories: "Sheet1!$A$2:$A$6".into(),
2109                values: "Sheet1!$B$2:$B$6".into(),
2110                x_values: None,
2111                bubble_sizes: Some("Sheet1!$C$2:$C$6".into()),
2112            }],
2113            show_legend: false,
2114            view_3d: None,
2115        });
2116        let b = cs.chart.plot_area.bubble_chart.unwrap();
2117        assert_eq!(b.series.len(), 1);
2118        assert!(b.series[0].bubble_3d.as_ref().unwrap().val);
2119    }
2120
2121    #[test]
2122    fn test_bubble_no_3d_flag() {
2123        let cs = build_chart_xml(&mc(ChartType::Bubble));
2124        let b = cs.chart.plot_area.bubble_chart.unwrap();
2125        assert!(b.series[0].bubble_3d.is_none());
2126    }
2127
2128    #[test]
2129    fn test_col_3d_no_shape() {
2130        let cs = build_chart_xml(&mc(ChartType::Col3D));
2131        let b = cs.chart.plot_area.bar_3d_chart.unwrap();
2132        assert!(b.shape.is_none());
2133    }
2134}