test/MiniExcel
1
0
Fork 0
mirror of https://gitee.com/dotnetchina/MiniExcel.git synced 2024-11-29 18:38:08 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
master
MiniExcel/tests/MiniExcelTests/MiniExcelIssueTests.cs
Nikolai Norum Hansen 29d4ee8af8
Fix dimension writing in FastMode (#659) 
* Add tests for fast mode

* Fix dimension writing in FastMode
2024-08-25 15:59:32 +08:00

3815 lines
156 KiB
C#
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

using Dapper;
using MiniExcelLibs.Attributes;
using MiniExcelLibs.Csv;
using MiniExcelLibs.Exceptions;
using MiniExcelLibs.OpenXml;
using MiniExcelLibs.Tests.Utils;
using Newtonsoft.Json;
using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
using OfficeOpenXml;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.SQLite;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Xunit;
using Xunit.Abstractions;
using static MiniExcelLibs.Tests.MiniExcelOpenXmlTests;
namespace MiniExcelLibs.Tests
{
public partial class MiniExcelIssueTests
{
private readonly ITestOutputHelper output;
public MiniExcelIssueTests(ITestOutputHelper output)
{
this.output = output;
}
/// <summary>
/// https://github.com/mini-software/MiniExcel/issues/549
/// </summary>
[Fact]
public void TestIssue549()
{
var data = new[] {
new{id=1,name="jack"},
new{id=2,name="mike"},
};
var path = Path.GetTempPath() + Guid.NewGuid() + ".xlsx";
MiniExcel.SaveAs(path, data);
var rows = MiniExcel.Query(path,true).ToList();
{
using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read))
{
XSSFWorkbook workbook = new XSSFWorkbook(stream);
ISheet sheet = workbook.GetSheetAt(0);
var a2 = sheet.GetRow(1).GetCell(0);
var b2 = sheet.GetRow(1).GetCell(1);
Assert.Equal((string)rows[0].id.ToString(), a2.NumericCellValue.ToString());
Assert.Equal((string)rows[0].name.ToString(), b2.StringCellValue);
}
}
}
[Fact]
public void TestIssue24020201()
{
{
var path = PathHelper.GetTempFilePath();
var templatePath = PathHelper.GetFile("xlsx/TestIssue24020201.xlsx");
var data = new Dictionary<string, object>()
{
["title"] = "This's title",
["B"] = new List<Dictionary<string, object>>()
{
new Dictionary<string, object>(){ { "specialMark", 1 } },
new Dictionary<string, object>(){ { "specialMark", 2 } },
new Dictionary<string, object>(){ { "specialMark", 3 } },
}
};
MiniExcel.SaveAsByTemplate(path, templatePath, data);
}
}
[Fact]
public void TestIssue553()
{
var path = PathHelper.GetTempFilePath();
var templatePath = PathHelper.GetFile("xlsx/TestIssue553.xlsx");
var data = new
{
B = new[] {
new{ ITM=1 },new{ ITM=2 }, new{ ITM=3 },
}
};
MiniExcel.SaveAsByTemplate(path, templatePath, data);
}
[Fact]
public void TestPR10()
{
var path = PathHelper.GetFile("csv/TestIssue142.csv");
var config = new CsvConfiguration()
{
SplitFn = (row) => Regex.Split(row, $"[\t,](?=(?:[^\"]|\"[^\"]*\")*$)")
.Select(s => Regex.Replace(s.Replace("\"\"", "\""), "^\"|\"$", "")).ToArray()
};
var rows = MiniExcel.Query(path, configuration: config).ToList();
}
[Fact]
public void TestIssue289()
{
var path = PathHelper.GetTempFilePath();
var value = new[] {
new Issue289Dto { Name="0001", UserType=Issue289Type.V1 },
new Issue289Dto { Name="0002", UserType=Issue289Type.V2 },
new Issue289Dto { Name="0003", UserType=Issue289Type.V3 },
};
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query<Issue289Dto>(path).ToList();
Assert.Equal(Issue289Type.V1, rows[0].UserType);
Assert.Equal(Issue289Type.V2, rows[1].UserType);
Assert.Equal(Issue289Type.V3, rows[2].UserType);
}
public class Issue289Dto
{
public string Name { get; set; }
public Issue289Type UserType { get; set; }
}
public enum Issue289Type
{
[Description("General User")]
V1,
[Description("General Administrator")]
V2,
[Description("Super Administrator")]
V3
}
/// <summary>
/// https://gitee.com/dotnetchina/MiniExcel/issues/I4X92G
/// </summary>
[Fact]
public void TestIssueI4X92G()
{
var path = PathHelper.GetTempFilePath("csv");
{
var value = new[] {
new { ID=1,Name ="Jack",InDate=new DateTime(2021,01,03)},
new { ID=2,Name ="Henry",InDate=new DateTime(2020,05,03)},
};
MiniExcel.SaveAs(path, value);
var content = File.ReadAllText(path);
Assert.Contains(@"ID,Name,InDate
1,Jack,""2021-01-03 00:00:00""
2,Henry,""2020-05-03 00:00:00""
", content);
}
{
var value = new { ID = 3, Name = "Mike", InDate = new DateTime(2021, 04, 23) };
MiniExcel.Insert(path, value);
var content = File.ReadAllText(path);
Assert.Equal(@"ID,Name,InDate
1,Jack,""2021-01-03 00:00:00""
2,Henry,""2020-05-03 00:00:00""
3,Mike,""2021-04-23 00:00:00""
", content);
}
{
var value = new[] {
new { ID=4,Name ="Frank",InDate=new DateTime(2021,06,07)},
new { ID=5,Name ="Gloria",InDate=new DateTime(2022,05,03)},
};
MiniExcel.Insert(path, value);
var content = File.ReadAllText(path);
Assert.Equal(@"ID,Name,InDate
1,Jack,""2021-01-03 00:00:00""
2,Henry,""2020-05-03 00:00:00""
3,Mike,""2021-04-23 00:00:00""
4,Frank,""2021-06-07 00:00:00""
5,Gloria,""2022-05-03 00:00:00""
", content);
}
}
/// <summary>
/// Exception : MiniExcelLibs.Exceptions.ExcelInvalidCastException: 'ColumnName : Date, CellRow : 2, Value : 2021-01-31 10:03:00 +08:00, it can't cast to DateTimeOffset type.'
/// </summary>
[Fact]
public void TestIssue430()
{
var outputPath = PathHelper.GetTempFilePath();
var value = new[] {
new TestIssue430Dto{ Date=DateTimeOffset.Parse("2021-01-31 10:03:00 +05:00")}
};
MiniExcel.SaveAs(outputPath, value);
var rows = MiniExcel.Query<TestIssue430Dto>(outputPath).ToArray();
Assert.Equal("2021-01-31 10:03:00 +05:00", rows[0].Date.ToString("yyyy-MM-dd HH:mm:ss zzz"));
}
public class TestIssue430Dto
{
[ExcelFormat("yyyy-MM-dd HH:mm:ss zzz")]
public DateTimeOffset Date { get; set; }
}
[Fact]
public void TestIssue_DataReaderSupportDimension()
{
{
DataTable table = new DataTable();
{
table.Columns.Add("id", typeof(int));
table.Columns.Add("name", typeof(string));
table.Rows.Add(1, "Jack");
table.Rows.Add(2, "Mike");
}
var path = Path.GetTempPath() + Guid.NewGuid() + ".xlsx";
DataTableReader reader = table.CreateDataReader();
var config = new OpenXmlConfiguration() { FastMode = true };
MiniExcel.SaveAs(path, reader, configuration: config);
var xml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
Assert.Contains("<x:autoFilter ref=\"A1:B3\" />", xml);
Assert.Contains("<x:dimension ref=\"A1:B3\" />", xml);
}
}
/// <summary>
/// [ · Issue #413 · MiniExcel/MiniExcel]
/// (https://github.com/MiniExcel/MiniExcel/issues/413)
/// </summary>
[Fact]
public void TestIssue413()
{
var path = PathHelper.GetTempFilePath();
var value = new
{
list = new List<Dictionary<string, object>>{
new Dictionary<string, object>{ { "id","001"},{ "time",new DateTime(2022,12,25)} },
new Dictionary<string, object>{ { "id","002"},{ "time",new DateTime(2022,9,23)} },
}
};
var templatePath = PathHelper.GetFile("xlsx/TestIssue413.xlsx");
MiniExcel.SaveAsByTemplate(path, templatePath, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("2022-12-25 00:00:00", rows[1].B);
Assert.Equal("2022-09-23 00:00:00", rows[2].B);
}
/// <summary>
/// [SaveAs Support empty sharedstring · Issue #405 · MiniExcel/MiniExcel]
/// (https://github.com/MiniExcel/MiniExcel/issues/405)
/// </summary>
[Fact]
public void TestIssue405()
{
var path = PathHelper.GetTempFilePath();
var value = new[] { new { id = 1, name = "test" } };
MiniExcel.SaveAs(path, value);
var xml = Helpers.GetZipFileContent(path, "xl/sharedStrings.xml");
Assert.StartsWith("<sst xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\"", xml);
}
/// <summary>
/// Using stream.SaveAs will close the Stream automatically when Specifying excelType
/// https://gitee.com/dotnetchina/MiniExcel/issues/I57WMM
/// </summary>
[Fact]
public void TestIssueI57WMM()
{
var sheets = new[] {
new Dictionary<string,object>(){
{"ID","0001"},{"Name","Jack"}
}
};
var stream = new MemoryStream();
stream.SaveAs(sheets, excelType: ExcelType.CSV);
stream.Position = 0;
// convert stream to string
StreamReader reader = new StreamReader(stream);
string text = reader.ReadToEnd();
var expected = "ID,Name\r\n0001,Jack\r\n";
Assert.Equal(expected, text);
}
[Fact]
public void TestIssue370()
{
var config = new OpenXmlConfiguration
{
DynamicColumns = new DynamicExcelColumn[] {
new DynamicExcelColumn("id"){Ignore=true},
new DynamicExcelColumn("name"){Index=1,Width=10},
new DynamicExcelColumn("createdate"){Index=0,Format="yyyy-MM-dd",Width=15},
new DynamicExcelColumn("point"){Index=2,Name="Account Point"},
}
};
var path = PathHelper.GetTempPath();
var json = JsonConvert.SerializeObject(new[] { new { id = 1, name = "Jack", createdate = new DateTime(2022, 04, 12), point = 123.456 } }, Formatting.Indented);
var value = JsonConvert.DeserializeObject<List<Dictionary<string, object>>>(json);
MiniExcel.SaveAs(path, value, configuration: config);
var rows = MiniExcel.Query(path, false).ToList();
Assert.Equal("createdate", rows[0].A);
Assert.Equal(new DateTime(2022, 04, 12), rows[1].A);
Assert.Equal("name", rows[0].B);
Assert.Equal("Jack", rows[1].B);
Assert.Equal("Account Point", rows[0].C);
Assert.Equal(123.456, rows[1].C);
}
[Fact]
public void TestIssue369()
{
var config = new OpenXmlConfiguration
{
DynamicColumns = new DynamicExcelColumn[] {
new DynamicExcelColumn("id"){Ignore=true},
new DynamicExcelColumn("name"){Index=1,Width=10},
new DynamicExcelColumn("createdate"){Index=0,Format="yyyy-MM-dd",Width=15},
new DynamicExcelColumn("point"){Index=2,Name="Account Point"},
}
};
var path = PathHelper.GetTempPath();
var value = new[] { new { id = 1, name = "Jack", createdate = new DateTime(2022, 04, 12), point = 123.456 } };
MiniExcel.SaveAs(path, value, configuration: config);
var rows = MiniExcel.Query(path, false).ToList();
Assert.Equal("createdate", rows[0].A);
Assert.Equal(new DateTime(2022, 04, 12), rows[1].A);
Assert.Equal("name", rows[0].B);
Assert.Equal("Jack", rows[1].B);
Assert.Equal("Account Point", rows[0].C);
Assert.Equal(123.456, rows[1].C);
}
[Fact]
public void TestIssueI4ZYUU()
{
var path = PathHelper.GetTempPath();
var value = new TestIssueI4ZYUUDto[] { new() { MyProperty = "1", MyProperty2 = new DateTime(2022, 10, 15) } };
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("2022-10", rows[1].B);
using (var workbook = new ClosedXML.Excel.XLWorkbook(path))
{
var ws = workbook.Worksheet(1);
Assert.True(ws.Column("A").Width > 0);
Assert.True(ws.Column("B").Width > 0);
}
}
public class TestIssueI4ZYUUDto
{
[ExcelColumn(Name = "ID", Index = 0)]
public string MyProperty { get; set; }
[ExcelColumn(Name = "CreateDate", Index = 1, Format = "yyyy-MM", Width = 100)]
public DateTime MyProperty2 { get; set; }
}
[Fact]
public void TestIssue360()
{
var path = PathHelper.GetFile("xlsx/NotDuplicateSharedStrings_10x100.xlsx");
var config = new OpenXmlConfiguration { SharedStringCacheSize = 1 };
var sheets = MiniExcel.GetSheetNames(path);
foreach (var sheetName in sheets)
{
var dt = MiniExcel.QueryAsDataTable(path, useHeaderRow: true, sheetName: sheetName, configuration: config);
}
}
[Fact]
public void TestIssue117()
{
{
var cache = new SharedStringsDiskCache();
for (int i = 0; i < 100; i++)
{
cache[i] = i.ToString();
}
for (int i = 0; i < 100; i++)
{
Assert.Equal(i.ToString(), cache[i]);
}
Assert.Equal(100, cache.Count);
}
{
var cache = new SharedStringsDiskCache();
Assert.Empty(cache);
}
}
[Fact]
public void TestIssue352()
{
{
DataTable table = new DataTable();
{
table.Columns.Add("id", typeof(int));
table.Columns.Add("name", typeof(string));
table.Rows.Add(1, "Jack");
table.Rows.Add(2, "Mike");
}
var path = Path.GetTempPath() + Guid.NewGuid() + ".xlsx";
DataTableReader reader = table.CreateDataReader();
MiniExcel.SaveAs(path, reader);
var xml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
var cnt = Regex.Matches(xml, "<x:autoFilter ref=\"A1:B3\" />").Count;
}
{
DataTable table = new DataTable();
{
table.Columns.Add("id", typeof(int));
table.Columns.Add("name", typeof(string));
table.Rows.Add(1, "Jack");
table.Rows.Add(2, "Mike");
}
var path = Path.GetTempPath() + Guid.NewGuid() + ".xlsx";
DataTableReader reader = table.CreateDataReader();
MiniExcel.SaveAs(path, reader, false);
var xml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
var cnt = Regex.Matches(xml, "<x:autoFilter ref=\"A1:B2\" />").Count;
}
{
DataTable table = new DataTable();
{
table.Columns.Add("id", typeof(int));
table.Columns.Add("name", typeof(string));
}
var path = Path.GetTempPath() + Guid.NewGuid() + ".xlsx";
DataTableReader reader = table.CreateDataReader();
MiniExcel.SaveAs(path, reader);
var xml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
var cnt = Regex.Matches(xml, "<x:autoFilter ref=\"A1:B1\" />").Count;
}
}
[Theory]
[InlineData(true, 1)]
[InlineData(false, 0)]
public void TestIssue401(bool autoFilter, int count)
{
// Test for DataTable
{
DataTable table = new DataTable();
{
table.Columns.Add("id", typeof(int));
table.Columns.Add("name", typeof(string));
table.Rows.Add(1, "Jack");
table.Rows.Add(2, "Mike");
}
DataTableReader reader = table.CreateDataReader();
var path = Path.GetTempPath() + Guid.NewGuid() + ".xlsx";
var config = new OpenXmlConfiguration { AutoFilter = autoFilter };
MiniExcel.SaveAs(path, reader, configuration: config);
var xml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
var cnt = Regex.Matches(xml, "<x:autoFilter ref=\"A1:B3\" />").Count;
Assert.Equal(count, cnt);
File.Delete(path);
}
{
DataTable table = new DataTable();
{
table.Columns.Add("id", typeof(int));
table.Columns.Add("name", typeof(string));
table.Rows.Add(1, "Jack");
table.Rows.Add(2, "Mike");
}
DataTableReader reader = table.CreateDataReader();
var path = Path.GetTempPath() + Guid.NewGuid() + ".xlsx";
var config = new OpenXmlConfiguration { AutoFilter = autoFilter };
MiniExcel.SaveAs(path, reader, false, configuration: config);
var xml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
var cnt = Regex.Matches(xml, "<x:autoFilter ref=\"A1:B2\" />").Count;
Assert.Equal(count, cnt);
File.Delete(path);
}
{
DataTable table = new DataTable();
{
table.Columns.Add("id", typeof(int));
table.Columns.Add("name", typeof(string));
}
DataTableReader reader = table.CreateDataReader();
var path = Path.GetTempPath() + Guid.NewGuid() + ".xlsx";
var config = new OpenXmlConfiguration { AutoFilter = autoFilter };
MiniExcel.SaveAs(path, reader, configuration: config);
var xml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
var cnt = Regex.Matches(xml, "<x:autoFilter ref=\"A1:B1\" />").Count;
Assert.Equal(count, cnt);
File.Delete(path);
}
// Test for DataReader
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
var config = new OpenXmlConfiguration { AutoFilter = autoFilter };
using (var connection = Db.GetConnection("Data Source=:memory:"))
{
using var command = new SQLiteCommand(@"select 'MiniExcel' as Column1,1 as Column2 union all select 'Github',2", connection);
connection.Open();
using var reader = command.ExecuteReader();
MiniExcel.SaveAs(path, reader, configuration: config);
}
var xml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
var cnt = Regex.Matches(xml, "autoFilter").Count;
Assert.Equal(count, cnt);
File.Delete(path);
}
{
var xlsxPath = @"../../../../../samples/xlsx/Test5x2.xlsx";
var tempSqlitePath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.db");
var connectionString = $"Data Source={tempSqlitePath};Version=3;";
using (var connection = new SQLiteConnection(connectionString))
{
connection.Execute(@"create table T (A varchar(20),B varchar(20));");
}
using (var connection = new SQLiteConnection(connectionString))
{
connection.Open();
using (var transaction = connection.BeginTransaction())
using (var stream = File.OpenRead(xlsxPath))
{
var rows = stream.Query();
foreach (var row in rows)
connection.Execute("insert into T (A,B) values (@A,@B)", new { row.A, row.B }, transaction: transaction);
transaction.Commit();
}
}
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
var config = new OpenXmlConfiguration { AutoFilter = autoFilter };
using (var connection = new SQLiteConnection(connectionString))
{
using var command = new SQLiteCommand("select * from T", connection);
connection.Open();
using var reader = command.ExecuteReader();
MiniExcel.SaveAs(path, reader, configuration: config);
}
var xml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
var cnt = Regex.Matches(xml, "autoFilter").Count;
Assert.Equal(count, cnt);
File.Delete(path);
File.Delete(tempSqlitePath);
}
}
[Fact]
public async Task TestIssue307()
{
var path = PathHelper.GetTempFilePath();
var value = new[] { new { id = 1, name = "Jack" } };
MiniExcel.SaveAs(path, value);
Assert.Throws<IOException>(() => MiniExcel.SaveAs(path, value));
MiniExcel.SaveAs(path, value, overwriteFile: true);
await Assert.ThrowsAsync<IOException>(async () => await MiniExcel.SaveAsAsync(path, value));
await MiniExcel.SaveAsAsync(path, value, overwriteFile: true);
}
[Fact]
public void TestIssue310()
{
var path = PathHelper.GetTempFilePath();
var value = new[] { new TestIssue310Dto { V1 = null }, new TestIssue310Dto { V1 = 2 } };
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query<TestIssue310Dto>(path).ToList();
}
[Fact]
public void TestIssue310Fix497()
{
var path = PathHelper.GetTempFilePath();
var value = new[] { new TestIssue310Dto { V1 = null }, new TestIssue310Dto { V1 = 2 } };
MiniExcel.SaveAs(path, value, configuration: new OpenXmlConfiguration() { EnableWriteNullValueCell = false });
var rows = MiniExcel.Query<TestIssue310Dto>(path).ToList();
}
public class TestIssue310Dto
{
public int? V1 { get; set; }
}
/// <summary>
/// Excel was unable to open the file https://github.com/shps951023/MiniExcel/issues/343
/// </summary>
[Fact]
public void TestIssue343()
{
{
var date = DateTime.Parse("2022-03-17 09:32:06.111", CultureInfo.InvariantCulture);
var path = PathHelper.GetTempFilePath();
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("ff-Latn");
DataTable table = new DataTable();
{
table.Columns.Add("time1", typeof(DateTime));
table.Columns.Add("time2", typeof(DateTime));
table.Rows.Add(date, date);
table.Rows.Add(date, date);
}
DataTableReader reader = table.CreateDataReader();
MiniExcel.SaveAs(path, reader);
var rows = MiniExcel.Query(path, true).ToArray();
Assert.Equal(date, rows[0].time1);
Assert.Equal(date, rows[0].time2);
}
}
[Fact]
public void TestIssueI4YCLQ_2()
{
var c = ExcelOpenXmlUtils.ConvertColumnName(1);
var c2 = ExcelOpenXmlUtils.ConvertColumnName(3);
var path = PathHelper.GetFile("xlsx/TestIssueI4YCLQ_2.xlsx");
var rows = MiniExcel.Query<TestIssueI4YCLQ_2Dto>(path, startCell: "B2")
.ToList();
Assert.Null(rows[0].站点编码);
Assert.Equal("N1", rows[0].站址名称);
Assert.Equal("a", rows[0].值1);
Assert.Equal("b", rows[0].值2);
Assert.Equal("c", rows[0].值3);
Assert.Equal("A1", rows[0].资源ID);
Assert.Equal("A", rows[0].值4);
Assert.Equal("B", rows[0].值5);
Assert.Equal("C", rows[0].值6);
Assert.Null(rows[0].值7);
Assert.Null(rows[0].值8);
}
public class TestIssueI4YCLQ_2Dto
{
[ExcelColumnIndex("A")]
public string 站点编码 { get; set; }
[ExcelColumnIndex("B")]
public string 站址名称 { get; set; }
[ExcelColumnIndex("C")]
public string 值1 { get; set; }
[ExcelColumnIndex("D")]
public string 值2 { get; set; }
[ExcelColumnIndex("E")]
public string 值3 { get; set; }
[ExcelColumnIndex("F")]
public string 资源ID { get; set; }
[ExcelColumnIndex("G")]
public string 值4 { get; set; }
[ExcelColumnIndex("H")]
public string 值5 { get; set; }
[ExcelColumnIndex("I")]
public string 值6 { get; set; }
public string 值7 { get; set; }
[ExcelColumnName("NotExist")]
public string 值8 { get; set; }
}
[Fact]
public async Task TestIssue338()
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
{
var path = PathHelper.GetFile("csv/TestIssue338.csv");
var row = MiniExcel.Query(path).FirstOrDefault();
Assert.Equal("<22><><EFBFBD>IJ<EFBFBD><C4B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>", row.A);
}
{
var path = PathHelper.GetFile("csv/TestIssue338.csv");
var config = new CsvConfiguration()
{
StreamReaderFunc = (stream) => new StreamReader(stream, Encoding.GetEncoding("gb2312"))
};
var row = MiniExcel.Query(path, configuration: config).FirstOrDefault();
Assert.Equal("中文测试内容", row.A);
}
{
var path = PathHelper.GetFile("csv/TestIssue338.csv");
var config = new CsvConfiguration()
{
StreamReaderFunc = (stream) => new StreamReader(stream, Encoding.GetEncoding("gb2312"))
};
using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read))
{
var row = (await stream.QueryAsync(configuration: config, excelType: ExcelType.CSV)).FirstOrDefault();
Assert.Equal("中文测试内容", row.A);
}
}
}
[Fact]
public void TestIssueI4WM67()
{
var path = PathHelper.GetTempFilePath();
var templatePath = PathHelper.GetFile("xlsx/TestIssueI4WM67.xlsx");
var value = new Dictionary<string, object>()
{
["users"] = new TestIssueI4WM67Dto[] { }
};
MiniExcel.SaveAsByTemplate(path, templatePath, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Single(rows);
}
public class TestIssueI4WM67Dto
{
public int ID { get; set; }
public string Name { get; set; }
}
[Fact]
public void TestIssueI4WXFB()
{
{
var path = PathHelper.GetTempFilePath();
var templatePath = PathHelper.GetFile("xlsx/TestIssueI4WXFB.xlsx");
var value = new Dictionary<string, object>()
{
["Name"] = "Jack",
["Amount"] = 1000,
["Department"] = "HR"
};
MiniExcel.SaveAsByTemplate(path, templatePath, value);
}
{
var config = new OpenXmlConfiguration()
{
IgnoreTemplateParameterMissing = false,
};
var path = PathHelper.GetTempFilePath();
var templatePath = PathHelper.GetFile("xlsx/TestIssueI4WXFB.xlsx");
var value = new Dictionary<string, object>()
{
["Name"] = "Jack",
["Amount"] = 1000,
["Department"] = "HR"
};
Assert.Throws<KeyNotFoundException>(() =>
MiniExcel.SaveAsByTemplate(path, templatePath, value, config)
);
}
}
[Fact]
public void TestIssueI4WDA9()
{
var path = Path.GetTempPath() + Guid.NewGuid() + ".csv";
var value = new DataTable();
{
value.Columns.Add("\"name\"");
value.Rows.Add("\"Jack\"");
}
MiniExcel.SaveAs(path, value);
Console.WriteLine(path);
var content = File.ReadAllText(path);
var expected = "\"\"\"name\"\"\"\r\n\"\"\"Jack\"\"\"\r\n";
Assert.Equal(expected, content);
}
[Fact]
public void TestIssue331_2()
{
var cln = CultureInfo.CurrentCulture.Name;
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("cs-CZ");
var config = new OpenXmlConfiguration()
{
Culture = CultureInfo.GetCultureInfo("cs-CZ")
};
var rnd = new Random();
var data = Enumerable.Range(1, 100).Select(x => new TestIssue331Dto
{
Number = x,
Text = $"Number {x}",
DecimalNumber = (decimal)rnd.NextDouble(),
DoubleNumber = rnd.NextDouble()
});
var path = Path.GetTempPath() + Guid.NewGuid() + ".xlsx";
MiniExcelLibs.MiniExcel.SaveAs(path, data, configuration: config);
Console.WriteLine(path);
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo(cln);
}
[Fact]
public void TestIssue331()
{
var cln = CultureInfo.CurrentCulture.Name;
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo("cs-CZ");
var data = Enumerable.Range(1, 10).Select(x => new TestIssue331Dto
{
Number = x,
Text = $"Number {x}",
DecimalNumber = (decimal)x / (decimal)2,
DoubleNumber = (double)x / (double)2
});
var path = Path.GetTempPath() + Guid.NewGuid() + ".xlsx";
MiniExcelLibs.MiniExcel.SaveAs(path, data);
Console.WriteLine(path);
var rows = MiniExcel.Query(path, startCell: "A2").ToArray();
Assert.Equal(1.5, rows[2].B);
Assert.Equal(1.5, rows[2].C);
CultureInfo.CurrentCulture = CultureInfo.GetCultureInfo(cln);
}
public class TestIssue331Dto
{
public int Number { get; set; }
public decimal DecimalNumber { get; set; }
public double DoubleNumber { get; set; }
public string Text { get; set; }
}
[Fact]
public void TestIssueI4TXGT()
{
var path = PathHelper.GetTempFilePath();
var value = new[] { new TestIssueI4TXGTDto { ID = 1, Name = "Apple", Spc = "X", Up = 6999 } };
MiniExcel.SaveAs(path, value);
{
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("ID", rows[0].A);
Assert.Equal("Name", rows[0].B);
Assert.Equal("Specification", rows[0].C);
Assert.Equal("Unit Price", rows[0].D);
}
{
var rows = MiniExcel.Query<TestIssueI4TXGTDto>(path).ToList();
Assert.Equal(1, rows[0].ID);
Assert.Equal("Apple", rows[0].Name);
Assert.Equal("X", rows[0].Spc);
Assert.Equal(6999, rows[0].Up);
}
}
public class TestIssueI4TXGTDto
{
public int ID { get; set; }
public string Name { get; set; }
[DisplayName("Specification")]
public string Spc { get; set; }
[DisplayName("Unit Price")]
public decimal Up { get; set; }
}
[Fact]
public void TestIssue328()
{
var path = PathHelper.GetTempFilePath();
var value = new[] {
new { id=1,name="Jack",indate=new DateTime(2022,5,13), file = File.ReadAllBytes(PathHelper.GetFile("images/TestIssue327.png")) },
new { id=2,name="Henry",indate=new DateTime(2022,4,10), file = File.ReadAllBytes(PathHelper.GetFile("other/TestIssue327.txt")) },
};
MiniExcel.SaveAs(path, value);
var rowIndx = 0;
using (var reader = MiniExcel.GetReader(path, true))
{
Assert.Equal("id", reader.GetName(0));
Assert.Equal("name", reader.GetName(1));
Assert.Equal("indate", reader.GetName(2));
Assert.Equal("file", reader.GetName(3));
while (reader.Read())
{
for (int i = 0; i < reader.FieldCount; i++)
{
var v = reader.GetValue(i);
if (rowIndx == 0 && i == 0) Assert.Equal(1.0, v);
if (rowIndx == 0 && i == 1) Assert.Equal("Jack", v);
if (rowIndx == 0 && i == 2) Assert.Equal(new DateTime(2022, 5, 13), v);
if (rowIndx == 0 && i == 3) Assert.Equal(File.ReadAllBytes(PathHelper.GetFile("images/TestIssue327.png")), v);
if (rowIndx == 1 && i == 0) Assert.Equal(2.0, v);
if (rowIndx == 1 && i == 1) Assert.Equal("Henry", v);
if (rowIndx == 1 && i == 2) Assert.Equal(new DateTime(2022, 4, 10), v);
if (rowIndx == 1 && i == 3) Assert.Equal(File.ReadAllBytes(PathHelper.GetFile("other/TestIssue327.txt")), v);
}
rowIndx++;
}
}
//TODO:How to resolve empty body sheet?
}
[Fact]
public void TestIssue327()
{
var path = PathHelper.GetTempFilePath();
var value = new[] {
new { id = 1, file = File.ReadAllBytes(PathHelper.GetFile("images/TestIssue327.png")) },
new { id = 2, file = File.ReadAllBytes(PathHelper.GetFile("other/TestIssue327.txt")) },
new { id = 3, file = File.ReadAllBytes(PathHelper.GetFile("other/TestIssue327.html")) },
};
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal(value[0].file, rows[0].file);
Assert.Equal(value[1].file, rows[1].file);
Assert.Equal(value[2].file, rows[2].file);
Assert.Equal("Hello MiniExcel", Encoding.UTF8.GetString(rows[1].file));
Assert.Equal("<html>Hello MiniExcel</html>", Encoding.UTF8.GetString(rows[2].file));
}
[Fact]
public void TestIssue316()
{
// XLSX
{
{
var path = PathHelper.GetTempFilePath("xlsx");
var value = new[] {
new{ amount=123_456.789M,createtime=DateTime.Parse("2018-01-31",CultureInfo.InvariantCulture)}
};
var config = new OpenXmlConfiguration()
{
Culture = new CultureInfo("fr-FR"),
};
MiniExcel.SaveAs(path, value, configuration: config);
//Datetime error
{
Assert.Throws<ExcelInvalidCastException>(() =>
{
var config = new OpenXmlConfiguration()
{
Culture = new CultureInfo("en-US"),
};
MiniExcel.Query<TestIssue316Dto>(path, configuration: config).ToList();
});
}
// dynamic
{
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal("123456,789", rows[0].amount);
Assert.Equal("31/01/2018 00:00:00", rows[0].createtime);
}
}
// type
{
var path = PathHelper.GetTempFilePath("xlsx");
var value = new[] {
new{ amount=123_456.789M,createtime=DateTime.Parse("2018-05-12",CultureInfo.InvariantCulture)}
};
{
var config = new OpenXmlConfiguration()
{
Culture = new CultureInfo("fr-FR"),
};
MiniExcel.SaveAs(path, value, configuration: config);
}
{
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal("123456,789", rows[0].amount);
Assert.Equal("12/05/2018 00:00:00", rows[0].createtime);
}
{
var config = new OpenXmlConfiguration()
{
Culture = new CultureInfo("en-US"),
};
var rows = MiniExcel.Query<TestIssue316Dto>(path, configuration: config).ToList();
Assert.Equal("2018-12-05 00:00:00", rows[0].createtime.ToString("yyyy-MM-dd HH:mm:ss"));
Assert.Equal(123456789m, rows[0].amount);
}
{
var config = new OpenXmlConfiguration()
{
Culture = new CultureInfo("fr-FR"),
};
var rows = MiniExcel.Query<TestIssue316Dto>(path, configuration: config).ToList();
Assert.Equal("2018-05-12 00:00:00", rows[0].createtime.ToString("yyyy-MM-dd HH:mm:ss"));
Assert.Equal(123456.789m, rows[0].amount);
}
}
}
// CSV
{
{
var path = PathHelper.GetTempFilePath("csv");
var value = new[] {
new{ amount=123_456.789M,createtime=DateTime.Parse("2018-01-31",CultureInfo.InvariantCulture)}
};
var config = new CsvConfiguration()
{
Culture = new CultureInfo("fr-FR"),
};
MiniExcel.SaveAs(path, value, configuration: config);
//Datetime error
{
Assert.Throws<ExcelInvalidCastException>(() =>
{
var config = new CsvConfiguration()
{
Culture = new CultureInfo("en-US"),
};
MiniExcel.Query<TestIssue316Dto>(path, configuration: config).ToList();
});
}
// dynamic
{
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal("123456,789", rows[0].amount);
Assert.Equal("31/01/2018 00:00:00", rows[0].createtime);
}
}
// type
{
var path = PathHelper.GetTempFilePath("csv");
var value = new[] {
new{ amount=123_456.789M,createtime=DateTime.Parse("2018-05-12",CultureInfo.InvariantCulture)}
};
{
var config = new CsvConfiguration()
{
Culture = new CultureInfo("fr-FR"),
};
MiniExcel.SaveAs(path, value, configuration: config);
}
{
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal("123456,789", rows[0].amount);
Assert.Equal("12/05/2018 00:00:00", rows[0].createtime);
}
{
var config = new CsvConfiguration()
{
Culture = new CultureInfo("en-US"),
};
var rows = MiniExcel.Query<TestIssue316Dto>(path, configuration: config).ToList();
Assert.Equal("2018-12-05 00:00:00", rows[0].createtime.ToString("yyyy-MM-dd HH:mm:ss"));
Assert.Equal(123456789m, rows[0].amount);
}
{
var config = new CsvConfiguration()
{
Culture = new CultureInfo("fr-FR"),
};
var rows = MiniExcel.Query<TestIssue316Dto>(path, configuration: config).ToList();
Assert.Equal("2018-05-12 00:00:00", rows[0].createtime.ToString("yyyy-MM-dd HH:mm:ss"));
Assert.Equal(123456.789m, rows[0].amount);
}
}
}
}
public class TestIssue316Dto
{
public decimal amount { get; set; }
public DateTime createtime { get; set; }
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/325
/// </summary>
[Fact]
public void TestIssue325()
{
var path = PathHelper.GetTempFilePath();
var value = new Dictionary<string, object>()
{
{ "sheet1",new[]{ new { id = 1, date = DateTime.Parse("2022-01-01") } }},
{ "sheet2",new[]{ new { id = 2, date = DateTime.Parse("2022-01-01") } }},
};
MiniExcel.SaveAs(path, value);
var xml = Helpers.GetZipFileContent(path, "xl/worksheets/_rels/sheet2.xml.rels");
var cnt = Regex.Matches(xml, "Id=\"drawing2\"").Count;
Assert.True(cnt == 1);
}
/// <summary>
/// https://gitee.com/dotnetchina/MiniExcel/issues/I49RZH
/// https://github.com/shps951023/MiniExcel/issues/305
/// </summary>
[Fact]
public void TestIssueI49RZH()
{
// xlsx
{
var path = PathHelper.GetTempFilePath();
var value = new TestIssueI49RZHDto[] {
new TestIssueI49RZHDto{ dd = DateTimeOffset.Parse("2022-01-22")},
new TestIssueI49RZHDto{ dd = null}
};
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("2022-01-22", rows[1].A);
}
//TODO:CSV
{
var path = PathHelper.GetTempFilePath("csv");
var value = new TestIssueI49RZHDto[] {
new TestIssueI49RZHDto{ dd = DateTimeOffset.Parse("2022-01-22")},
new TestIssueI49RZHDto{ dd = null}
};
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("2022-01-22", rows[1].A);
}
}
public class TestIssueI49RZHDto
{
[ExcelFormat("yyyy-MM-dd")]
public DateTimeOffset? dd { get; set; }
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/312
/// </summary>
[Fact]
public void TestIssue312()
{
//xlsx
{
var path = PathHelper.GetTempFilePath();
var value = new TestIssue312Dto[] {
new TestIssue312Dto{ value = 12345.6789},
new TestIssue312Dto{ value = null}
};
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("12,345.68", rows[1].A);
}
//TODO:CSV
{
var path = PathHelper.GetTempFilePath("csv");
var value = new TestIssue312Dto[] {
new TestIssue312Dto{ value = 12345.6789},
new TestIssue312Dto{ value = null}
};
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("12,345.68", rows[1].A);
}
}
public class TestIssue312Dto
{
[ExcelFormat("0,0.00")]
public double? value { get; set; }
}
/// <summary>
/// Query type conversion error
/// https://github.com/shps951023/MiniExcel/issues/309
/// </summary>
[Fact]
public void TestIssue209()
{
try
{
var path = PathHelper.GetFile("xlsx/TestIssue309.xlsx");
var rows = MiniExcel.Query<TestIssue209Dto>(path).ToList();
}
catch (ExcelInvalidCastException ex)
{
Assert.Equal("SEQ", ex.ColumnName);
Assert.Equal(4, ex.Row);
Assert.Equal("Error", ex.Value);
Assert.Equal(typeof(int), ex.InvalidCastType);
Assert.Equal("ColumnName : SEQ, CellRow : 4, Value : Error, it can't cast to Int32 type.", ex.Message);
}
}
public class TestIssue209Dto
{
public int ID { get; set; }
public string Name { get; set; }
public int SEQ { get; set; }
}
/// <summary>
/// [SaveAs and Query support btye[] base64 converter · Issue #318 · shps951023/MiniExcel](https://github.com/shps951023/MiniExcel/issues/318)
/// </summary>
[Fact]
public void TestIssue318()
{
var imageByte = File.ReadAllBytes(PathHelper.GetFile("images/github_logo.png"));
var path = PathHelper.GetTempFilePath();
var value = new[] {
new { Name="github",Image=imageByte},
};
MiniExcel.SaveAs(path, value);
// import to byte[]
{
var rows = MiniExcel.Query(path, true).ToList();
var expectedBase64 = "iVBORw0KGgoAAAANSUhEUgAAABwAAAAcCAIAAAD9b0jDAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAAEXRFWHRTb2Z0d2FyZQBTbmlwYXN0ZV0Xzt0AAALNSURBVEiJ7ZVLTBNBGMdndrfdIofy0ERbCgcFeYRuCy2JGOPNRA9qeIZS6YEEogQj0YMmGOqDSATxQaLRxKtRID4SgjGelUBpaQvGZ7kpII8aWtjd2dkdDxsJoS1pIh6M/k+z8833m/3+8+0OJISArRa15cT/0D8CZTYPe32+Zy+GxjzjMzOzAACDYafdZquqOG7hzJtkwUQthRC6cavv0eN+QRTBujUQQp1OV1dbffZMq1arTRaqKIok4eZTrSNjHqIo6gIIIQBgbQwpal+Z/f7dPo2GoaiNHtJut3vjPhBe7+kdfvW61Mq1nGyaX1xYjkRzsk2Z6Rm8IOTvzWs73SLwwqjHK4jCgf3lcV6VxGgiECji7AXm0gvtHYQQnue/zy8ghCRJWlxaWuV5Qsilq9cKzLYiiz04ORVLiHP6A4NPRQlhjLWsVpZlnU63Y3umRqNhGCYjPV3HsrIsMwyDsYQQejIwGEuIA/WMT1AAaDSahnoHTdPKL1vXPKVp2umoZVkWAOj1+ZOCzs7NKYTo9XqjYRcAgKIo9ZRUu9VxltGYZTQAAL5+m0kKijEmAPCrqyJCcRuOECKI4lL4ByEEYykpaE62iQIgurLi9wchhLIsry8fYwwh9PomwuEwACDbZEoKauHMgKJSU1PbOy6Hpqdpml5fPsMwn7+EOru6IYQAghKrJSloTVUFURSX02G3lRw+WulqbA4EJ9XQh4+f2s6dr65zhkLTEEIKwtqaylhCnG/fauFO1Nfde/Bw6Hm/0WiYevc+LU2vhlK2pQwNvwQAsCwrYexyOrji4lhCnOaXZRljXONoOHTk2Ju3I/5AcC3EC0JZ+cE9Bea8IqursUkUker4BsWBqpIk6aL7Sm4htzvfvByJqJORaDS3kMsvLuns6kYIJcpNCFU17pvouXlHEET1URDEnt7bo2OezbMS/vp+R3/PdfKPQ38Ccg0E/CDcpY8AAAAASUVORK5CYII=";
var actulBase64 = Convert.ToBase64String((byte[])rows[0].Image);
Assert.Equal(expectedBase64, actulBase64);
}
// import to base64 string
{
var config = new OpenXmlConfiguration() { EnableConvertByteArray = false };
var rows = MiniExcel.Query(path, true, configuration: config).ToList();
var image = (string)rows[0].Image;
Assert.StartsWith("@@@fileid@@@,xl/media/", image);
}
}
/// <summary>
/// SaveAs support Image type · Issue #304 https://github.com/shps951023/MiniExcel/issues/304
/// </summary>
[Fact]
public void TestIssue304()
{
var path = PathHelper.GetTempFilePath();
var value = new[] {
new { Name="github",Image=File.ReadAllBytes(PathHelper.GetFile("images/github_logo.png"))},
new { Name="google",Image=File.ReadAllBytes(PathHelper.GetFile("images/google_logo.png"))},
new { Name="microsoft",Image=File.ReadAllBytes(PathHelper.GetFile("images/microsoft_logo.png"))},
new { Name="reddit",Image=File.ReadAllBytes(PathHelper.GetFile("images/reddit_logo.png"))},
new { Name="statck_overflow",Image=File.ReadAllBytes(PathHelper.GetFile("images/statck_overflow_logo.png"))},
};
MiniExcel.SaveAs(path, value);
{
Assert.Contains("/xl/media/", Helpers.GetZipFileContent(path, "xl/drawings/_rels/drawing1.xml.rels"));
Assert.Contains("ext cx=\"609600\" cy=\"190500\"", Helpers.GetZipFileContent(path, "xl/drawings/drawing1.xml"));
Assert.Contains("/xl/drawings/drawing1.xml", Helpers.GetZipFileContent(path, "[Content_Types].xml"));
Assert.Contains("drawing r:id=", Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml"));
Assert.Contains("../drawings/drawing1.xml", Helpers.GetZipFileContent(path, "xl/worksheets/_rels/sheet1.xml.rels"));
}
}
/// <summary>
/// https://gitee.com/dotnetchina/MiniExcel/issues/I4HL54
/// </summary>
[Fact]
public void TestIssueI4HL54()
{
{
using (var cn = Db.GetConnection())
{
var reader = cn.ExecuteReader(@"select 'Hello World1' Text union all select 'Hello World2'");
var templatePath = PathHelper.GetFile("xlsx/TestIssueI4HL54_Template.xlsx");
var path = PathHelper.GetTempPath();
var value = new Dictionary<string, object>()
{
{ "Texts",reader}
};
MiniExcel.SaveAsByTemplate(path, templatePath, value);
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal("Hello World1", rows[0].Text);
Assert.Equal("Hello World2", rows[1].Text);
}
}
}
/// <summary>
/// [Prefix and suffix blank space will lost after SaveAs · Issue #294 · shps951023/MiniExcel]
/// (https://github.com/shps951023/MiniExcel/issues/294)
/// </summary>
[Fact]
public void TestIssue294()
{
{
var path = PathHelper.GetTempPath();
var value = new[] { new { Name = " Jack" } };
MiniExcel.SaveAs(path, value);
var sheetXml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
Assert.Contains("xml:space=\"preserve\"", sheetXml);
}
{
var path = PathHelper.GetTempPath();
var value = new[] { new { Name = "Ja ck" } };
MiniExcel.SaveAs(path, value);
var sheetXml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
Assert.DoesNotContain("xml:space=\"preserve\"", sheetXml);
}
{
var path = PathHelper.GetTempPath();
var value = new[] { new { Name = "Jack " } };
MiniExcel.SaveAs(path, value);
var sheetXml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
Assert.Contains("xml:space=\"preserve\"", sheetXml);
}
}
/// <summary>
/// Column '' does not belong to table when csv convert to datatable #298
/// https://github.com/shps951023/MiniExcel/issues/298
/// </summary>
[Fact]
public void TestIssue298()
{
var path = PathHelper.GetFile("/csv/TestIssue298.csv");
var dt = MiniExcel.QueryAsDataTable(path);
Assert.Equal(new[] { "ID", "Name", "Age" }, dt.Columns.Cast<DataColumn>().Select(_ => _.ColumnName));
}
/// <summary>
/// SaveAsByTemplate if there is & in the cell value, it will be &amp;
/// https://gitee.com/dotnetchina/MiniExcel/issues/I4DQUN
/// </summary>
[Fact]
public void TestIssueI4DQUN()
{
var templatePath = PathHelper.GetFile("xlsx/TestIssueI4DQUN.xlsx");
var path = PathHelper.GetTempPath();
var value = new Dictionary<string, object>()
{
{ "Title","Hello & World < , > , \" , '" },
{ "Details",new[]{ new { Value = "Hello & Value < , > , \" , '" } } },
};
MiniExcel.SaveAsByTemplate(path, templatePath, value);
var sheetXml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
Assert.Contains("<v>Hello &amp; World &lt; , &gt; , \" , '</v>", sheetXml);
Assert.Contains("<v>Hello &amp; Value &lt; , &gt; , \" , '</v>", sheetXml);
}
/// <summary>
/// [SaveAs default theme support filter mode · Issue #190 · shps951023/MiniExcel](https://github.com/shps951023/MiniExcel/issues/190)
/// </summary>
[Fact]
public void TestIssue190()
{
{
var path = PathHelper.GetTempPath();
var value = new TestIssue190Dto[] { };
MiniExcel.SaveAs(path, value, configuration: new OpenXmlConfiguration() { AutoFilter = false });
var sheetXml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
Assert.DoesNotContain("<x:autoFilter ref=\"A1:C1\" />", sheetXml);
}
{
var path = PathHelper.GetTempPath();
var value = new TestIssue190Dto[] { };
MiniExcel.SaveAs(path, value);
var sheetXml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
Assert.Contains("<x:autoFilter ref=\"A1:C1\" />", sheetXml);
}
{
var path = PathHelper.GetTempPath();
var value = new[] { new TestIssue190Dto { ID = 1, Name = "Jack", Age = 32 }, new TestIssue190Dto { ID = 2, Name = "Lisa", Age = 45 } };
MiniExcel.SaveAs(path, value);
var sheetXml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
Assert.Contains("<x:autoFilter ref=\"A1:C3\" />", sheetXml);
}
}
public class TestIssue190Dto
{
public int ID { get; set; }
public string Name { get; set; }
public int Age { get; set; }
}
/// <summary>
/// [According to the XLSX to CSV example, there will be data loss if there is no header. · Issue #292 · shps951023/MiniExcel](https://github.com/shps951023/MiniExcel/issues/292)
/// </summary>
[Fact]
public void TestIssue292()
{
{
var xlsxPath = PathHelper.GetFile("/xlsx/TestIssue292.xlsx");
var csvPath = PathHelper.GetTempPath("csv");
MiniExcel.ConvertXlsxToCsv(xlsxPath, csvPath);
var actualCotent = File.ReadAllText(csvPath);
Assert.Equal(@"Name,Age,Name,Age
Jack,22,Mike,25
Henry,44,Jerry,44
", actualCotent);
}
{
var csvPath = PathHelper.GetFile("/csv/TestIssue292.csv");
var xlsxPath = PathHelper.GetTempPath("xlsx");
MiniExcel.ConvertCsvToXlsx(csvPath, xlsxPath);
var rows = MiniExcel.Query(xlsxPath).ToList();
Assert.Equal(3, rows.Count);
Assert.Equal("Name", rows[0].A);
Assert.Equal("Age", rows[0].B);
Assert.Equal("Name", rows[0].C);
Assert.Equal("Age", rows[0].D);
Assert.Equal("Jack", rows[1].A);
Assert.Equal("22", rows[1].B);
Assert.Equal("Mike", rows[1].C);
Assert.Equal("25", rows[1].D);
}
}
/// <summary>
/// [Csv Query then SaveAs will throw "Stream was not readable." exception · Issue #293 · shps951023/MiniExcel](https://github.com/shps951023/MiniExcel/issues/293)
/// </summary>
[Fact]
public void TestIssue293()
{
var path = PathHelper.GetFile("/csv/Test5x2.csv");
var tempPath = PathHelper.GetTempPath("csv");
using (var csv = File.OpenRead(path))
{
var value = MiniExcel.Query(csv, useHeaderRow: false, excelType: ExcelType.CSV);
MiniExcel.SaveAs(tempPath, value, printHeader: false, excelType: ExcelType.XLSX);
}
}
[Fact]
public void TestIssueI49RYZ()
{
{
var values = new[]
{
new I49RYZDto(){Name="Jack",UserType=I49RYZUserType.V1},
new I49RYZDto(){Name="Leo",UserType=I49RYZUserType.V2},
new I49RYZDto(){Name="Henry",UserType=I49RYZUserType.V3},
new I49RYZDto(){Name="Lisa",UserType=null},
};
var path = PathHelper.GetTempPath();
MiniExcel.SaveAs(path, values);
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal("GeneralUser", rows[0].UserType);
Assert.Equal("SuperAdministrator", rows[1].UserType);
Assert.Equal("GeneralAdministrator", rows[2].UserType);
Assert.Null(rows[3].UserType);
}
}
[Fact]
public void TestIssue286()
{
{
var values = new[]
{
new TestIssue286Dto(){E=TestIssue286Enum.VIP1},
new TestIssue286Dto(){E=TestIssue286Enum.VIP2},
};
var path = PathHelper.GetTempPath();
MiniExcel.SaveAs(path, values);
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal("VIP1", rows[0].E);
Assert.Equal("VIP2", rows[1].E);
}
}
public class TestIssue286Dto
{
public TestIssue286Enum E { get; set; }
}
public enum TestIssue286Enum
{
VIP1,
VIP2
}
public enum I49RYZUserType
{
[Description("GeneralUser")]
V1 = 0,
[Description("SuperAdministrator")]
V2 = 1,
[Description("GeneralAdministrator")]
V3 = 2
}
public class I49RYZDto
{
public string Name { get; set; }
public I49RYZUserType? UserType { get; set; }
}
/// <summary>
/// Create Multiple Sheets from IDataReader have Bug #283
/// </summary>
[Fact]
public void TestIssue283()
{
var path = PathHelper.GetTempPath();
using (var cn = Db.GetConnection())
{
var sheets = new Dictionary<string, object> { };
sheets.Add("sheet01", cn.ExecuteReader(@"select 'v1' col1"));
sheets.Add("sheet02", cn.ExecuteReader(@"select 'v2' col1"));
MiniExcel.SaveAs(path, sheets);
}
var sheetNames = MiniExcel.GetSheetNames(path);
Assert.Equal(new[] { "sheet01", "sheet02" }, sheetNames);
}
/// <summary>
/// https://gitee.com/dotnetchina/MiniExcel/issues/I40QA5
/// </summary>
[Fact]
public void TestIssueI40QA5()
{
{
var path = PathHelper.GetFile("/xlsx/TestIssueI40QA5_1.xlsx");
var rows = MiniExcel.Query<TestIssueI40QA5Dto>(path).ToList();
Assert.Equal("E001", rows[0].Empno);
Assert.Equal("E002", rows[1].Empno);
}
{
var path = PathHelper.GetFile("/xlsx/TestIssueI40QA5_2.xlsx");
var rows = MiniExcel.Query<TestIssueI40QA5Dto>(path).ToList();
Assert.Equal("E001", rows[0].Empno);
Assert.Equal("E002", rows[1].Empno);
}
{
var path = PathHelper.GetFile("/xlsx/TestIssueI40QA5_3.xlsx");
var rows = MiniExcel.Query<TestIssueI40QA5Dto>(path).ToList();
Assert.Equal("E001", rows[0].Empno);
Assert.Equal("E002", rows[1].Empno);
}
{
var path = PathHelper.GetFile("/xlsx/TestIssueI40QA5_4.xlsx");
var rows = MiniExcel.Query<TestIssueI40QA5Dto>(path).ToList();
Assert.Null(rows[0].Empno);
Assert.Null(rows[1].Empno);
}
}
public class TestIssueI40QA5Dto
{
[ExcelColumnName(excelColumnName: "EmployeeNo", aliases: new[] { "EmpNo", "No" })]
public string Empno { get; set; }
public string Name { get; set; }
}
[Fact]
public void TestIssues133()
{
{
var path = PathHelper.GetTempPath();
var value = new DataTable();
value.Columns.Add("Id");
value.Columns.Add("Name");
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("Id", rows[0].A);
Assert.Equal("Name", rows[0].B);
Assert.Single(rows);
Assert.Equal("A1:B1", Helpers.GetFirstSheetDimensionRefValue(path));
}
{
var path = PathHelper.GetTempPath();
var value = Array.Empty<TestIssues133Dto>();
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("Id", rows[0].A);
Assert.Equal("Name", rows[0].B);
Assert.Single(rows);
Assert.Equal("A1:B1", Helpers.GetFirstSheetDimensionRefValue(path));
}
}
public class TestIssues133Dto
{
public string Id { get; set; }
public string Name { get; set; }
}
/// <summary>
/// Semicolon expected
/// </summary>
[Fact]
public void TestIssueI45TF5_2()
{
{
var value = new[] { new Dictionary<string, object>() { { "Col1&Col2", "V1&V2" } } };
var path = PathHelper.GetTempPath();
MiniExcel.SaveAs(path, value);
//System.Xml.XmlException : '<' is an unexpected token. The expected token is ';'.
Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml"); //check illegal format or not
}
{
var dt = new DataTable();
dt.Columns.Add("Col1&Col2");
dt.Rows.Add("V1&V2");
var path = PathHelper.GetTempPath();
MiniExcel.SaveAs(path, dt);
//System.Xml.XmlException : '<' is an unexpected token. The expected token is ';'.
Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml"); //check illegal format or not
}
}
[Fact]
public void TestIssueI45TF5()
{
var path = PathHelper.GetTempPath();
MiniExcel.SaveAs(path, new[] { new { C1 = "1&2;3,4", C2 = "1&2;3,4" } });
var sheet1Xml = Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml");
Assert.True(!sheet1Xml.Contains("<x:cols>"));
}
/// <summary>
/// [Support column width attribute · Issue #280 · shps951023/MiniExcel](https://github.com/shps951023/MiniExcel/issues/280)
/// </summary>
[Fact]
public void TestIssue280()
{
var value = new[] { new TestIssue280Dto { ID = 1, Name = "Jack" }, new TestIssue280Dto { ID = 2, Name = "Mike" } };
var path = PathHelper.GetTempPath();
MiniExcel.SaveAs(path, value);
}
public class TestIssue280Dto
{
[ExcelColumnWidth(20)]
public int ID { get; set; }
[ExcelColumnWidth(15.50)]
public string Name { get; set; }
}
/// <summary>
/// Csv not support QueryAsDataTable #279 https://github.com/shps951023/MiniExcel/issues/279
/// </summary>
[Fact]
public void TestIssue279()
{
var path = PathHelper.GetFile("/csv/TestHeader.csv");
var dt = MiniExcel.QueryAsDataTable(path, true, null, ExcelType.CSV);
Assert.Equal("A1", dt.Rows[0]["Column1"]);
Assert.Equal("A2", dt.Rows[1]["Column1"]);
Assert.Equal("B1", dt.Rows[0]["Column2"]);
Assert.Equal("B2", dt.Rows[1]["Column2"]);
}
/// <summary>
/// Custom excel zip can't read and show Number of entries expected in End Of Central Directory does not correspond to number of entries in Central Directory. #272
/// </summary>
[Fact]
public void TestIssue272()
{
var path = PathHelper.GetFile("/xlsx/TestIssue272.xlsx");
try
{
var rows = MiniExcel.Query(path).ToList();
}
catch (Exception e)
{
Assert.Equal(typeof(InvalidDataException), e.GetType());
Assert.StartsWith("It's not legal excel zip, please check or issue for me.", e.Message);
}
}
/// <summary>
/// v0.16.0-0.17.1 custom format contains specific format (eg:`#,##0.000_);[Red]\(#,##0.000\)`), automatic converter will convert double to datetime #267
/// </summary>
[Fact]
public void TestIssue267()
{
var path = PathHelper.GetFile("/xlsx/TestIssue267.xlsx");
var row = MiniExcel.Query(path).SingleOrDefault();
Assert.Equal(10618, row.A);
Assert.Equal("2021-02-23", row.B);
Assert.Equal(43.199999999999996, row.C);
Assert.Equal(1.2, row.D);
Assert.Equal(new DateTime(2021, 7, 5), row.E);
Assert.Equal(new DateTime(2021, 7, 5, 15, 2, 46), row.F);
}
[Fact]
public void TestIssue268_DateFormat()
{
Assert.True(IsDateFormatString("dd/mm/yyyy"));
Assert.True(IsDateFormatString("dd-mmm-yy"));
Assert.True(IsDateFormatString("dd-mmmm"));
Assert.True(IsDateFormatString("mmm-yy"));
Assert.True(IsDateFormatString("h:mm AM/PM"));
Assert.True(IsDateFormatString("h:mm:ss AM/PM"));
Assert.True(IsDateFormatString("hh:mm"));
Assert.True(IsDateFormatString("hh:mm:ss"));
Assert.True(IsDateFormatString("dd/mm/yyyy hh:mm"));
Assert.True(IsDateFormatString("mm:ss"));
Assert.True(IsDateFormatString("mm:ss.0"));
Assert.True(IsDateFormatString("[$-809]dd mmmm yyyy"));
Assert.False(IsDateFormatString("#,##0;[Red]-#,##0"));
Assert.False(IsDateFormatString(@"#,##0.000_);[Red]\(#,##0.000\)"));
Assert.False(IsDateFormatString("0_);[Red](0)"));
Assert.False(IsDateFormatString(@"0\h"));
Assert.False(IsDateFormatString("0\"h\""));
Assert.False(IsDateFormatString("0%"));
Assert.False(IsDateFormatString("General"));
Assert.False(IsDateFormatString(@"_-* #,##0\ _P_t_s_-;\-* #,##0\ _P_t_s_-;_-* "" - ""??\ _P_t_s_-;_-@_- "));
}
private static bool IsDateFormatString(string formatCode)
{
return MiniExcelLibs.Utils.DateTimeHelper.IsDateTimeFormat(formatCode);
}
[Fact]
public void TestIssueI3X2ZL()
{
try
{
var path = PathHelper.GetFile("xlsx/TestIssueI3X2ZL_datetime_error.xlsx");
var rows = MiniExcel.Query<IssueI3X2ZLDTO>(path, startCell: "B3").ToList();
}
catch (InvalidCastException ex)
{
Assert.Equal(
"ColumnName : Col2, CellRow : 6, Value : error, it can't cast to DateTime type.",
ex.Message
);
}
try
{
var path = PathHelper.GetFile("xlsx/TestIssueI3X2ZL_int_error.xlsx");
var rows = MiniExcel.Query<IssueI3X2ZLDTO>(path).ToList();
}
catch (InvalidCastException ex)
{
Assert.Equal(
"ColumnName : Col1, CellRow : 3, Value : error, it can't cast to Int32 type.",
ex.Message
);
}
}
public class IssueI3X2ZLDTO
{
public int Col1 { get; set; }
public DateTime Col2 { get; set; }
}
/// <summary>
/// [Convert csv to xlsx · Issue #261 · shps951023/MiniExcel](https://github.com/shps951023/MiniExcel/issues/261)
/// </summary>
[Fact]
public void TestIssue261()
{
var csvPath = PathHelper.GetFile("csv/TestCsvToXlsx.csv");
var xlsxPath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".xlsx");
CsvToXlsx(csvPath, xlsxPath);
var rows = MiniExcel.Query(xlsxPath).ToList();
Assert.Equal("Name", rows[0].A);
Assert.Equal("Jack", rows[1].A);
Assert.Equal("Neo", rows[2].A);
Assert.Null(rows[3].A);
Assert.Null(rows[4].A);
Assert.Equal("Age", rows[0].B);
Assert.Equal("34", rows[1].B);
Assert.Equal("26", rows[2].B);
Assert.Null(rows[3].B);
Assert.Null(rows[4].B);
}
internal static void CsvToXlsx(string csvPath, string xlsxPath)
{
var value = MiniExcel.Query(csvPath, true);
MiniExcel.SaveAs(xlsxPath, value);
}
/// <summary>
/// [SaveAsByTemplate support DateTime custom format · Issue #255 · shps951023/MiniExcel]
/// (https://github.com/shps951023/MiniExcel/issues/255)
/// </summary>
[Fact]
public void Issue255()
{
//tempalte
{
var templatePath = PathHelper.GetFile("xlsx/TestsIssue255_Template.xlsx");
var path = PathHelper.GetTempPath();
var value = new
{
Issue255DTO = new Issue255DTO[] {
new Issue255DTO { Time = new DateTime(2021, 01, 01), Time2 = new DateTime(2021, 01, 01) }
}
};
MiniExcel.SaveAsByTemplate(path, templatePath, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("2021", rows[1].A.ToString());
Assert.Equal("2021", rows[1].B.ToString());
}
//saveas
{
var path = PathHelper.GetTempPath();
var value = new Issue255DTO[] {
new Issue255DTO { Time = new DateTime(2021, 01, 01) }
};
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("2021", rows[1].A.ToString());
}
}
public class Issue255DTO
{
[ExcelFormat("yyyy")]
public DateTime Time { get; set; }
[ExcelColumn(Format = "yyyy")]
public DateTime Time2 { get; set; }
}
/// <summary>
/// [Dynamic Query custom format not using mapping format · Issue #256]
/// (https://github.com/shps951023/MiniExcel/issues/256)
/// </summary>
[Fact]
public void Issue256()
{
var path = PathHelper.GetFile("xlsx/TestIssue256.xlsx");
var rows = MiniExcel.Query(path, false).ToList();
Assert.Equal(new DateTime(2003, 4, 16), rows[1].A);
Assert.Equal(new DateTime(2004, 4, 16), rows[1].B);
}
/// <summary>
/// Csv SaveAs by datareader with encoding default show messy code #253
/// </summary>
[Fact]
public void Issue253()
{
{
var value = new[] { new { col1 = "世界你好" } };
var path = PathHelper.GetTempPath(extension: "csv");
MiniExcel.SaveAs(path, value);
var expected = @"col1
世界你好
";
Assert.Equal(expected, File.ReadAllText(path));
}
{
System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);
var value = new[] { new { col1 = "世界你好" } };
var path = PathHelper.GetTempPath(extension: "csv");
var config = new CsvConfiguration()
{
StreamWriterFunc = (stream) => new StreamWriter(stream, Encoding.GetEncoding("gb2312"))
};
MiniExcel.SaveAs(path, value, excelType: ExcelType.CSV, configuration: config);
var expected = @"col1
<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
";
Assert.Equal(expected, File.ReadAllText(path));
}
using (var cn = Db.GetConnection())
{
var value = cn.ExecuteReader(@"select '世界你好' col1");
var path = PathHelper.GetTempPath(extension: "csv");
MiniExcel.SaveAs(path, value);
var expected = @"col1
世界你好
";
Assert.Equal(expected, File.ReadAllText(path));
}
}
/// <summary>
/// [CSV SaveAs support datareader · Issue #251 · shps951023/MiniExcel](https://github.com/shps951023/MiniExcel/issues/251)
/// </summary>
[Fact]
public void Issue251()
{
using (var cn = Db.GetConnection())
{
var reader = cn.ExecuteReader(@"select '""<>+-*//}{\\n' a,1234567890 b union all select '<test>Hello World</test>',-1234567890");
var path = PathHelper.GetTempPath(extension: "csv");
MiniExcel.SaveAs(path, reader);
var expected = @"a,b
""""""<>+-*//}{\\n"",1234567890
""<test>Hello World</test>"",-1234567890
";
Assert.Equal(expected, File.ReadAllText(path));
}
}
/// <summary>
/// No error exception throw when reading xls file #242
/// </summary>
[Fact]
public void Issue242()
{
var path = PathHelper.GetFile("xls/TestIssue242.xls");
Assert.Throws<NotSupportedException>(() => MiniExcel.Query(path).ToList());
using (var stream = File.OpenRead(path))
{
Assert.Throws<NotSupportedException>(() => stream.Query().ToList());
}
}
/// <summary>
/// Csv type mapping Query error "cannot be converted to xxx type" #243
/// </summary>
[Fact]
public void Issue243()
{
var path = PathHelper.GetTempPath("csv");
var value = new[] {
new { Name ="Jack",Age=25,InDate=new DateTime(2021,01,03)},
new { Name ="Henry",Age=36,InDate=new DateTime(2020,05,03)},
};
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query<Issue243Dto>(path).ToList();
Assert.Equal("Jack", rows[0].Name);
Assert.Equal(25, rows[0].Age);
Assert.Equal(new DateTime(2021, 01, 03), rows[0].InDate);
Assert.Equal("Henry", rows[1].Name);
Assert.Equal(36, rows[1].Age);
Assert.Equal(new DateTime(2020, 05, 03), rows[1].InDate);
}
public class Issue243Dto
{
public string Name { get; set; }
public int Age { get; set; }
public DateTime InDate { get; set; }
}
/// <summary>
/// Support Custom Datetime format #241
/// </summary>
[Fact]
public void Issue241()
{
var value = new Issue241Dto[] {
new Issue241Dto{ Name="Jack",InDate=new DateTime(2021,01,04)},
new Issue241Dto{ Name="Henry",InDate=new DateTime(2020,04,05)},
};
// csv
{
var path = PathHelper.GetTempPath("csv");
MiniExcel.SaveAs(path, value);
{
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal(rows[0].InDate, "01 04, 2021");
Assert.Equal(rows[1].InDate, "04 05, 2020");
}
{
var rows = MiniExcel.Query<Issue241Dto>(path).ToList();
Assert.Equal(rows[0].InDate, new DateTime(2021, 01, 04));
Assert.Equal(rows[1].InDate, new DateTime(2020, 04, 05));
}
}
// xlsx
{
var path = PathHelper.GetTempPath();
MiniExcel.SaveAs(path, value);
{
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal(rows[0].InDate, "01 04, 2021");
Assert.Equal(rows[1].InDate, "04 05, 2020");
}
{
var rows = MiniExcel.Query<Issue241Dto>(path).ToList();
Assert.Equal(rows[0].InDate, new DateTime(2021, 01, 04));
Assert.Equal(rows[1].InDate, new DateTime(2020, 04, 05));
}
}
}
public class Issue241Dto
{
public string Name { get; set; }
[ExcelFormat("MM dd, yyyy")]
public DateTime InDate { get; set; }
}
/// <summary>
/// SaveAs Default Template #132
/// </summary>
[Fact]
public void Issue132()
{
{
var path = PathHelper.GetTempPath();
var value = new[] {
new { name ="Jack",Age=25,InDate=new DateTime(2021,01,03)},
new { name ="Henry",Age=36,InDate=new DateTime(2020,05,03)},
};
MiniExcel.SaveAs(path, value);
}
{
var path = PathHelper.GetTempPath();
var value = new[] {
new { name ="Jack",Age=25,InDate=new DateTime(2021,01,03)},
new { name ="Henry",Age=36,InDate=new DateTime(2020,05,03)},
};
var config = new OpenXmlConfiguration()
{
TableStyles = TableStyles.None
};
MiniExcel.SaveAs(path, value, configuration: config);
}
{
var path = PathHelper.GetTempPath();
var value = JsonConvert.DeserializeObject<DataTable>(
JsonConvert.SerializeObject(new[] {
new { name ="Jack",Age=25,InDate=new DateTime(2021,01,03)},
new { name ="Henry",Age=36,InDate=new DateTime(2020,05,03)},
})
);
MiniExcel.SaveAs(path, value);
}
}
/// <summary>
/// Support SaveAs by DataSet #235
/// </summary>
[Fact]
public void Issue235()
{
var path = PathHelper.GetTempPath();
DataSet dataSet = new();
DataSet sheets = dataSet;
var users = JsonConvert.DeserializeObject<DataTable>(JsonConvert.SerializeObject(new[] { new { Name = "Jack", Age = 25 }, new { Name = "Mike", Age = 44 } }));
users.TableName = "users";
var department = JsonConvert.DeserializeObject<DataTable>(JsonConvert.SerializeObject(new[] { new { ID = "01", Name = "HR" }, new { ID = "02", Name = "IT" } })); ;
department.TableName = "department";
sheets.Tables.Add(users);
sheets.Tables.Add(department);
MiniExcel.SaveAs(path, sheets);
var sheetNames = MiniExcel.GetSheetNames(path);
Assert.Equal("users", sheetNames[0]);
Assert.Equal("department", sheetNames[1]);
{
var rows = MiniExcel.Query(path, true, sheetName: "users").ToList();
Assert.Equal("Jack", rows[0].Name);
Assert.Equal(25, rows[0].Age);
Assert.Equal("Mike", rows[1].Name);
Assert.Equal(44, rows[1].Age);
}
{
var rows = MiniExcel.Query(path, true, sheetName: "department").ToList();
Assert.Equal("01", rows[0].ID);
Assert.Equal("HR", rows[0].Name);
Assert.Equal("02", rows[1].ID);
Assert.Equal("IT", rows[1].Name);
}
}
/// <summary>
/// QueryAsDataTable A2=5.5 , A3=0.55/1.1 will case double type check error #233
/// </summary>
[Fact]
public void Issue233()
{
var path = PathHelper.GetFile("xlsx/TestIssue233.xlsx");
var dt = MiniExcel.QueryAsDataTable(path);
var rows = dt.Rows;
Assert.Equal(0.55, rows[0]["Size"]);
Assert.Equal("0.55/1.1", rows[1]["Size"]);
}
/// <summary>
/// Csv Query split comma not correct #237
/// https://github.com/shps951023/MiniExcel/issues/237
/// </summary>
[Fact]
public void Issue237()
{
var value = new[]
{
new{ id="\"\"1,2,3\"\""},
new{ id="1,2,3"},
};
var path = PathHelper.GetTempPath("csv");
MiniExcel.SaveAs(path, value);
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal("\"\"1,2,3\"\"", rows[0].id);
Assert.Equal("1,2,3", rows[1].id);
}
/// <summary>
/// SaveAs support multiple sheets #234
/// </summary>
[Fact]
public void Issue234()
{
var path = PathHelper.GetTempPath();
var users = new[] { new { Name = "Jack", Age = 25 }, new { Name = "Mike", Age = 44 } };
var department = new[] { new { ID = "01", Name = "HR" }, new { ID = "02", Name = "IT" } };
var sheets = new Dictionary<string, object>
{
["users"] = users,
["department"] = department
};
MiniExcel.SaveAs(path, sheets);
var sheetNames = MiniExcel.GetSheetNames(path);
Assert.Equal("users", sheetNames[0]);
Assert.Equal("department", sheetNames[1]);
{
var rows = MiniExcel.Query(path, true, sheetName: "users").ToList();
Assert.Equal("Jack", rows[0].Name);
Assert.Equal(25, rows[0].Age);
Assert.Equal("Mike", rows[1].Name);
Assert.Equal(44, rows[1].Age);
}
{
var rows = MiniExcel.Query(path, true, sheetName: "department").ToList();
Assert.Equal("01", rows[0].ID);
Assert.Equal("HR", rows[0].Name);
Assert.Equal("02", rows[1].ID);
Assert.Equal("IT", rows[1].Name);
}
}
/// <summary>
/// SaveAs By Reader Closed error : 'Error! Invalid attempt to call FieldCount when reader is closed' #230
/// https://github.com/shps951023/MiniExcel/issues/230
/// </summary>
[Fact]
public void Issue230()
{
var conn = Db.GetConnection("Data Source=:memory:");
conn.Open();
var cmd = conn.CreateCommand();
cmd.CommandText = "select 1 id union all select 2";
using (var reader = cmd.ExecuteReader(CommandBehavior.CloseConnection))
{
while (reader.Read())
{
for (int i = 0; i < reader.FieldCount; i++)
{
var result = $"{reader.GetName(i)} , {reader.GetValue(i)}";
output.WriteLine(result);
}
}
}
conn = Db.GetConnection("Data Source=:memory:");
conn.Open();
cmd = conn.CreateCommand();
cmd.CommandText = "select 1 id union all select 2";
using (var reader = cmd.ExecuteReader(CommandBehavior.CloseConnection))
{
while (reader.Read())
{
for (int i = 0; i < reader.FieldCount; i++)
{
var result = $"{reader.GetName(i)} , {reader.GetValue(i)}";
output.WriteLine(result);
}
}
}
conn = Db.GetConnection("Data Source=:memory:");
conn.Open();
cmd = conn.CreateCommand();
cmd.CommandText = "select 1 id union all select 2";
using (var reader = cmd.ExecuteReader(CommandBehavior.CloseConnection))
{
var path = PathHelper.GetTempPath();
MiniExcel.SaveAs(path, reader, printHeader: true);
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal(1, rows[0].id);
Assert.Equal(2, rows[1].id);
}
}
/// <summary>
/// v0.14.3 QueryAsDataTable error "Cannot set Column to be null" #229
/// https://github.com/shps951023/MiniExcel/issues/229
/// </summary>
[Fact]
public void Issue229()
{
var path = PathHelper.GetFile("xlsx/TestIssue229.xlsx");
var dt = MiniExcel.QueryAsDataTable(path);
foreach (DataColumn column in dt.Columns)
{
var v = dt.Rows[3][column];
Assert.Equal(DBNull.Value, v);
}
}
/// <summary>
/// [Query Merge cells data · Issue #122 · shps951023/MiniExcel]
/// (https://github.com/shps951023/MiniExcel/issues/122)
/// </summary>
[Fact]
public void Issue122()
{
var config = new OpenXmlConfiguration()
{
FillMergedCells = true
};
{
var path = PathHelper.GetFile("xlsx/TestIssue122.xlsx");
{
var rows = MiniExcel.Query(path, useHeaderRow: true, configuration: config).ToList();
Assert.Equal("HR", rows[0].Department);
Assert.Equal("HR", rows[1].Department);
Assert.Equal("HR", rows[2].Department);
Assert.Equal("IT", rows[3].Department);
Assert.Equal("IT", rows[4].Department);
Assert.Equal("IT", rows[5].Department);
}
}
{
var path = PathHelper.GetFile("xlsx/TestIssue122_2.xlsx");
{
var rows = MiniExcel.Query(path, useHeaderRow: true, configuration: config).ToList();
Assert.Equal("V1", rows[2].Test1);
Assert.Equal("V2", rows[5].Test2);
Assert.Equal("V3", rows[1].Test3);
Assert.Equal("V4", rows[2].Test4);
Assert.Equal("V5", rows[3].Test5);
Assert.Equal("V6", rows[5].Test5);
}
}
}
/// <summary>
/// [Support Xlsm AutoCheck · Issue #227 · shps951023/MiniExcel]
/// (https://github.com/shps951023/MiniExcel/issues/227)
/// </summary>
[Fact]
public void Issue227()
{
{
var path = PathHelper.GetTempPath("xlsm");
Assert.Throws<NotSupportedException>(() => MiniExcel.SaveAs(path, new[] { new { V = "A1" }, new { V = "A2" } }));
}
{
var path = PathHelper.GetFile("xlsx/TestIssue227.xlsm");
{
var rows = MiniExcel.Query<UserAccount>(path).ToList();
Assert.Equal(100, rows.Count);
Assert.Equal(Guid.Parse("78DE23D2-DCB6-BD3D-EC67-C112BBC322A2"), rows[0].ID);
Assert.Equal("Wade", rows[0].Name);
Assert.Equal(DateTime.ParseExact("27/09/2020", "dd/MM/yyyy", CultureInfo.InvariantCulture), rows[0].BoD);
Assert.Equal(36, rows[0].Age);
Assert.False(rows[0].VIP);
Assert.Equal(5019.12m, rows[0].Points);
Assert.Equal(1, rows[0].IgnoredProperty);
}
{
using (var stream = File.OpenRead(path))
{
var rows = stream.Query<UserAccount>().ToList();
Assert.Equal(100, rows.Count);
Assert.Equal(Guid.Parse("78DE23D2-DCB6-BD3D-EC67-C112BBC322A2"), rows[0].ID);
Assert.Equal("Wade", rows[0].Name);
Assert.Equal(DateTime.ParseExact("27/09/2020", "dd/MM/yyyy", CultureInfo.InvariantCulture), rows[0].BoD);
Assert.Equal(36, rows[0].Age);
Assert.False(rows[0].VIP);
Assert.Equal(5019.12m, rows[0].Points);
Assert.Equal(1, rows[0].IgnoredProperty);
}
}
}
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/226
/// Fix SaveAsByTemplate single column demension index error #226
/// </summary>
[Fact]
public void Issue226()
{
var path = PathHelper.GetTempPath();
var templatePath = PathHelper.GetFile("xlsx/TestIssue226.xlsx");
MiniExcel.SaveAsByTemplate(path, templatePath, new { employees = new[] { new { name = "123" }, new { name = "123" } } });
Assert.Equal("A1:A3", Helpers.GetFirstSheetDimensionRefValue(path));
}
/// <summary>
/// ASP.NET Webform gridview datasource can't use miniexcel queryasdatatable · Issue #223]
/// (https://github.com/shps951023/MiniExcel/issues/223)
/// </summary>
[Fact]
public void Issue223()
{
var value = new List<Dictionary<string, object>>()
{
new Dictionary<string, object>(){{"A",null},{"B",null}},
new Dictionary<string, object>(){{"A",123},{"B",new DateTime(2021,1,1)}},
new Dictionary<string, object>(){{"A",Guid.NewGuid()},{"B","HelloWorld"}},
};
var path = PathHelper.GetTempPath();
MiniExcel.SaveAs(path, value);
var dt = MiniExcel.QueryAsDataTable(path);
var columns = dt.Columns;
Assert.Equal(typeof(object), columns[0].DataType);
Assert.Equal(typeof(object), columns[1].DataType);
Assert.Equal(123.0, dt.Rows[1]["A"]);
Assert.Equal("HelloWorld", dt.Rows[2]["B"]);
}
/// <summary>
/// [Custom yyyy-MM-dd format not convert datetime · Issue #222]
/// (https://github.com/shps951023/MiniExcel/issues/222)
/// </summary>
[Fact]
public void Issue222()
{
var path = PathHelper.GetFile("xlsx/TestIssue222.xlsx");
var rows = MiniExcel.Query(path).ToList();
Assert.Equal(typeof(DateTime), rows[1].A.GetType());
Assert.Equal(new DateTime(2021, 4, 29), rows[1].A);
}
/// <summary>
/// Query Support StartCell #147
/// https://github.com/shps951023/MiniExcel/issues/147
/// </summary>
[Fact]
public void Issue147()
{
{
var path = PathHelper.GetFile("xlsx/TestIssue147.xlsx");
var rows = MiniExcel.Query(path, useHeaderRow: false, startCell: "C3", sheetName: "Sheet1").ToList();
Assert.Equal(new[] { "C", "D", "E" }, (rows[0] as IDictionary<string, object>).Keys);
Assert.Equal(new[] { "Column1", "Column2", "Column3" }, new[] { rows[0].C as string, rows[0].D as string, rows[0].E as string });
Assert.Equal(new[] { "C4", "D4", "E4" }, new[] { rows[1].C as string, rows[1].D as string, rows[1].E as string });
Assert.Equal(new[] { "C9", "D9", "E9" }, new[] { rows[6].C as string, rows[6].D as string, rows[6].E as string });
Assert.Equal(new[] { "C12", "D12", "E12" }, new[] { rows[9].C as string, rows[9].D as string, rows[9].E as string });
Assert.Equal(new[] { "C13", "D13", "E13" }, new[] { rows[10].C as string, rows[10].D as string, rows[10].E as string });
foreach (var i in new[] { 4, 5, 7, 8 })
Assert.Equal(expected: new[] { default, default, default(string) }, new[] { rows[i].C as string, rows[i].D as string, rows[i].E as string });
Assert.Equal(11, rows.Count);
var columns = MiniExcel.GetColumns(path, startCell: "C3");
Assert.Equal(new[] { "C", "D", "E" }, columns);
}
{
var path = PathHelper.GetFile("xlsx/TestIssue147.xlsx");
var rows = MiniExcel.Query(path, useHeaderRow: true, startCell: "C3", sheetName: "Sheet1").ToList();
Assert.Equal(new[] { "Column1", "Column2", "Column3" }, (rows[0] as IDictionary<string, object>).Keys);
Assert.Equal(new[] { "C4", "D4", "E4" }, new[] { rows[0].Column1 as string, rows[0].Column2 as string, rows[0].Column3 as string });
Assert.Equal(new[] { "C9", "D9", "E9" }, new[] { rows[5].Column1 as string, rows[5].Column2 as string, rows[5].Column3 as string });
Assert.Equal(new[] { "C12", "D12", "E12" }, new[] { rows[8].Column1 as string, rows[8].Column2 as string, rows[8].Column3 as string });
Assert.Equal(new[] { "C13", "D13", "E13" }, new[] { rows[9].Column1 as string, rows[9].Column2 as string, rows[9].Column3 as string });
foreach (var i in new[] { 3, 4, 6, 7 })
Assert.Equal(new[] { default, default, default(string) }, new[] { rows[i].Column1 as string, rows[i].Column2 as string, rows[i].Column3 as string });
Assert.Equal(10, rows.Count);
var columns = MiniExcel.GetColumns(path, useHeaderRow: true, startCell: "C3");
Assert.Equal(new[] { "Column1", "Column2", "Column3" }, columns);
}
}
/// <summary>
/// [Can SaveAs support iDataReader export to avoid the dataTable consuming too much memory · Issue #211 · shps951023/MiniExcel]
/// (https://github.com/shps951023/MiniExcel/issues/211)
/// </summary>
[Fact]
public void Issue211()
{
var path = PathHelper.GetTempPath();
var tempSqlitePath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.db");
var connectionString = $"Data Source={tempSqlitePath};Version=3;";
using (var connection = new SQLiteConnection(connectionString))
{
var reader = connection.ExecuteReader(@"select 1 Test1,2 Test2 union all select 3 , 4 union all select 5 ,6");
MiniExcel.SaveAs(path, reader);
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal(1.0, rows[0].Test1);
Assert.Equal(2.0, rows[0].Test2);
Assert.Equal(3.0, rows[1].Test1);
Assert.Equal(4.0, rows[1].Test2);
}
}
/// <summary>
/// [When reading Excel, can return IDataReader and DataTable to facilitate the import of database. Like ExcelDataReader provide reader.AsDataSet() · Issue #216 · shps951023/MiniExcel](https://github.com/shps951023/MiniExcel/issues/216)
/// </summary>
[Fact]
public void Issue216()
{
var path = PathHelper.GetTempPath();
var value = new[] { new { Test1 = "1", Test2 = 2 }, new { Test1 = "3", Test2 = 4 } };
MiniExcel.SaveAs(path, value);
{
var table = MiniExcel.QueryAsDataTable(path);
Assert.Equal("Test1", table.Columns[0].ColumnName);
Assert.Equal("Test2", table.Columns[1].ColumnName);
Assert.Equal("1", table.Rows[0]["Test1"]);
Assert.Equal(2.0, table.Rows[0]["Test2"]);
Assert.Equal("3", table.Rows[1]["Test1"]);
Assert.Equal(4.0, table.Rows[1]["Test2"]);
}
{
var dt = MiniExcel.QueryAsDataTable(path, false);
Assert.Equal("Test1", dt.Rows[0]["A"]);
Assert.Equal("Test2", dt.Rows[0]["B"]);
Assert.Equal("1", dt.Rows[1]["A"]);
Assert.Equal(2.0, dt.Rows[1]["B"]);
Assert.Equal("3", dt.Rows[2]["A"]);
Assert.Equal(4.0, dt.Rows[2]["B"]);
}
}
/// <summary>
/// https://gitee.com/dotnetchina/MiniExcel/issues/I3OSKV
/// When exporting, the pure numeric string will be forcibly converted to a numeric type, resulting in the loss of the end data
/// </summary>
[Fact]
public void IssueI3OSKV()
{
{
var path = PathHelper.GetTempPath();
var value = new[] { new { Test = "12345678901234567890" } };
MiniExcel.SaveAs(path, value);
var A2 = MiniExcel.Query(path, true).First().Test;
Assert.Equal("12345678901234567890", A2);
File.Delete(path);
}
{
var path = PathHelper.GetTempPath();
var value = new[] { new { Test = 123456.789 } };
MiniExcel.SaveAs(path, value);
var A2 = MiniExcel.Query(path, true).First().Test;
Assert.Equal(123456.789, A2);
File.Delete(path);
}
}
/// <summary>
/// [Dynamic Query can't summary numeric cell value default, need to cast · Issue #220 · shps951023/MiniExcel]
/// (https://github.com/shps951023/MiniExcel/issues/220)
/// </summary>
[Fact]
public void Issue220()
{
var path = PathHelper.GetFile("xlsx/TestIssue220.xlsx");
var rows = MiniExcel.Query(path, useHeaderRow: true);
var result = (from s in rows
group s by s.PRT_ID into g
select new
{
PRT_ID = g.Key,
Apr = g.Sum(_ => (double?)_.Apr),
May = g.Sum(_ => (double?)_.May),
Jun = g.Sum(_ => (double?)_.Jun),
}
).ToList();
Assert.Equal(91843.25, result[0].Jun);
Assert.Equal(50000.99, result[1].Jun);
}
/// <summary>
/// Optimize stream excel type check
/// https://github.com/shps951023/MiniExcel/issues/215
/// </summary>
[Fact]
public void Issue215()
{
using (var stream = new MemoryStream())
{
stream.SaveAs(new[] { new { V = "test1" }, new { V = "test2" } });
var rows = stream.Query(true).ToList();
Assert.Equal("test1", rows[0].V);
Assert.Equal("test2", rows[1].V);
}
}
/// <summary>
/// Support Enum Mapping
/// https://github.com/shps951023/MiniExcel/issues/89
/// </summary>
[Fact]
public void Issue89()
{
//csv
{
var text = @"State
OnDuty
Fired
Leave";
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer.Write(text);
writer.Flush();
stream.Position = 0;
var rows = MiniExcel.Query<Issue89VO>(stream, excelType: ExcelType.CSV).ToList();
Assert.Equal(Issue89VO.WorkState.OnDuty, rows[0].State);
Assert.Equal(Issue89VO.WorkState.Fired, rows[1].State);
Assert.Equal(Issue89VO.WorkState.Leave, rows[2].State);
var outputPath = PathHelper.GetTempPath("xlsx");
MiniExcel.SaveAs(outputPath, rows);
var rows2 = MiniExcel.Query<Issue89VO>(outputPath).ToList();
Assert.Equal(Issue89VO.WorkState.OnDuty, rows2[0].State);
Assert.Equal(Issue89VO.WorkState.Fired, rows2[1].State);
Assert.Equal(Issue89VO.WorkState.Leave, rows2[2].State);
}
//xlsx
{
var path = PathHelper.GetFile("xlsx/TestIssue89.xlsx");
var rows = MiniExcel.Query<Issue89VO>(path).ToList();
Assert.Equal(Issue89VO.WorkState.OnDuty, rows[0].State);
Assert.Equal(Issue89VO.WorkState.Fired, rows[1].State);
Assert.Equal(Issue89VO.WorkState.Leave, rows[2].State);
var outputPath = PathHelper.GetTempPath();
MiniExcel.SaveAs(outputPath, rows);
var rows2 = MiniExcel.Query<Issue89VO>(outputPath).ToList();
Assert.Equal(Issue89VO.WorkState.OnDuty, rows2[0].State);
Assert.Equal(Issue89VO.WorkState.Fired, rows2[1].State);
Assert.Equal(Issue89VO.WorkState.Leave, rows2[2].State);
}
}
public class Issue89VO
{
public WorkState State { get; set; }
public enum WorkState
{
OnDuty,
Leave,
Fired
}
}
/// <summary>
/// DataTable recommended to use Caption for column name first, then use columname
/// https://github.com/shps951023/MiniExcel/issues/217
/// </summary>
[Fact]
public void Issue217()
{
var table = new DataTable();
table.Columns.Add("CustomerID");
table.Columns.Add("CustomerName").Caption = "Name";
table.Columns.Add("CreditLimit").Caption = "Limit";
table.Rows.Add(new object[] { 1, "Jonathan", 23.44 });
table.Rows.Add(new object[] { 2, "Bill", 56.87 });
// openxml
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
MiniExcel.SaveAs(path, table);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("Name", rows[0].B);
Assert.Equal("Limit", rows[0].C);
File.Delete(path);
}
// csv
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.csv");
MiniExcel.SaveAs(path, table);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("Name", rows[0].B);
Assert.Equal("Limit", rows[0].C);
File.Delete(path);
}
}
/// <summary>
/// MiniExcel.SaveAs(path, table,sheetName:“Name”) ，the actual sheetName is Sheet1
/// https://github.com/shps951023/MiniExcel/issues/212
/// </summary>
[Fact]
public void Issue212()
{
var sheetName = "Demo";
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
MiniExcel.SaveAs(path, new[] { new { x = 1, y = 2 } }, sheetName: sheetName);
var actualSheetName = MiniExcel.GetSheetNames(path).ToList()[0];
Assert.Equal(sheetName, actualSheetName);
File.Delete(path);
}
/// <summary>
/// Version <= v0.13.1 Template merge row list rendering has no merge
/// https://github.com/shps951023/MiniExcel/issues/207
/// </summary>
[Fact]
public void Issue207()
{
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
var tempaltePath = @"../../../../../samples/xlsx/TestIssue207_2.xlsx";
var value = new
{
project = new[] {
new {name = "項目1",content="[]內容1,[]內容2,[]內容3,[]內容4,[]內容5"},
new {name = "項目2",content="[]內容1,[]內容2,[]內容3,[]內容4,[]內容5"},
new {name = "項目3",content="[]內容1,[]內容2,[]內容3,[]內容4,[]內容5"},
new {name = "項目4",content="[]內容1,[]內容2,[]內容3,[]內容4,[]內容5"},
}
};
MiniExcel.SaveAsByTemplate(path, tempaltePath, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("項目1", rows[0].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[0].B);
Assert.Equal("項目2", rows[2].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[2].B);
Assert.Equal("項目3", rows[4].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[4].B);
Assert.Equal("項目4", rows[6].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[6].B);
Assert.Equal("Test1", rows[8].A);
Assert.Equal("Test2", rows[8].B);
Assert.Equal("Test3", rows[8].C);
Assert.Equal("項目1", rows[12].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[12].B);
Assert.Equal("項目2", rows[13].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[13].B);
Assert.Equal("項目3", rows[14].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[14].B);
Assert.Equal("項目4", rows[15].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[15].B);
var demension = Helpers.GetFirstSheetDimensionRefValue(path);
Assert.Equal("A1:C16", demension);
File.Delete(path);
}
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
var tempaltePath = @"../../../../../samples/xlsx/TestIssue207_Template_Merge_row_list_rendering_without_merge/template.xlsx";
var value = new
{
project = new[] {
new {name = "項目1",content="[]內容1,[]內容2,[]內容3,[]內容4,[]內容5"},
new {name = "項目2",content="[]內容1,[]內容2,[]內容3,[]內容4,[]內容5"},
new {name = "項目3",content="[]內容1,[]內容2,[]內容3,[]內容4,[]內容5"},
new {name = "項目4",content="[]內容1,[]內容2,[]內容3,[]內容4,[]內容5"},
}
};
MiniExcel.SaveAsByTemplate(path, tempaltePath, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("項目1", rows[0].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[0].C);
Assert.Equal("項目2", rows[3].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[3].C);
Assert.Equal("項目3", rows[6].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[6].C);
Assert.Equal("項目4", rows[9].A);
Assert.Equal("[]內容1,[]內容2,[]內容3,[]內容4,[]內容5", rows[9].C);
var demension = Helpers.GetFirstSheetDimensionRefValue(path);
Assert.Equal("A1:E15", demension);
File.Delete(path);
}
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/87
/// </summary>
[Fact]
public void Issue87()
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
var templatePath = @"../../../../../samples/xlsx/TestTemplateCenterEmpty.xlsx";
var value = new
{
Tests = Enumerable.Range(1, 5).Select((s, i) => new { test1 = i, test2 = i })
};
using (var stream = File.OpenRead(templatePath))
{
var rows = MiniExcel.Query(templatePath).ToList();
MiniExcel.SaveAsByTemplate(path, templatePath, value);
}
File.Delete(path);
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/208
/// </summary>
[Fact]
public void Issue208()
{
var path = @"../../../../../samples/xlsx/TestIssue208.xlsx";
var columns = MiniExcel.GetColumns(path).ToList();
Assert.Equal(16384, columns.Count);
Assert.Equal("XFD", columns[16383]);
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/206
/// </summary>
[Fact]
public void Issue206()
{
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
var templatePath = @"../../../../../samples/xlsx/TestTemplateBasicIEmumerableFill.xlsx";
var dt = new DataTable();
{
dt.Columns.Add("name");
dt.Columns.Add("department");
}
var value = new Dictionary<string, object>()
{
["employees"] = dt
};
MiniExcel.SaveAsByTemplate(path, templatePath, value);
var demension = Helpers.GetFirstSheetDimensionRefValue(path);
Assert.Equal("A1:B2", demension);
File.Delete(path);
}
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
var templatePath = @"../../../../../samples/xlsx/TestTemplateBasicIEmumerableFill.xlsx";
var dt = new DataTable();
{
dt.Columns.Add("name");
dt.Columns.Add("department");
dt.Rows.Add("Jack", "HR");
}
var value = new Dictionary<string, object>()
{
["employees"] = dt
};
MiniExcel.SaveAsByTemplate(path, templatePath, value);
var demension = Helpers.GetFirstSheetDimensionRefValue(path);
Assert.Equal("A1:B2", demension);
File.Delete(path);
}
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/193
/// </summary>
[Fact]
public void Issue193()
{
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
var templatePath = @"../../../../../samples/xlsx/TestTemplateComplexWithNamespacePrefix.xlsx";
// 1. By Class
var value = new
{
title = "FooCompany",
managers = new[] {
new {name="Jack",department="HR"},
new {name="Loan",department="IT"}
},
employees = new[] {
new {name="Wade",department="HR"},
new {name="Felix",department="HR"},
new {name="Eric",department="IT"},
new {name="Keaton",department="IT"}
}
};
MiniExcel.SaveAsByTemplate(path, templatePath, value);
foreach (var sheetName in MiniExcel.GetSheetNames(path))
{
var rows = MiniExcel.Query(path, sheetName: sheetName).ToList();
Assert.Equal(9, rows.Count);
Assert.Equal("FooCompany", rows[0].A);
Assert.Equal("Jack", rows[2].B);
Assert.Equal("HR", rows[2].C);
Assert.Equal("Loan", rows[3].B);
Assert.Equal("IT", rows[3].C);
Assert.Equal("Wade", rows[5].B);
Assert.Equal("HR", rows[5].C);
Assert.Equal("Felix", rows[6].B);
Assert.Equal("HR", rows[6].C);
Assert.Equal("Eric", rows[7].B);
Assert.Equal("IT", rows[7].C);
Assert.Equal("Keaton", rows[8].B);
Assert.Equal("IT", rows[8].C);
var demension = Helpers.GetFirstSheetDimensionRefValue(path);
Assert.Equal("A1:C9", demension);
//TODO:row can't contain xmlns
//![image](https://user-images.githubusercontent.com/12729184/114998840-ead44500-9ed3-11eb-8611-58afb98faed9.png)
}
File.Delete(path);
}
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
var templatePath = @"../../../../../samples/xlsx/TestTemplateComplex.xlsx";
// 2. By Dictionary
var value = new Dictionary<string, object>()
{
["title"] = "FooCompany",
["managers"] = new[] {
new {name="Jack",department="HR"},
new {name="Loan",department="IT"}
},
["employees"] = new[] {
new {name="Wade",department="HR"},
new {name="Felix",department="HR"},
new {name="Eric",department="IT"},
new {name="Keaton",department="IT"}
}
};
MiniExcel.SaveAsByTemplate(path, templatePath, value);
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("FooCompany", rows[0].A);
Assert.Equal("Jack", rows[2].B);
Assert.Equal("HR", rows[2].C);
Assert.Equal("Loan", rows[3].B);
Assert.Equal("IT", rows[3].C);
Assert.Equal("Wade", rows[5].B);
Assert.Equal("HR", rows[5].C);
Assert.Equal("Felix", rows[6].B);
Assert.Equal("HR", rows[6].C);
Assert.Equal("Eric", rows[7].B);
Assert.Equal("IT", rows[7].C);
Assert.Equal("Keaton", rows[8].B);
Assert.Equal("IT", rows[8].C);
var demension = Helpers.GetFirstSheetDimensionRefValue(path);
Assert.Equal("A1:C9", demension);
File.Delete(path);
}
}
[Fact]
public void Issue142()
{
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
MiniExcel.SaveAs(path, new Issue142VO[] { new Issue142VO { MyProperty1 = "MyProperty1", MyProperty2 = "MyProperty2", MyProperty3 = "MyProperty3", MyProperty4 = "MyProperty4", MyProperty5 = "MyProperty5", MyProperty6 = "MyProperty6", MyProperty7 = "MyProperty7" } });
{
var rows = MiniExcel.Query(path).ToList();
Assert.Equal("MyProperty4", rows[0].A);
Assert.Equal("CustomColumnName", rows[0].B); //note
Assert.Equal("MyProperty5", rows[0].C);
Assert.Equal("MyProperty2", rows[0].D);
Assert.Equal("MyProperty6", rows[0].E);
Assert.Equal(null, rows[0].F);
Assert.Equal("MyProperty3", rows[0].G);
Assert.Equal("MyProperty4", rows[0].A);
Assert.Equal("CustomColumnName", rows[0].B); //note
Assert.Equal("MyProperty5", rows[0].C);
Assert.Equal("MyProperty2", rows[0].D);
Assert.Equal("MyProperty6", rows[0].E);
Assert.Equal(null, rows[0].F);
Assert.Equal("MyProperty3", rows[0].G);
}
{
var rows = MiniExcel.Query<Issue142VO>(path).ToList();
Assert.Equal("MyProperty4", rows[0].MyProperty4);
Assert.Equal("MyProperty1", rows[0].MyProperty1); //note
Assert.Equal("MyProperty5", rows[0].MyProperty5);
Assert.Equal("MyProperty2", rows[0].MyProperty2);
Assert.Equal("MyProperty6", rows[0].MyProperty6);
Assert.Null(rows[0].MyProperty7);
Assert.Equal("MyProperty3", rows[0].MyProperty3);
}
File.Delete(path);
}
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.csv");
MiniExcel.SaveAs(path, new Issue142VO[] { new Issue142VO { MyProperty1 = "MyProperty1", MyProperty2 = "MyProperty2", MyProperty3 = "MyProperty3", MyProperty4 = "MyProperty4", MyProperty5 = "MyProperty5", MyProperty6 = "MyProperty6", MyProperty7 = "MyProperty7" } });
var expected = @"MyProperty4,CustomColumnName,MyProperty5,MyProperty2,MyProperty6,,MyProperty3
MyProperty4,MyProperty1,MyProperty5,MyProperty2,MyProperty6,,MyProperty3
";
Assert.Equal(expected, File.ReadAllText(path));
{
var rows = MiniExcel.Query<Issue142VO>(path).ToList();
Assert.Equal("MyProperty4", rows[0].MyProperty4);
Assert.Equal("MyProperty1", rows[0].MyProperty1); //note
Assert.Equal("MyProperty5", rows[0].MyProperty5);
Assert.Equal("MyProperty2", rows[0].MyProperty2);
Assert.Equal("MyProperty6", rows[0].MyProperty6);
Assert.Null(rows[0].MyProperty7);
Assert.Equal("MyProperty3", rows[0].MyProperty3);
}
File.Delete(path);
}
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.csv");
var input = new Issue142VoDuplicateColumnName[] { new Issue142VoDuplicateColumnName { } };
Assert.Throws<InvalidOperationException>(() => MiniExcel.SaveAs(path, input));
}
}
[Fact]
public void Issue142_Query()
{
{
var path = @"../../../../../samples/xlsx/TestIssue142.xlsx";
var rows = MiniExcel.Query<Issue142VoExcelColumnNameNotFound>(path).ToList();
Assert.Equal(0, rows[0].MyProperty1);
}
{
var path = @"../../../../../samples/xlsx/TestIssue142.xlsx";
Assert.Throws<ArgumentException>(() => MiniExcel.Query<Issue142VoOverIndex>(path).ToList());
}
{
var path = @"../../../../../samples/xlsx/TestIssue142.xlsx";
var rows = MiniExcel.Query<Issue142VO>(path).ToList();
Assert.Equal("CustomColumnName", rows[0].MyProperty1);
Assert.Null(rows[0].MyProperty7);
Assert.Equal("MyProperty2", rows[0].MyProperty2);
Assert.Equal("MyProperty103", rows[0].MyProperty3);
Assert.Equal("MyProperty100", rows[0].MyProperty4);
Assert.Equal("MyProperty102", rows[0].MyProperty5);
Assert.Equal("MyProperty6", rows[0].MyProperty6);
}
{
var path = @"../../../../../samples/csv/TestIssue142.csv";
var rows = MiniExcel.Query<Issue142VO>(path).ToList();
Assert.Equal("CustomColumnName", rows[0].MyProperty1);
Assert.Null(rows[0].MyProperty7);
Assert.Equal("MyProperty2", rows[0].MyProperty2);
Assert.Equal("MyProperty103", rows[0].MyProperty3);
Assert.Equal("MyProperty100", rows[0].MyProperty4);
Assert.Equal("MyProperty102", rows[0].MyProperty5);
Assert.Equal("MyProperty6", rows[0].MyProperty6);
}
}
public class Issue142VO
{
[ExcelColumnName("CustomColumnName")]
public string MyProperty1 { get; set; } //index = 1
[ExcelIgnore]
public string MyProperty7 { get; set; } //index = null
public string MyProperty2 { get; set; } //index = 3
[ExcelColumnIndex(6)]
public string MyProperty3 { get; set; } //index = 6
[ExcelColumnIndex("A")] // equal column index 0
public string MyProperty4 { get; set; }
[ExcelColumnIndex(2)]
public string MyProperty5 { get; set; } //index = 2
public string MyProperty6 { get; set; } //index = 4
}
public class Issue142VoDuplicateColumnName
{
[ExcelColumnIndex("A")]
public int MyProperty1 { get; set; }
[ExcelColumnIndex("A")]
public int MyProperty2 { get; set; }
public int MyProperty3 { get; set; }
[ExcelColumnIndex("B")]
public int MyProperty4 { get; set; }
}
public class Issue142VoOverIndex
{
[ExcelColumnIndex("Z")]
public int MyProperty1 { get; set; }
}
public class Issue142VoExcelColumnNameNotFound
{
[ExcelColumnIndex("B")]
public int MyProperty1 { get; set; }
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/150
/// </summary>
[Fact]
public void Issue150()
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
//MiniExcel.SaveAs(path, new[] { "1", "2" });
Assert.Throws<NotImplementedException>(() => MiniExcel.SaveAs(path, new[] { 1, 2 }));
File.Delete(path);
Assert.Throws<NotImplementedException>(() => MiniExcel.SaveAs(path, new[] { "1", "2" }));
File.Delete(path);
Assert.Throws<NotImplementedException>(() => MiniExcel.SaveAs(path, new[] { '1', '2' }));
File.Delete(path);
Assert.Throws<NotImplementedException>(() => MiniExcel.SaveAs(path, new[] { DateTime.Now }));
File.Delete(path);
Assert.Throws<NotImplementedException>(() => MiniExcel.SaveAs(path, new[] { Guid.NewGuid() }));
File.Delete(path);
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/157
/// </summary>
[Fact]
public void Issue157()
{
{
var path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
Console.WriteLine("==== SaveAs by strongly type ====");
var input = JsonConvert.DeserializeObject<IEnumerable<UserAccount>>("[{\"ID\":\"78de23d2-dcb6-bd3d-ec67-c112bbc322a2\",\"Name\":\"Wade\",\"BoD\":\"2020-09-27T00:00:00\",\"Age\":5019,\"VIP\":false,\"Points\":5019.12,\"IgnoredProperty\":null},{\"ID\":\"20d3bfce-27c3-ad3e-4f70-35c81c7e8e45\",\"Name\":\"Felix\",\"BoD\":\"2020-10-25T00:00:00\",\"Age\":7028,\"VIP\":true,\"Points\":7028.46,\"IgnoredProperty\":null},{\"ID\":\"52013bf0-9aeb-48e6-e5f5-e9500afb034f\",\"Name\":\"Phelan\",\"BoD\":\"2021-10-04T00:00:00\",\"Age\":3836,\"VIP\":true,\"Points\":3835.7,\"IgnoredProperty\":null},{\"ID\":\"3b97b87c-7afe-664f-1af5-6914d313ae25\",\"Name\":\"Samuel\",\"BoD\":\"2020-06-21T00:00:00\",\"Age\":9352,\"VIP\":false,\"Points\":9351.71,\"IgnoredProperty\":null},{\"ID\":\"9a989c43-d55f-5306-0d2f-0fbafae135bb\",\"Name\":\"Raymond\",\"BoD\":\"2021-07-12T00:00:00\",\"Age\":8210,\"VIP\":true,\"Points\":8209.76,\"IgnoredProperty\":null}]");
MiniExcel.SaveAs(path, input);
var rows = MiniExcel.Query(path, sheetName: "Sheet1").ToList();
Assert.Equal(6, rows.Count);
Assert.Equal("Sheet1", MiniExcel.GetSheetNames(path).First());
using var p = new ExcelPackage(new FileInfo(path));
var ws = p.Workbook.Worksheets.First();
Assert.Equal("Sheet1", ws.Name);
Assert.Equal("Sheet1", p.Workbook.Worksheets["Sheet1"].Name);
}
{
var path = @"../../../../../samples/xlsx/TestIssue157.xlsx";
{
var rows = MiniExcel.Query(path, sheetName: "Sheet1").ToList();
Assert.Equal(6, rows.Count);
Assert.Equal("Sheet1", MiniExcel.GetSheetNames(path).First());
}
using (var p = new ExcelPackage(new FileInfo(path)))
{
var ws = p.Workbook.Worksheets.First();
Assert.Equal("Sheet1", ws.Name);
Assert.Equal("Sheet1", p.Workbook.Worksheets["Sheet1"].Name);
}
using (var stream = File.OpenRead(path))
{
var rows = MiniExcel.Query<UserAccount>(path, sheetName: "Sheet1").ToList();
Assert.Equal(5, rows.Count);
Assert.Equal(Guid.Parse("78DE23D2-DCB6-BD3D-EC67-C112BBC322A2"), rows[0].ID);
Assert.Equal("Wade", rows[0].Name);
Assert.Equal(DateTime.ParseExact("27/09/2020", "dd/MM/yyyy", CultureInfo.InvariantCulture), rows[0].BoD);
Assert.False(rows[0].VIP);
Assert.Equal(5019m, rows[0].Points);
Assert.Equal(1, rows[0].IgnoredProperty);
}
}
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/149
/// </summary>
[Fact]
public void Issue149()
{
var chars = new char[] {'\u0000','\u0001','\u0002','\u0003','\u0004','\u0005','\u0006','\u0007','\u0008',
'\u0009', //<HT>
'\u000A', //<LF>
'\u000B','\u000C',
'\u000D', //<CR>
'\u000E','\u000F','\u0010','\u0011','\u0012','\u0013','\u0014','\u0015','\u0016',
'\u0017','\u0018','\u0019','\u001A','\u001B','\u001C','\u001D','\u001E','\u001F','\u007F'
}.Select(s => s.ToString()).ToArray();
{
var path = @"../../../../../samples/xlsx/TestIssue149.xlsx";
var rows = MiniExcel.Query(path).Select(s => (string)s.A).ToList();
for (int i = 0; i < chars.Length; i++)
{
//output.WriteLine($"{i} , {chars[i]} , {rows[i]}");
if (i == 13)
continue;
Assert.Equal(chars[i], rows[i]);
}
}
{
string path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
var input = chars.Select(s => new { Test = s.ToString() });
MiniExcel.SaveAs(path, input);
var rows = MiniExcel.Query(path, true).Select(s => (string)s.Test).ToList();
for (int i = 0; i < chars.Length; i++)
{
output.WriteLine($"{i} , {chars[i]} , {rows[i]}");
if (i == 13 || i == 9 || i == 10)
continue;
Assert.Equal(chars[i], rows[i]);
}
}
{
string path = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.xlsx");
var input = chars.Select(s => new { Test = s.ToString() });
MiniExcel.SaveAs(path, input);
var rows = MiniExcel.Query<Issue149VO>(path).Select(s => (string)s.Test).ToList();
for (int i = 0; i < chars.Length; i++)
{
output.WriteLine($"{i} , {chars[i]} , {rows[i]}");
if (i == 13 || i == 9 || i == 10)
continue;
Assert.Equal(chars[i], rows[i]);
}
}
}
public class Issue149VO
{
public string Test { get; set; }
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/153
/// </summary>
[Fact]
public void Issue153()
{
var path = @"../../../../../samples/xlsx/TestIssue153.xlsx";
var rows = MiniExcel.Query(path, true).First() as IDictionary<string, object>;
Assert.Equal(new[] { "序号", "代号", "新代号", "名称", "XXX", "部门名称", "单位", "ERP工时 (小时)A", "工时(秒) A/3600", "标准人工工时(秒)", "生产标准机器工时(秒)", "财务、标准机器工时(秒)", "更新日期", "产品机种", "备注", "最近一次修改前的标准工时(秒)", "最近一次修改前的标准机时(秒)", "备注1" }
, rows.Keys);
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/137
/// </summary>
[Fact]
public void Issue137()
{
var path = @"../../../../../samples/xlsx/TestIssue137.xlsx";
{
var rows = MiniExcel.Query(path).ToList();
var first = rows[0] as IDictionary<string, object>; //![image](https://user-images.githubusercontent.com/12729184/113266322-ba06e400-9307-11eb-9521-d36abfda75cc.png)
Assert.Equal(new[] { "A", "B", "C", "D", "E", "F", "G", "H" }, first.Keys.ToArray());
Assert.Equal(11, rows.Count);
{
var row = rows[0] as IDictionary<string, object>;
Assert.Equal("比例", row["A"]);
Assert.Equal("商品", row["B"]);
Assert.Equal("滿倉口數", row["C"]);
Assert.Equal(" ", row["D"]);
Assert.Equal(" ", row["E"]);
Assert.Equal(" ", row["F"]);
Assert.Equal(0.0, row["G"]);
Assert.Equal("1為港幣 0為台幣", row["H"]);
}
{
var row = rows[1] as IDictionary<string, object>;
Assert.Equal(1.0, row["A"]);
Assert.Equal("MTX", row["B"]);
Assert.Equal(10.0, row["C"]);
Assert.Null(row["D"]);
Assert.Null(row["E"]);
Assert.Null(row["F"]);
Assert.Null(row["G"]);
Assert.Null(row["H"]);
}
{
var row = rows[2] as IDictionary<string, object>;
Assert.Equal(0.95, row["A"]);
}
}
// dynamic query with head
{
var rows = MiniExcel.Query(path, true).ToList();
var first = rows[0] as IDictionary<string, object>; //![image](https://user-images.githubusercontent.com/12729184/113266322-ba06e400-9307-11eb-9521-d36abfda75cc.png)
Assert.Equal(new[] { "比例", "商品", "滿倉口數", "0", "1為港幣 0為台幣" }, first.Keys.ToArray());
Assert.Equal(10, rows.Count);
{
var row = rows[0] as IDictionary<string, object>;
Assert.Equal(1.0, row["比例"]);
Assert.Equal("MTX", row["商品"]);
Assert.Equal(10.0, row["滿倉口數"]);
Assert.Null(row["0"]);
Assert.Null(row["1為港幣 0為台幣"]);
}
{
var row = rows[1] as IDictionary<string, object>;
Assert.Equal(0.95, row["比例"]);
}
}
{
var rows = MiniExcel.Query<Issue137ExcelRow>(path).ToList();
Assert.Equal(10, rows.Count);
{
var row = rows[0];
Assert.Equal(1, row.比例);
Assert.Equal("MTX", row.商品);
Assert.Equal(10, row.滿倉口數);
}
{
var row = rows[1];
Assert.Equal(0.95, row.比例);
}
}
}
public class Issue137ExcelRow
{
public double? 比例 { get; set; }
public string 商品 { get; set; }
public int? 滿倉口數 { get; set; }
}
/// <summary>
/// https://github.com/shps951023/MiniExcel/issues/138
/// </summary>
[Fact]
public void Issue138()
{
var path = @"../../../../../samples/xlsx/TestIssue138.xlsx";
{
var rows = MiniExcel.Query(path, true).ToList();
Assert.Equal(6, rows.Count);
foreach (var index in new[] { 0, 2, 5 })
{
Assert.Equal(1, rows[index].實單每日損益);
Assert.Equal(2, rows[index].程式每日損益);
Assert.Equal("測試商品1", rows[index].商品);
Assert.Equal(111.11, rows[index].滿倉口數);
Assert.Equal(111.11, rows[index].波段);
Assert.Equal(111.11, rows[index].當沖);
}
foreach (var index in new[] { 1, 3, 4 })
{
Assert.Null(rows[index].實單每日損益);
Assert.Null(rows[index].程式每日損益);
Assert.Null(rows[index].商品);
Assert.Null(rows[index].滿倉口數);
Assert.Null(rows[index].波段);
Assert.Null(rows[index].當沖);
}
}
{
var rows = MiniExcel.Query<Issue138ExcelRow>(path).ToList();
Assert.Equal(6, rows.Count);
Assert.Equal(new DateTime(2021, 3, 1), rows[0].Date);
foreach (var index in new[] { 0, 2, 5 })
{
Assert.Equal(1, rows[index].實單每日損益);
Assert.Equal(2, rows[index].程式每日損益);
Assert.Equal("測試商品1", rows[index].商品);
Assert.Equal(111.11, rows[index].滿倉口數);
Assert.Equal(111.11, rows[index].波段);
Assert.Equal(111.11, rows[index].當沖);
}
foreach (var index in new[] { 1, 3, 4 })
{
Assert.Null(rows[index].實單每日損益);
Assert.Null(rows[index].程式每日損益);
Assert.Null(rows[index].商品);
Assert.Null(rows[index].滿倉口數);
Assert.Null(rows[index].波段);
Assert.Null(rows[index].當沖);
}
}
}
public class Issue138ExcelRow
{
public DateTime? Date { get; set; }
public int? 實單每日損益 { get; set; }
public int? 程式每日損益 { get; set; }
public string 商品 { get; set; }
public double? 滿倉口數 { get; set; }
public double? 波段 { get; set; }
public double? 當沖 { get; set; }
}
/// <summary>
/// https://gitee.com/dotnetchina/MiniExcel/issues/I50VD5
/// </summary>
[Fact]
public void IssueI50VD5()
{
var path = PathHelper.GetTempFilePath();
var list1 = new List<dynamic>()
{
new { Name="github",Image=File.ReadAllBytes(PathHelper.GetFile("images/github_logo.png"))},
new { Name="google",Image=File.ReadAllBytes(PathHelper.GetFile("images/google_logo.png"))},
new { Name="microsoft",Image=File.ReadAllBytes(PathHelper.GetFile("images/microsoft_logo.png"))},
new { Name="reddit",Image=File.ReadAllBytes(PathHelper.GetFile("images/reddit_logo.png"))},
new { Name="statck_overflow",Image=File.ReadAllBytes(PathHelper.GetFile("images/statck_overflow_logo.png"))},
};
var list2 = new List<dynamic>()
{
new { Id = 1, Name="github",Image=File.ReadAllBytes(PathHelper.GetFile("images/github_logo.png"))},
new { Id = 2, Name="google",Image=File.ReadAllBytes(PathHelper.GetFile("images/google_logo.png"))},
};
var sheets = new Dictionary<string, object>
{
["A"] = list1,
["B"] = list2,
};
MiniExcel.SaveAs(path, sheets);
{
Assert.Contains("/xl/media/", Helpers.GetZipFileContent(path, "xl/drawings/_rels/drawing1.xml.rels"));
Assert.Contains("ext cx=\"609600\" cy=\"190500\"", Helpers.GetZipFileContent(path, "xl/drawings/drawing1.xml"));
Assert.Contains("/xl/drawings/drawing1.xml", Helpers.GetZipFileContent(path, "[Content_Types].xml"));
Assert.Contains("drawing r:id=\"drawing1\"", Helpers.GetZipFileContent(path, "xl/worksheets/sheet1.xml"));
Assert.Contains("../drawings/drawing1.xml", Helpers.GetZipFileContent(path, "xl/worksheets/_rels/sheet1.xml.rels"));
Assert.Contains("/xl/media/", Helpers.GetZipFileContent(path, "xl/drawings/_rels/drawing2.xml.rels"));
Assert.Contains("ext cx=\"609600\" cy=\"190500\"", Helpers.GetZipFileContent(path, "xl/drawings/drawing2.xml"));
Assert.Contains("/xl/drawings/drawing1.xml", Helpers.GetZipFileContent(path, "[Content_Types].xml"));
Assert.Contains("drawing r:id=\"drawing2\"", Helpers.GetZipFileContent(path, "xl/worksheets/sheet2.xml"));
Assert.Contains("../drawings/drawing2.xml", Helpers.GetZipFileContent(path, "xl/worksheets/_rels/sheet2.xml.rels"));
}
}
public class Issue422Enumerable : IEnumerable
{
public int GetEnumeratorCount { get; private set; }
private readonly IEnumerable _inner;
public Issue422Enumerable(IEnumerable inner)
{
_inner = inner;
}
public IEnumerator GetEnumerator()
{
GetEnumeratorCount++;
return _inner.GetEnumerator();
}
}
/// <summary>
/// https://github.com/mini-software/MiniExcel/issues/422
/// </summary>
[Fact]
public void Issue422()
{
var items = new[]
{
new { Row1 = "1", Row2 = "2" },
new { Row1 = "3", Row2 = "4" }
};
var enumerableWithCount = new Issue422Enumerable(items);
var path = PathHelper.GetTempFilePath();
MiniExcel.SaveAs(path, enumerableWithCount);
Assert.Equal(1, enumerableWithCount.GetEnumeratorCount);
}
public class Issue585VO1
{
public string Col1 { get; set; }
public string Col2 { get; set; }
public string Col3 { get; set; }
}
public class Issue585VO2
{
public string Col1 { get; set; }
[ExcelColumnName("Col2")]
public string Prop2 { get; set; }
public string Col3 { get; set; }
}
public class Issue585VO3
{
public string Col1 { get; set; }
[ExcelColumnIndex("B")]
public string Prop2 { get; set; }
public string Col3 { get; set; }
}
[Fact]
public void Issue585()
{
var path = @"../../../../../samples/xlsx/TestIssue585.xlsx";
var items1 = MiniExcel.Query<Issue585VO1>(path);
Assert.Equal(2, items1.Count());
var items2 = MiniExcel.Query<Issue585VO2>(path);
Assert.Equal(2, items2.Count());
var items3 = MiniExcel.Query<Issue585VO3>(path);
Assert.Equal(2, items3.Count());
}
class Issue507V01
{
public string A { get; set; }
public DateTime B { get; set; }
public string C { get; set; }
public int D { get; set; }
}
class Issue507V02 {
public DateTime B { get; set; }
public int D { get; set; }
}
[Fact]
public void Issue507_1()
{
//Problem with multi-line when using Query func
//https://github.com/mini-software/MiniExcel/issues/507
var path = Path.Combine(Path.GetTempPath(), string.Concat( nameof(MiniExcelIssueTests),"_", nameof(Issue507_1), ".csv" ));
var values = new Issue507V01[]
{
new() { A = "Github", B = DateTime.Parse("2021-01-01"), C = "abcd", D = 123 },
new() { A = "Microsoft \nTest 1", B = DateTime.Parse("2021-02-01"), C = "efgh", D = 123 },
new() { A = "Microsoft \rTest 2", B = DateTime.Parse("2021-02-01"), C = "ab\nc\nd", D = 123 },
new() { A = "Microsoft\"\" \r\nTest\n3", B = DateTime.Parse("2021-02-01"), C = "a\"\"\nb\n\nc", D = 123 },
};
var config = new CsvConfiguration()
{
//AlwaysQuote = true,
ReadLineBreaksWithinQuotes = true,
};
// create
using (var stream = File.Create(path))
{
stream.SaveAs(values, excelType: ExcelType.CSV, configuration: config);
}
// read
var getRowsInfo = MiniExcel.Query<Issue507V01>(path, excelType: ExcelType.CSV, configuration: config).ToArray();
Assert.Equal(values.Length, getRowsInfo.Count());
Assert.Equal("Github", getRowsInfo[0].A);
Assert.Equal("abcd", getRowsInfo[0].C);
Assert.Equal(@$"Microsoft {config.NewLine}Test 1", getRowsInfo[1].A);
Assert.Equal("efgh", getRowsInfo[1].C);
Assert.Equal(@$"Microsoft {config.NewLine}Test 2", getRowsInfo[2].A);
Assert.Equal($"ab{config.NewLine}c{config.NewLine}d", getRowsInfo[2].C);
Assert.Equal(@$"Microsoft"""" {config.NewLine}Test{config.NewLine}3", getRowsInfo[3].A);
Assert.Equal(@$"a""""{config.NewLine}b{config.NewLine}{config.NewLine}c", getRowsInfo[3].C);
}
[Fact]
public void Issue507_2() {
//Problem with multi-line when using Query func
//https://github.com/mini-software/MiniExcel/issues/507
var path = Path.Combine(Path.GetTempPath(), string.Concat(nameof(MiniExcelIssueTests), "_", nameof(Issue507_2), ".csv"));
var values = new Issue507V02[]
{
new() { B = DateTime.Parse("2021-01-01"), D = 123 },
new() { B = DateTime.Parse("2021-02-01"), D = 123 },
new() { B = DateTime.Parse("2021-02-01"), D = 123 },
new() { B = DateTime.Parse("2021-02-01"), D = 123 },
};
var config = new CsvConfiguration()
{
//AlwaysQuote = true,
ReadLineBreaksWithinQuotes = true,
};
// create
using (var stream = File.Create(path))
{
stream.SaveAs(values, excelType: ExcelType.CSV, configuration: config);
}
// read
var getRowsInfo = MiniExcel.Query<Issue507V02>(path, excelType: ExcelType.CSV, configuration: config).ToArray();
Assert.Equal(values.Length, getRowsInfo.Count());
}
[Fact]
public void Issue507_3_MismatchedQuoteCsv() {
//Problem with multi-line when using Query func
//https://github.com/mini-software/MiniExcel/issues/507
var config = new CsvConfiguration()
{
//AlwaysQuote = true,
ReadLineBreaksWithinQuotes = true,
};
var badCsv = "A,B,C\n\"r1a: no end quote,r1b,r1c";
// create
using var stream = new MemoryStream( Encoding.UTF8.GetBytes( badCsv ) );
// read
var getRowsInfo = MiniExcel.Query( stream, excelType: ExcelType.CSV, configuration: config ).ToArray();
Assert.Equal(2, getRowsInfo.Length );
}
[Fact]
public void Issue606_1()
{
// excel max rows: 1,048,576
// before changes: 1999999 => 25.8 GB mem
// after changes: 1999999 => peaks at 3.2 GB mem (10:20 min)
// after changes: 100000 => peaks at 222 MB mem (34 sec)
var value = new
{
Title = "My Title",
OrderInfo = Enumerable
.Range( 1, 100 )
.Select( x => new
{
Standard = "standard",
RegionName = "region",
DealerName = "department",
SalesPointName = "region",
CustomerName = "customer",
IdentityType = "aaaaaa",
IdentitySeries = "ssssss",
IdentityNumber = "nnnnn",
BirthDate = "date",
TariffPlanName = "plan",
PhoneNumber = "num",
SimCardIcc = "sss",
BisContractNumber = "eee",
CreatedAt = "dd.mm.yyyy",
UserDescription = "fhtyrhthrthrt",
UserName = "dfsfsdfds",
PaymentsAmount = "dfhgdfgadfgdfg",
OrderState = "agafgdafgadfgd",
})
};
var path = Path.Combine
(
Path.GetTempPath(),
string.Concat( nameof( MiniExcelIssueTests ), "_", nameof( Issue606_1 ), ".xlsx" )
);
var templateFileName = @"../../../../../samples/xlsx/TestIssue606_Template.xlsx";
MiniExcel.SaveAsByTemplate( path, Path.GetFullPath( templateFileName ), value );
}
[Fact]
public void Issue632_1()
{
//https://github.com/mini-software/MiniExcel/issues/632
var values = new List<Dictionary<string, object>>();
foreach ( var item in Enumerable.Range( 1, 100 ) ) {
var dict = new Dictionary<string, object>
{
{ "Id", item },
{ "Time", DateTime.Now.ToLocalTime() },
{ "CPU Usage (%)", Math.Round( 56.345, 1 ) },
{ "Memory Usage (%)", Math.Round( 98.234, 1 ) },
{ "Disk Usage (%)", Math.Round( 32.456, 1 ) },
{ "CPU Temperature (°C)", Math.Round( 74.234, 1 ) },
{ "Voltage (V)", Math.Round( 6.3223, 1 ) },
{ "Network Usage (Kb/s)", Math.Round( 4503.23422, 1 ) },
{ "Instrument", "QT800050" }
};
values.Add( dict );
}
var config = new OpenXmlConfiguration
{
TableStyles = TableStyles.None,
DynamicColumns = new DynamicExcelColumn[]
{
//new DynamicExcelColumn("Time") { Index = 0, Width = 20, Format = CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern + " " + CultureInfo.CurrentCulture.DateTimeFormat.LongTimePattern },
//new DynamicExcelColumn("Time") { Index = 0, Width = 20, Format = CultureInfo.InvariantCulture.DateTimeFormat.ShortDatePattern + " " + CultureInfo.InvariantCulture.DateTimeFormat.LongTimePattern },
//new DynamicExcelColumn("Time") { Index = 0, Width = 20 },
new DynamicExcelColumn("Time") { Index = 0, Width = 20, Format = "d.MM.yyyy" },
}
};
var path = Path.Combine(
Path.GetTempPath(),
string.Concat( nameof( MiniExcelIssueTests ), "_", nameof( Issue632_1 ), ".xlsx" )
);
MiniExcel.SaveAs( path, values, excelType: ExcelType.XLSX, configuration: config, overwriteFile: true );
}
private class Issue658TestData
{
public string FirstName { get; set; }
public string LastName { get; set; }
}
/// <summary>
/// https://github.com/mini-software/MiniExcel/issues/658
/// </summary>
[Fact]
public void Issue_658()
{
static IEnumerable<Issue658TestData> GetTestData()
{
yield return new() { FirstName = "Unit", LastName = "Test" };
yield return new() { FirstName = "Unit1", LastName = "Test1" };
yield return new() { FirstName = "Unit2", LastName = "Test2" };
}
using var memoryStream = new MemoryStream();
var testData = GetTestData();
memoryStream.SaveAs(testData, configuration: new OpenXmlConfiguration
{
FastMode = true,
});
memoryStream.Position = 0;
var queryData = memoryStream.Query<Issue658TestData>().ToList();
Assert.Equal(testData.Count(), queryData.Count);
var i = 0;
foreach (var data in testData)
{
Assert.Equal(data.FirstName, queryData[i].FirstName);
Assert.Equal(data.LastName, queryData[i].LastName);
i++;
}
}
/// <summary>
/// https://github.com/mini-software/MiniExcel/issues/658
/// </summary>
/// <returns></returns>
[Fact]
public async Task Issue_658_async()
{
static IEnumerable<Issue658TestData> GetTestData()
{
yield return new() { FirstName = "Unit", LastName = "Test" };
yield return new() { FirstName = "Unit1", LastName = "Test1" };
yield return new() { FirstName = "Unit2", LastName = "Test2" };
}
using var memoryStream = new MemoryStream();
var testData = GetTestData();
await memoryStream.SaveAsAsync(testData, configuration: new OpenXmlConfiguration
{
FastMode = true,
});
memoryStream.Position = 0;
var queryData = (await memoryStream.QueryAsync<Issue658TestData>()).ToList();
Assert.Equal(testData.Count(), queryData.Count);
var i = 0;
foreach (var data in testData)
{
Assert.Equal(data.FirstName, queryData[i].FirstName);
Assert.Equal(data.LastName, queryData[i].LastName);
i++;
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink