From 48c9dc6f5d2e325394cdcf0a50deb7718a44518b Mon Sep 17 00:00:00 2001
From: Johann Tuffe <tafia973@gmail.com>
Date: Mon, 8 Jul 2024 23:22:38 +0800
Subject: [PATCH 1/3] Cleanup tests workbook creation

---
 tests/test.rs | 434 ++++++++++----------------------------------------
 1 file changed, 86 insertions(+), 348 deletions(-)

diff --git a/tests/test.rs b/tests/test.rs
index 2116cb8e..81f3465c 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -5,16 +5,19 @@ use calamine::{
 };
 use calamine::{CellErrorType::*, Data};
 use std::collections::BTreeSet;
-use std::io::Cursor;
+use std::fs::File;
+use std::io::{BufReader, Cursor};
 use std::sync::Once;
 
 static INIT: Once = Once::new();
 
 /// Setup function that is only run once, even if called multiple times.
-fn setup() {
+fn wb<R: Reader<BufReader<File>>>(name: &str) -> R {
     INIT.call_once(|| {
         env_logger::init();
     });
+    let path = format!("{}/tests/{name}", env!("CARGO_MANIFEST_DIR"));
+    open_workbook(&path).expect(&path)
 }
 
 macro_rules! range_eq {
@@ -34,11 +37,7 @@ macro_rules! range_eq {
 
 #[test]
 fn issue_2() {
-    setup();
-
-    let path = format!("{}/tests/issues.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsx<_> = wb("issues.xlsx");
     let range = excel.worksheet_range("issue2").unwrap();
     range_eq!(
         range,
@@ -52,36 +51,22 @@ fn issue_2() {
 
 #[test]
 fn issue_3() {
-    setup();
-
     // test if sheet is resolved with only one row
-    let path = format!("{}/tests/issue3.xlsm", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsx<_> = wb("issue3.xlsm");
     let range = excel.worksheet_range("Sheet1").unwrap();
     range_eq!(range, [[Float(1.), String("a".to_string())]]);
 }
 
 #[test]
 fn issue_4() {
-    setup();
-
-    // test if sheet is resolved with only one row
-    let path = format!("{}/tests/issues.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsx<_> = wb("issues.xlsx");
     let range = excel.worksheet_range("issue5").unwrap();
     range_eq!(range, [[Float(0.5)]]);
 }
 
 #[test]
 fn issue_6() {
-    setup();
-
-    // test if sheet is resolved with only one row
-    let path = format!("{}/tests/issues.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsx<_> = wb("issues.xlsx");
     let range = excel.worksheet_range("issue6").unwrap();
     range_eq!(
         range,
@@ -96,11 +81,7 @@ fn issue_6() {
 
 #[test]
 fn error_file() {
-    setup();
-
-    let path = format!("{}/tests/errors.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsx<_> = wb("errors.xlsx");
     let range = excel.worksheet_range("Feuil1").unwrap();
     range_eq!(
         range,
@@ -118,11 +99,7 @@ fn error_file() {
 
 #[test]
 fn issue_9() {
-    setup();
-
-    let path = format!("{}/tests/issue9.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsx<_> = wb("issue9.xlsx");
     let range = excel.worksheet_range("Feuil1").unwrap();
     range_eq!(
         range,
@@ -137,11 +114,7 @@ fn issue_9() {
 
 #[test]
 fn vba() {
-    setup();
-
-    let path = format!("{}/tests/vba.xlsm", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsx<_> = wb("vba.xlsm");
     let mut vba = excel.vba_project().unwrap().unwrap();
     assert_eq!(
         vba.to_mut().get_module("testVBA").unwrap(),
@@ -152,11 +125,7 @@ fn vba() {
 
 #[test]
 fn xlsb() {
-    setup();
-
-    let path = format!("{}/tests/issues.xlsb", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsb<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsb<_> = wb("issues.xlsb");
     let range = excel.worksheet_range("issue2").unwrap();
     range_eq!(
         range,
@@ -170,11 +139,7 @@ fn xlsb() {
 
 #[test]
 fn xlsx() {
-    setup();
-
-    let path = format!("{}/tests/issues.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsx<_> = wb("issues.xlsx");
     let range = excel.worksheet_range("issue2").unwrap();
     range_eq!(
         range,
@@ -188,11 +153,7 @@ fn xlsx() {
 
 #[test]
 fn xls() {
-    setup();
-
-    let path = format!("{}/tests/issues.xls", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xls<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xls<_> = wb("issues.xls");
     let range = excel.worksheet_range("issue2").unwrap();
     range_eq!(
         range,
@@ -208,13 +169,7 @@ fn xls() {
 #[ignore]
 #[test]
 fn issue_195() {
-    setup();
-
-    let path = format!(
-        "{}/JLCPCB SMT Parts Library(20210204).xls",
-        env!("CARGO_MANIFEST_DIR")
-    );
-    let mut excel: Xls<_> = open_workbook(path).expect("can't open wb");
+    let mut excel: Xls<_> = wb("JLCPCB SMT Parts Library(20210204).xls");
     let range = excel
         .worksheet_range("JLCPCB SMT Parts Library")
         .expect("error in wks range");
@@ -223,11 +178,7 @@ fn issue_195() {
 
 #[test]
 fn ods() {
-    setup();
-
-    let path = format!("{}/tests/issues.ods", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Ods<_> = open_workbook(path).unwrap();
-
+    let mut excel: Ods<_> = wb("issues.ods");
     let range = excel.worksheet_range("datatypes").unwrap();
     range_eq!(
         range,
@@ -257,11 +208,7 @@ fn ods() {
 
 #[test]
 fn ods_covered() {
-    setup();
-
-    let path = format!("{}/tests/covered.ods", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Ods<_> = open_workbook(path).unwrap();
-
+    let mut excel: Ods<_> = wb("covered.ods");
     let range = excel.worksheet_range("sheet1").unwrap();
     range_eq!(
         range,
@@ -275,9 +222,7 @@ fn ods_covered() {
 
 #[test]
 fn special_cells() {
-    let path = format!("{}/tests/special_cells.ods", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Ods<_> = open_workbook(path).unwrap();
-
+    let mut excel: Ods<_> = wb("special_cells.ods");
     let range = excel.worksheet_range("sheet1").unwrap();
     range_eq!(
         range,
@@ -295,11 +240,7 @@ fn special_cells() {
 
 #[test]
 fn special_chrs_xlsx() {
-    setup();
-
-    let path = format!("{}/tests/issues.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsx<_> = wb("issues.xlsx");
     let range = excel.worksheet_range("spc_chrs").unwrap();
     range_eq!(
         range,
@@ -318,11 +259,7 @@ fn special_chrs_xlsx() {
 
 #[test]
 fn special_chrs_xlsb() {
-    setup();
-
-    let path = format!("{}/tests/issues.xlsb", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsb<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsb<_> = wb("issues.xlsb");
     let range = excel.worksheet_range("spc_chrs").unwrap();
     range_eq!(
         range,
@@ -341,11 +278,7 @@ fn special_chrs_xlsb() {
 
 #[test]
 fn special_chrs_ods() {
-    setup();
-
-    let path = format!("{}/tests/issues.ods", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Ods<_> = open_workbook(path).unwrap();
-
+    let mut excel: Ods<_> = wb("issues.ods");
     let range = excel.worksheet_range("spc_chrs").unwrap();
     range_eq!(
         range,
@@ -364,25 +297,14 @@ fn special_chrs_ods() {
 
 #[test]
 fn partial_richtext_ods() {
-    setup();
-
-    let path = format!("{}/tests/richtext_issue.ods", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Ods<_> = open_workbook(path).unwrap();
-
+    let mut excel: Ods<_> = wb("richtext_issue.ods");
     let range = excel.worksheet_range("datatypes").unwrap();
     range_eq!(range, [[String("abc".to_string())]]);
 }
 
 #[test]
 fn xlsx_richtext_namespaced() {
-    setup();
-
-    let path = format!(
-        "{}/tests/richtext-namespaced.xlsx",
-        env!("CARGO_MANIFEST_DIR")
-    );
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsx<_> = wb("richtext-namespaced.xlsx");
     let range = excel.worksheet_range("Sheet1").unwrap();
     range_eq!(
         range,
@@ -401,11 +323,7 @@ fn xlsx_richtext_namespaced() {
 
 #[test]
 fn defined_names_xlsx() {
-    setup();
-
-    let path = format!("{}/tests/issues.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let excel: Xlsx<_> = wb("issues.xlsx");
     let mut defined_names = excel.defined_names().to_vec();
     defined_names.sort();
     assert_eq!(
@@ -420,11 +338,7 @@ fn defined_names_xlsx() {
 
 #[test]
 fn defined_names_xlsb() {
-    setup();
-
-    let path = format!("{}/tests/issues.xlsb", env!("CARGO_MANIFEST_DIR"));
-    let excel: Xlsb<_> = open_workbook(path).unwrap();
-
+    let excel: Xlsb<_> = wb("issues.xlsb");
     let mut defined_names = excel.defined_names().to_vec();
     defined_names.sort();
     assert_eq!(
@@ -439,11 +353,7 @@ fn defined_names_xlsb() {
 
 #[test]
 fn defined_names_xls() {
-    setup();
-
-    let path = format!("{}/tests/issues.xls", env!("CARGO_MANIFEST_DIR"));
-    let excel: Xls<_> = open_workbook(path).unwrap();
-
+    let excel: Xls<_> = wb("issues.xls");
     let mut defined_names = excel.defined_names().to_vec();
     defined_names.sort();
     assert_eq!(
@@ -458,11 +368,7 @@ fn defined_names_xls() {
 
 #[test]
 fn defined_names_ods() {
-    setup();
-
-    let path = format!("{}/tests/issues.ods", env!("CARGO_MANIFEST_DIR"));
-    let excel: Ods<_> = open_workbook(path).unwrap();
-
+    let excel: Ods<_> = wb("issues.ods");
     let mut defined_names = excel.defined_names().to_vec();
     defined_names.sort();
     assert_eq!(
@@ -483,20 +389,12 @@ fn defined_names_ods() {
 
 #[test]
 fn parse_sheet_names_in_xls() {
-    setup();
-
-    let path = format!(
-        "{}/tests/sheet_name_parsing.xls",
-        env!("CARGO_MANIFEST_DIR")
-    );
-    let excel: Xls<_> = open_workbook(path).unwrap();
+    let excel: Xls<_> = wb("sheet_name_parsing.xls");
     assert_eq!(excel.sheet_names(), &["Sheet1"]);
 }
 
 #[test]
 fn read_xls_from_memory() {
-    setup();
-
     const DATA_XLS: &[u8] = include_bytes!("sheet_name_parsing.xls");
     let reader = Cursor::new(DATA_XLS);
     let excel = Xls::new(reader).unwrap();
@@ -505,10 +403,7 @@ fn read_xls_from_memory() {
 
 #[test]
 fn search_references() {
-    setup();
-
-    let path = format!("{}/tests/vba.xlsm", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
+    let mut excel: Xlsx<_> = wb("vba.xlsm");
     let vba = excel.vba_project().unwrap().unwrap();
     let references = vba.get_references();
     let names = references.iter().map(|r| &*r.name).collect::<Vec<&str>>();
@@ -517,11 +412,7 @@ fn search_references() {
 
 #[test]
 fn formula_xlsx() {
-    setup();
-
-    let path = format!("{}/tests/issues.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsx<_> = wb("issues.xlsx");
     let sheets = excel.sheet_names().to_owned();
     for s in sheets {
         let _ = excel.worksheet_formula(&s).unwrap();
@@ -533,11 +424,7 @@ fn formula_xlsx() {
 
 #[test]
 fn formula_xlsb() {
-    setup();
-
-    let path = format!("{}/tests/issues.xlsb", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsb<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsb<_> = wb("issues.xlsb");
     let sheets = excel.sheet_names().to_owned();
     for s in sheets {
         let _ = excel.worksheet_formula(&s).unwrap();
@@ -549,11 +436,7 @@ fn formula_xlsb() {
 
 #[test]
 fn formula_vals_xlsb() {
-    setup();
-
-    let path = format!("{}/tests/issue_182.xlsb", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsb<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsb<_> = wb("issue_182.xlsb");
     let range = excel.worksheet_range("formula_vals").unwrap();
     range_eq!(
         range,
@@ -563,11 +446,7 @@ fn formula_vals_xlsb() {
 
 #[test]
 fn float_vals_xlsb() {
-    setup();
-
-    let path = format!("{}/tests/issue_186.xlsb", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsb<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xlsb<_> = wb("issue_186.xlsb");
     let range = excel.worksheet_range("Sheet1").unwrap();
     range_eq!(
         range,
@@ -583,11 +462,7 @@ fn float_vals_xlsb() {
 
 #[test]
 fn formula_xls() {
-    setup();
-
-    let path = format!("{}/tests/issues.xls", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xls<_> = open_workbook(path).unwrap();
-
+    let mut excel: Xls<_> = wb("issues.xls");
     let sheets = excel.sheet_names().to_owned();
     for s in sheets {
         let _ = excel.worksheet_formula(&s).unwrap();
@@ -599,25 +474,17 @@ fn formula_xls() {
 
 #[test]
 fn formula_ods() {
-    setup();
-
-    let path = format!("{}/tests/issues.ods", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Ods<_> = open_workbook(path).unwrap();
-
+    let mut excel: Ods<_> = wb("issues.ods");
     for s in excel.sheet_names() {
         let _ = excel.worksheet_formula(&s).unwrap();
     }
-
     let formula = excel.worksheet_formula("Sheet1").unwrap();
     range_eq!(formula, [["of:=[.B1]+$$OneRange".to_string()]]);
 }
 
 #[test]
 fn empty_sheet() {
-    setup();
-
-    let path = format!("{}/tests/empty_sheet.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
+    let mut excel: Xlsx<_> = wb("empty_sheet.xlsx");
     for s in excel.sheet_names() {
         let range = excel.worksheet_range(&s).unwrap();
         assert_eq!(range.start(), None, "wrong start");
@@ -628,10 +495,7 @@ fn empty_sheet() {
 
 #[test]
 fn issue_120() {
-    setup();
-
-    let path = format!("{}/tests/issues.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
+    let mut excel: Xlsx<_> = wb("issues.xlsx");
 
     let range = excel.worksheet_range("issue2").unwrap();
     let end = range.end().unwrap();
@@ -645,8 +509,6 @@ fn issue_120() {
 
 #[test]
 fn issue_127() {
-    setup();
-
     let root = env!("CARGO_MANIFEST_DIR");
     let ordered_names: Vec<std::string::String> = [
         "Sheet1", "Sheet2", "Sheet3", "Sheet4", "Sheet5", "Sheet6", "Sheet7", "Sheet8",
@@ -669,23 +531,14 @@ fn issue_127() {
 
 #[test]
 fn mul_rk() {
-    setup();
-
-    let path = format!(
-        "{}/tests/adhocallbabynames1996to2016.xls",
-        env!("CARGO_MANIFEST_DIR")
-    );
-    let mut xls: Xls<_> = open_workbook(path).unwrap();
+    let mut xls: Xls<_> = wb("adhocallbabynames1996to2016.xls");
     let range = xls.worksheet_range("Boys").unwrap();
     assert_eq!(range.get_value((6, 2)), Some(&Float(9.)));
 }
 
 #[test]
 fn skip_phonetic_text() {
-    setup();
-
-    let path = format!("{}/tests/rph.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut xls: Xlsx<_> = open_workbook(path).unwrap();
+    let mut xls: Xlsx<_> = wb("rph.xlsx");
     let range = xls.worksheet_range("Sheet1").unwrap();
     assert_eq!(
         range.get_value((0, 0)),
@@ -695,21 +548,13 @@ fn skip_phonetic_text() {
 
 #[test]
 fn issue_174() {
-    setup();
-
-    let path = format!("{}/tests/issue_174.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut xls: Xlsx<_> = open_workbook(path).unwrap();
+    let mut xls: Xlsx<_> = wb("issue_174.xlsx");
     xls.worksheet_range_at(0).unwrap().unwrap();
 }
 
 #[test]
 fn table() {
-    setup();
-    let path = format!(
-        "{}/tests/temperature-table.xlsx",
-        env!("CARGO_MANIFEST_DIR")
-    );
-    let mut xls: Xlsx<_> = open_workbook(path).unwrap();
+    let mut xls: Xlsx<_> = wb("temperature-table.xlsx");
     xls.load_tables().unwrap();
     let table_names = xls.table_names();
     assert_eq!(table_names[0], "Temperature");
@@ -742,10 +587,7 @@ fn table() {
 
 #[test]
 fn date_xls() {
-    setup();
-
-    let path = format!("{}/tests/date.xls", env!("CARGO_MANIFEST_DIR"));
-    let mut xls: Xls<_> = open_workbook(path).unwrap();
+    let mut xls: Xls<_> = wb("date.xls");
     let range = xls.worksheet_range_at(0).unwrap().unwrap();
 
     assert_eq!(
@@ -780,10 +622,7 @@ fn date_xls() {
 
 #[test]
 fn date_xls_1904() {
-    setup();
-
-    let path = format!("{}/tests/date_1904.xls", env!("CARGO_MANIFEST_DIR"));
-    let mut xls: Xls<_> = open_workbook(path).unwrap();
+    let mut xls: Xls<_> = wb("date_1904.xls");
     let range = xls.worksheet_range_at(0).unwrap().unwrap();
 
     assert_eq!(
@@ -818,10 +657,7 @@ fn date_xls_1904() {
 
 #[test]
 fn date_xlsx() {
-    setup();
-
-    let path = format!("{}/tests/date.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut xls: Xlsx<_> = open_workbook(path).unwrap();
+    let mut xls: Xlsx<_> = wb("date.xlsx");
     let range = xls.worksheet_range_at(0).unwrap().unwrap();
 
     assert_eq!(
@@ -856,10 +692,7 @@ fn date_xlsx() {
 
 #[test]
 fn date_xlsx_1904() {
-    setup();
-
-    let path = format!("{}/tests/date_1904.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut xls: Xlsx<_> = open_workbook(path).unwrap();
+    let mut xls: Xlsx<_> = wb("date_1904.xlsx");
     let range = xls.worksheet_range_at(0).unwrap().unwrap();
 
     assert_eq!(
@@ -894,10 +727,7 @@ fn date_xlsx_1904() {
 
 #[test]
 fn date_xlsx_iso() {
-    setup();
-
-    let path = format!("{}/tests/date_iso.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut xls: Xlsx<_> = open_workbook(path).unwrap();
+    let mut xls: Xlsx<_> = wb("date_iso.xlsx");
     let range = xls.worksheet_range_at(0).unwrap().unwrap();
 
     assert_eq!(
@@ -937,10 +767,7 @@ fn date_xlsx_iso() {
 
 #[test]
 fn date_ods() {
-    setup();
-
-    let path = format!("{}/tests/date.ods", env!("CARGO_MANIFEST_DIR"));
-    let mut ods: Ods<_> = open_workbook(path).unwrap();
+    let mut ods: Ods<_> = wb("date.ods");
     let range = ods.worksheet_range_at(0).unwrap().unwrap();
 
     assert_eq!(
@@ -988,10 +815,7 @@ fn date_ods() {
 
 #[test]
 fn date_xlsb() {
-    setup();
-
-    let path = format!("{}/tests/date.xlsb", env!("CARGO_MANIFEST_DIR"));
-    let mut xls: Xlsb<_> = open_workbook(path).unwrap();
+    let mut xls: Xlsb<_> = wb("date.xlsb");
     let range = xls.worksheet_range_at(0).unwrap().unwrap();
 
     assert_eq!(
@@ -1026,10 +850,7 @@ fn date_xlsb() {
 
 #[test]
 fn date_xlsb_1904() {
-    setup();
-
-    let path = format!("{}/tests/date_1904.xlsb", env!("CARGO_MANIFEST_DIR"));
-    let mut xls: Xlsb<_> = open_workbook(path).unwrap();
+    let mut xls: Xlsb<_> = wb("date_1904.xlsb");
     let range = xls.worksheet_range_at(0).unwrap().unwrap();
 
     assert_eq!(
@@ -1064,20 +885,13 @@ fn date_xlsb_1904() {
 
 #[test]
 fn issue_219() {
-    setup();
-
-    let path = format!("{}/tests/issue219.xls", env!("CARGO_MANIFEST_DIR"));
-
     // should not panic
-    let _: Xls<_> = open_workbook(path).unwrap();
+    let _: Xls<_> = wb("issue219.xls");
 }
 
 #[test]
 fn issue_221() {
-    setup();
-
-    let path = format!("{}/tests/issue221.xlsm", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
+    let mut excel: Xlsx<_> = wb("issue221.xlsm");
 
     let range = excel.worksheet_range("Sheet1").unwrap();
     range_eq!(
@@ -1093,8 +907,7 @@ fn issue_221() {
 fn merged_regions_xlsx() {
     use calamine::Dimensions;
     use std::string::String;
-    let path = format!("{}/tests/merged_range.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
+    let mut excel: Xlsx<_> = wb("merged_range.xlsx");
     excel.load_merged_regions().unwrap();
     assert_eq!(
         excel
@@ -1283,9 +1096,7 @@ fn merged_regions_xlsx() {
 
 #[test]
 fn issue_252() {
-    setup();
-
-    let path = format!("{}/tests/issue252.xlsx", env!("CARGO_MANIFEST_DIR"));
+    let path = format!("issue252.xlsx");
 
     // should err, not panic
     assert!(open_workbook::<Xls<_>, _>(&path).is_err());
@@ -1293,20 +1104,8 @@ fn issue_252() {
 
 #[test]
 fn issue_261() {
-    setup();
-
-    let mut workbook_with_missing_r_attributes = {
-        let path = format!("{}/tests/issue_261.xlsx", env!("CARGO_MANIFEST_DIR"));
-        open_workbook::<Xlsx<_>, _>(&path).unwrap()
-    };
-
-    let mut workbook_fixed_by_excel = {
-        let path = format!(
-            "{}/tests/issue_261_fixed_by_excel.xlsx",
-            env!("CARGO_MANIFEST_DIR")
-        );
-        open_workbook::<Xlsx<_>, _>(&path).unwrap()
-    };
+    let mut workbook_with_missing_r_attributes: Xlsx<_> = wb("issue_261.xlsx");
+    let mut workbook_fixed_by_excel: Xlsx<_> = wb("issue_261_fixed_by_excel.xlsx");
 
     let range_a = workbook_fixed_by_excel
         .worksheet_range("Some Sheet")
@@ -1361,11 +1160,7 @@ fn issue_261() {
 
 #[test]
 fn test_values_xls() {
-    let path = format!(
-        "{}/tests/xls_wrong_decimals.xls",
-        env!("CARGO_MANIFEST_DIR")
-    );
-    let mut excel: Xls<_> = open_workbook(path).unwrap();
+    let mut excel: Xls<_> = wb("xls_wrong_decimals.xls");
     let range = excel
         .worksheet_range_at(0)
         .unwrap()
@@ -1379,8 +1174,7 @@ fn issue_271() -> Result<(), calamine::Error> {
     let mut count = 0;
     let mut values = Vec::new();
     loop {
-        let path = format!("{}/tests/issue_271.xls", env!("CARGO_MANIFEST_DIR"));
-        let mut workbook: Xls<_> = open_workbook(path)?;
+        let mut workbook: Xls<_> = wb("issue_271.xls");
         let v = workbook.worksheets();
         let (_sheetname, range) = v.first().expect("bad format");
         dbg!(_sheetname);
@@ -1404,8 +1198,7 @@ fn issue_271() -> Result<(), calamine::Error> {
 
 #[test]
 fn issue_305_merge_cells() {
-    let path = format!("{}/tests/merge_cells.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
+    let mut excel: Xlsx<_> = wb("merge_cells.xlsx");
     let merge_cells = excel.worksheet_merge_cells_at(0).unwrap().unwrap();
 
     assert_eq!(
@@ -1420,8 +1213,7 @@ fn issue_305_merge_cells() {
 
 #[test]
 fn issue_305_merge_cells_xls() {
-    let path = format!("{}/tests/merge_cells.xls", env!("CARGO_MANIFEST_DIR"));
-    let excel: Xls<_> = open_workbook(path).unwrap();
+    let excel: Xls<_> = wb("merge_cells.xls");
     let merge_cells = excel.worksheet_merge_cells_at(0).unwrap();
 
     assert_eq!(
@@ -1438,21 +1230,21 @@ fn issue_305_merge_cells_xls() {
 #[test]
 #[cfg(feature = "picture")]
 fn pictures() -> Result<(), calamine::Error> {
-    let jpg_path = format!("{}/tests/picture.jpg", env!("CARGO_MANIFEST_DIR"));
-    let png_path = format!("{}/tests/picture.png", env!("CARGO_MANIFEST_DIR"));
+    let jpg_path = format!("picture.jpg");
+    let png_path = format!("picture.png");
 
-    let xlsx_path = format!("{}/tests/picture.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let xlsb_path = format!("{}/tests/picture.xlsb", env!("CARGO_MANIFEST_DIR"));
-    let xls_path = format!("{}/tests/picture.xls", env!("CARGO_MANIFEST_DIR"));
-    let ods_path = format!("{}/tests/picture.ods", env!("CARGO_MANIFEST_DIR"));
+    let xlsx_path = format!("picture.xlsx");
+    let xlsb_path = format!("picture.xlsb");
+    let xls_path = format!("picture.xls");
+    let ods_path = format!("picture.ods");
 
     let jpg_hash = sha256::digest(&*std::fs::read(&jpg_path)?);
     let png_hash = sha256::digest(&*std::fs::read(&png_path)?);
 
-    let xlsx: Xlsx<_> = open_workbook(xlsx_path)?;
-    let xlsb: Xlsb<_> = open_workbook(xlsb_path)?;
-    let xls: Xls<_> = open_workbook(xls_path)?;
-    let ods: Ods<_> = open_workbook(ods_path)?;
+    let xlsx: Xlsx<_> = wb(xlsx_path)?;
+    let xlsb: Xlsb<_> = wb(xlsb_path)?;
+    let xls: Xls<_> = wb(xls_path)?;
+    let ods: Ods<_> = wb(ods_path)?;
 
     let mut pictures = Vec::with_capacity(8);
     let mut pass = 0;
@@ -1485,10 +1277,7 @@ fn pictures() -> Result<(), calamine::Error> {
 
 #[test]
 fn ods_merged_cells() {
-    setup();
-
-    let path = format!("{}/tests/merged_cells.ods", env!("CARGO_MANIFEST_DIR"));
-    let mut ods: Ods<_> = open_workbook(path).unwrap();
+    let mut ods: Ods<_> = wb("merged_cells.ods");
     let range = ods.worksheet_range_at(0).unwrap().unwrap();
 
     range_eq!(
@@ -1511,13 +1300,7 @@ fn ods_merged_cells() {
 
 #[test]
 fn ods_number_rows_repeated() {
-    setup();
-
-    let path = format!(
-        "{}/tests/number_rows_repeated.ods",
-        env!("CARGO_MANIFEST_DIR")
-    );
-    let mut ods: Ods<_> = open_workbook(path).unwrap();
+    let mut ods: Ods<_> = wb("number_rows_repeated.ods");
     let test_cropped_range = [
         [String("A".to_string()), String("B".to_string())],
         [String("C".to_string()), String("D".to_string())],
@@ -1590,9 +1373,7 @@ fn ods_number_rows_repeated() {
 
 #[test]
 fn issue304_xls_formula() {
-    setup();
-    let path = format!("{}/tests/xls_formula.xls", env!("CARGO_MANIFEST_DIR"));
-    let mut wb: Xls<_> = open_workbook(path).unwrap();
+    let mut wb: Xls<_> = wb("xls_formula.xls");
     let formula = wb.worksheet_formula("Sheet1").unwrap();
     let mut rows = formula.rows();
     assert_eq!(rows.next(), Some(&["A1*2".to_owned()][..]));
@@ -1603,9 +1384,7 @@ fn issue304_xls_formula() {
 
 #[test]
 fn issue304_xls_values() {
-    setup();
-    let path = format!("{}/tests/xls_formula.xls", env!("CARGO_MANIFEST_DIR"));
-    let mut wb: Xls<_> = open_workbook(path).unwrap();
+    let mut wb: Xls<_> = wb("xls_formula.xls");
     let rge = wb.worksheet_range("Sheet1").unwrap();
     let mut rows = rge.rows();
     assert_eq!(rows.next(), Some(&[Data::Float(10.)][..]));
@@ -1617,9 +1396,7 @@ fn issue304_xls_values() {
 
 #[test]
 fn issue334_xls_values_string() {
-    setup();
-    let path = format!("{}/tests/xls_ref_String.xls", env!("CARGO_MANIFEST_DIR"));
-    let mut wb: Xls<_> = open_workbook(path).unwrap();
+    let mut wb: Xls<_> = wb("xls_ref_String.xls");
     let rge = wb.worksheet_range("Sheet1").unwrap();
     let mut rows = rge.rows();
     assert_eq!(rows.next(), Some(&[Data::String("aa".into())][..]));
@@ -1631,10 +1408,7 @@ fn issue334_xls_values_string() {
 
 #[test]
 fn issue281_vba() {
-    setup();
-
-    let path = format!("{}/tests/issue281.xlsm", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
+    let mut excel: Xlsx<_> = wb("issue281.xlsm");
 
     let mut vba = excel.vba_project().unwrap().unwrap();
     assert_eq!(
@@ -1646,20 +1420,13 @@ fn issue281_vba() {
 
 #[test]
 fn issue343() {
-    setup();
-
-    let path = format!("{}/tests/issue343.xls", env!("CARGO_MANIFEST_DIR"));
-
     // should not panic
-    let _: Xls<_> = open_workbook(path).unwrap();
+    let _: Xls<_> = wb("issue343.xls");
 }
 
 #[test]
 fn any_sheets_xlsx() {
-    setup();
-
-    let path = format!("{}/tests/any_sheets.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let workbook: Xlsx<_> = open_workbook(path).unwrap();
+    let workbook: Xlsx<_> = wb("any_sheets.xlsx");
 
     assert_eq!(
         workbook.sheets_metadata(),
@@ -1690,10 +1457,7 @@ fn any_sheets_xlsx() {
 
 #[test]
 fn any_sheets_xlsb() {
-    setup();
-
-    let path = format!("{}/tests/any_sheets.xlsb", env!("CARGO_MANIFEST_DIR"));
-    let workbook: Xlsb<_> = open_workbook(path).unwrap();
+    let workbook: Xlsb<_> = wb("any_sheets.xlsb");
 
     assert_eq!(
         workbook.sheets_metadata(),
@@ -1724,10 +1488,7 @@ fn any_sheets_xlsb() {
 
 #[test]
 fn any_sheets_xls() {
-    setup();
-
-    let path = format!("{}/tests/any_sheets.xls", env!("CARGO_MANIFEST_DIR"));
-    let workbook: Xls<_> = open_workbook(path).unwrap();
+    let workbook: Xls<_> = wb("any_sheets.xls");
 
     assert_eq!(
         workbook.sheets_metadata(),
@@ -1758,10 +1519,7 @@ fn any_sheets_xls() {
 
 #[test]
 fn any_sheets_ods() {
-    setup();
-
-    let path = format!("{}/tests/any_sheets.ods", env!("CARGO_MANIFEST_DIR"));
-    let workbook: Ods<_> = open_workbook(path).unwrap();
+    let workbook: Ods<_> = wb("any_sheets.ods");
 
     assert_eq!(
         workbook.sheets_metadata(),
@@ -1794,10 +1552,7 @@ fn any_sheets_ods() {
 
 #[test]
 fn issue_102() {
-    setup();
-
     let path = format!("{}/tests/pass_protected.xlsx", env!("CARGO_MANIFEST_DIR"));
-
     assert!(
         matches!(
             open_workbook::<Xlsx<_>, std::string::String>(path),
@@ -1809,8 +1564,7 @@ fn issue_102() {
 
 #[test]
 fn issue_374() {
-    let path = format!("{}/tests/biff5_write.xls", env!("CARGO_MANIFEST_DIR"));
-    let mut workbook: Xls<_> = open_workbook(path).unwrap();
+    let mut workbook: Xls<_> = wb("biff5_write.xls");
 
     let first_sheet_name = workbook.sheet_names().first().unwrap().to_owned();
 
@@ -1826,7 +1580,6 @@ fn issue_374() {
 #[test]
 fn issue_385() {
     let path = format!("{}/tests/issue_385.xls", env!("CARGO_MANIFEST_DIR"));
-
     assert!(
         matches!(
             open_workbook::<Xls<_>, std::string::String>(path),
@@ -1839,7 +1592,6 @@ fn issue_385() {
 #[test]
 fn pass_protected_xlsb() {
     let path = format!("{}/tests/pass_protected.xlsb", env!("CARGO_MANIFEST_DIR"));
-
     assert!(
         matches!(
             open_workbook::<Xlsb<_>, std::string::String>(path),
@@ -1852,7 +1604,6 @@ fn pass_protected_xlsb() {
 #[test]
 fn pass_protected_ods() {
     let path = format!("{}/tests/pass_protected.ods", env!("CARGO_MANIFEST_DIR"));
-
     assert!(
         matches!(
             open_workbook::<Ods<_>, std::string::String>(path),
@@ -1864,8 +1615,7 @@ fn pass_protected_ods() {
 
 #[test]
 fn issue_384_multiple_formula() {
-    let path = format!("{}/tests/formula.issue.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut workbook: Xlsx<_> = open_workbook(path).unwrap();
+    let mut workbook: Xlsx<_> = wb("formula.issue.xlsx");
 
     // first check values
     let range = workbook.worksheet_range("Sheet1").unwrap();
@@ -1902,10 +1652,7 @@ fn issue_384_multiple_formula() {
 
 #[test]
 fn issue_401_empty_tables() {
-    setup();
-
-    let path = format!("{}/tests/date.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
+    let mut excel: Xlsx<_> = wb("date.xlsx");
     excel.load_tables().unwrap();
     let tables = excel.table_names();
     assert!(tables.is_empty());
@@ -1913,10 +1660,7 @@ fn issue_401_empty_tables() {
 
 #[test]
 fn issue_391_shared_formula() {
-    setup();
-
-    let path = format!("{}/tests/issue_391.xlsx", env!("CARGO_MANIFEST_DIR"));
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
+    let mut excel: Xlsx<_> = wb("issue_391.xlsx");
     let mut expect = Range::<std::string::String>::new((1, 0), (6, 0));
     for (i, cell) in ["A1+1", "A2+1", "A3+1", "A4+1", "A5+1", "A6+1"]
         .iter()
@@ -1932,13 +1676,7 @@ fn issue_391_shared_formula() {
 
 #[test]
 fn issue_420_empty_s_attribute() {
-    setup();
-
-    let path = format!(
-        "{}/tests/empty_s_attribute.xlsx",
-        env!("CARGO_MANIFEST_DIR")
-    );
-    let mut excel: Xlsx<_> = open_workbook(path).unwrap();
+    let mut excel: Xlsx<_> = wb("empty_s_attribute.xlsx");
 
     let range = excel.worksheet_range("Sheet1").unwrap();
     range_eq!(

From c1fe87616ef3f9e31f46b8ae3487e01ec932706b Mon Sep 17 00:00:00 2001
From: Johann Tuffe <tafia973@gmail.com>
Date: Mon, 8 Jul 2024 23:26:43 +0800
Subject: [PATCH 2/3] add failing test

---
 tests/issue446.xlsx | Bin 0 -> 9770 bytes
 tests/test.rs       |   6 ++++++
 2 files changed, 6 insertions(+)
 create mode 100644 tests/issue446.xlsx

diff --git a/tests/issue446.xlsx b/tests/issue446.xlsx
new file mode 100644
index 0000000000000000000000000000000000000000..86584fc30b4e9aaa54dfda6b6fbaa84ade4b0098
GIT binary patch
literal 9770
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
M39k5BbU*L@54{~1P5=M^

literal 0
HcmV?d00001

diff --git a/tests/test.rs b/tests/test.rs
index 81f3465c..5cd84042 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -1690,3 +1690,9 @@ fn issue_420_empty_s_attribute() {
         ]
     );
 }
+
+#[test]
+fn isssue_446_formulas() {
+    let mut excel: Xlsx<_> = wb("issue446.xlsx");
+    let _ = excel.worksheet_formula("Sheet1").unwrap(); // should not fail
+}

From 4dc9d3627c4ade1a4f768724d7e9c268b767fbcd Mon Sep 17 00:00:00 2001
From: Johann Tuffe <tafia973@gmail.com>
Date: Tue, 9 Jul 2024 00:15:21 +0800
Subject: [PATCH 3/3] remove value_cell_name fn for a simple match on
 offset_cell_name result

---
 src/xlsx/mod.rs | 50 +++++++++++--------------------------------------
 1 file changed, 11 insertions(+), 39 deletions(-)

diff --git a/src/xlsx/mod.rs b/src/xlsx/mod.rs
index 3a470829..de42bfff 100644
--- a/src/xlsx/mod.rs
+++ b/src/xlsx/mod.rs
@@ -1076,6 +1076,9 @@ fn get_row_and_optional_column(range: &[u8]) -> Result<(u32, Option<u32>), XlsxE
             }
             c @ b'A'..=b'Z' => {
                 if readrow {
+                    if row == 0 {
+                        return Err(XlsxError::RangeWithoutRowComponent);
+                    }
                     pow = 1;
                     readrow = false;
                 }
@@ -1084,6 +1087,9 @@ fn get_row_and_optional_column(range: &[u8]) -> Result<(u32, Option<u32>), XlsxE
             }
             c @ b'a'..=b'z' => {
                 if readrow {
+                    if row == 0 {
+                        return Err(XlsxError::RangeWithoutRowComponent);
+                    }
                     pow = 1;
                     readrow = false;
                 }
@@ -1196,42 +1202,8 @@ fn read_merge_cells(xml: &mut XlReader<'_>) -> Result<Vec<Dimensions>, XlsxError
     Ok(merge_cells)
 }
 
-/// check if a char vector is a valid cell name  
-/// column name must be between A and XFD,
-/// last char must be digit
-fn valid_cell_name(name: &[char]) -> bool {
-    if name.is_empty() {
-        return false;
-    }
-    if name.len() < 2 {
-        return false;
-    }
-    if name.len() > 3 {
-        if name[3].is_ascii_alphabetic() {
-            return false;
-        }
-        if name[2].is_alphabetic() {
-            if "YZ".contains(name[0]) {
-                return false;
-            } else if name[0] == 'X' {
-                if name[1] == 'F' {
-                    if !"ABCD".contains(name[2]) {
-                        return false;
-                    };
-                } else if !"ABCDE".contains(name[1]) {
-                    return false;
-                }
-            }
-        }
-    }
-    match name.last() {
-        Some(c) => c.is_ascii_digit(),
-        _ => false,
-    }
-}
-
 /// advance the cell name by the offset
-fn replace_cell(name: &[char], offset: (i64, i64)) -> Result<Vec<u8>, XlsxError> {
+fn offset_cell_name(name: &[char], offset: (i64, i64)) -> Result<Vec<u8>, XlsxError> {
     let cell = get_row_column(name.iter().map(|c| *c as u8).collect::<Vec<_>>().as_slice())?;
     coordinate_to_name((
         (cell.0 as i64 + offset.0) as u32,
@@ -1265,8 +1237,8 @@ fn replace_cell_names(s: &str, offset: (i64, i64)) -> Result<String, XlsxError>
             is_cell_row = true;
             cell.push(c);
         } else {
-            if valid_cell_name(cell.as_ref()) {
-                res.extend(replace_cell(cell.as_ref(), offset)?);
+            if let Ok(cell_name) = offset_cell_name(cell.as_ref(), offset) {
+                res.extend(cell_name);
             } else {
                 res.extend(cell.iter().map(|c| *c as u8));
             }
@@ -1276,8 +1248,8 @@ fn replace_cell_names(s: &str, offset: (i64, i64)) -> Result<String, XlsxError>
         }
     }
     if !cell.is_empty() {
-        if valid_cell_name(cell.as_ref()) {
-            res.extend(replace_cell(cell.as_ref(), offset)?);
+        if let Ok(cell_name) = offset_cell_name(cell.as_ref(), offset) {
+            res.extend(cell_name);
         } else {
             res.extend(cell.iter().map(|c| *c as u8));
         }