diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/ClosedXML_Tests.csproj b/ClosedXML/ClosedXML/ClosedXML_Tests/ClosedXML_Tests.csproj index ed9b2d6..91b7b38 100644 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/ClosedXML_Tests.csproj +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/ClosedXML_Tests.csproj @@ -74,28 +74,28 @@ - + - - - + + + - + - + - - + + - + @@ -104,16 +104,16 @@ - + - - + + - + diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RangeTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RangeTests.cs deleted file mode 100644 index 2569679..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RangeTests.cs +++ /dev/null @@ -1,98 +0,0 @@ -using ClosedXML_Examples; -using ClosedXML_Examples.Misc; -using ClosedXML_Examples.Ranges; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace ClosedXML_Tests.Examples -{ - [TestClass] - public class RangesTests - { - [TestMethod] - public void ClearingRanges() - { - TestHelper.RunTestExample(@"Ranges\ClearingRanges.xlsx"); - } - [TestMethod] - public void CopyingRanges() - { - TestHelper.RunTestExample(@"Ranges\CopyingRanges.xlsx"); - } - [TestMethod] - public void DefiningRanges() - { - TestHelper.RunTestExample(@"Ranges\DefiningRanges.xlsx"); - } - [TestMethod] - public void DeletingRanges() - { - TestHelper.RunTestExample(@"Ranges\DeletingRanges.xlsx"); - } - [TestMethod] - public void InsertingDeletingColumns() - { - TestHelper.RunTestExample(@"Ranges\InsertingDeletingColumns.xlsx"); - } - [TestMethod] - public void InsertingDeletingRows() - { - TestHelper.RunTestExample(@"Ranges\InsertingDeletingRows.xlsx"); - } - [TestMethod] - public void MultipleRanges() - { - TestHelper.RunTestExample(@"Ranges\MultipleRanges.xlsx"); - } - [TestMethod] - public void NamedRanges() - { - TestHelper.RunTestExample(@"Ranges\NamedRanges.xlsx"); - } - [TestMethod] - public void ShiftingRanges() - { - TestHelper.RunTestExample(@"Ranges\ShiftingRanges.xlsx"); - } - [TestMethod] - public void SortExample() - { - TestHelper.RunTestExample(@"Ranges\SortExample.xlsx"); - } - [TestMethod] - public void Sorting() - { - TestHelper.RunTestExample(@"Ranges\Sorting.xlsx"); - } - [TestMethod] - public void TransposeRanges() - { - TestHelper.RunTestExample(@"Ranges\TransposeRanges.xlsx"); - } - [TestMethod] - public void TransposeRangesPlus() - { - TestHelper.RunTestExample(@"Ranges\TransposeRangesPlus.xlsx"); - } - [TestMethod] - public void UsingTables() - { - TestHelper.RunTestExample(@"Ranges\UsingTables.xlsx"); - } - [TestMethod] - public void WalkingRanges() - { - TestHelper.RunTestExample(@"Ranges\WalkingRanges.xlsx"); - } - [TestMethod] - public void CurrentRowColumn() - { - TestHelper.RunTestExample(@"Ranges\CurrentRowColumn.xlsx"); - } - - [TestMethod] - public void SelectingRanges() - { - TestHelper.RunTestExample(@"Ranges\SelectingRanges.xlsx"); - } - } -} \ No newline at end of file diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RangesTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RangesTests.cs new file mode 100644 index 0000000..2569679 --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RangesTests.cs @@ -0,0 +1,98 @@ +using ClosedXML_Examples; +using ClosedXML_Examples.Misc; +using ClosedXML_Examples.Ranges; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace ClosedXML_Tests.Examples +{ + [TestClass] + public class RangesTests + { + [TestMethod] + public void ClearingRanges() + { + TestHelper.RunTestExample(@"Ranges\ClearingRanges.xlsx"); + } + [TestMethod] + public void CopyingRanges() + { + TestHelper.RunTestExample(@"Ranges\CopyingRanges.xlsx"); + } + [TestMethod] + public void DefiningRanges() + { + TestHelper.RunTestExample(@"Ranges\DefiningRanges.xlsx"); + } + [TestMethod] + public void DeletingRanges() + { + TestHelper.RunTestExample(@"Ranges\DeletingRanges.xlsx"); + } + [TestMethod] + public void InsertingDeletingColumns() + { + TestHelper.RunTestExample(@"Ranges\InsertingDeletingColumns.xlsx"); + } + [TestMethod] + public void InsertingDeletingRows() + { + TestHelper.RunTestExample(@"Ranges\InsertingDeletingRows.xlsx"); + } + [TestMethod] + public void MultipleRanges() + { + TestHelper.RunTestExample(@"Ranges\MultipleRanges.xlsx"); + } + [TestMethod] + public void NamedRanges() + { + TestHelper.RunTestExample(@"Ranges\NamedRanges.xlsx"); + } + [TestMethod] + public void ShiftingRanges() + { + TestHelper.RunTestExample(@"Ranges\ShiftingRanges.xlsx"); + } + [TestMethod] + public void SortExample() + { + TestHelper.RunTestExample(@"Ranges\SortExample.xlsx"); + } + [TestMethod] + public void Sorting() + { + TestHelper.RunTestExample(@"Ranges\Sorting.xlsx"); + } + [TestMethod] + public void TransposeRanges() + { + TestHelper.RunTestExample(@"Ranges\TransposeRanges.xlsx"); + } + [TestMethod] + public void TransposeRangesPlus() + { + TestHelper.RunTestExample(@"Ranges\TransposeRangesPlus.xlsx"); + } + [TestMethod] + public void UsingTables() + { + TestHelper.RunTestExample(@"Ranges\UsingTables.xlsx"); + } + [TestMethod] + public void WalkingRanges() + { + TestHelper.RunTestExample(@"Ranges\WalkingRanges.xlsx"); + } + [TestMethod] + public void CurrentRowColumn() + { + TestHelper.RunTestExample(@"Ranges\CurrentRowColumn.xlsx"); + } + + [TestMethod] + public void SelectingRanges() + { + TestHelper.RunTestExample(@"Ranges\SelectingRanges.xlsx"); + } + } +} \ No newline at end of file diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/XLMathTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/XLMathTests.cs index 0f6eb6c..f310d2a 100644 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/XLMathTests.cs +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/XLMathTests.cs @@ -9,7 +9,7 @@ /// Summary description for UnitTest1 /// [TestClass] - public class Extensions + public class XLMathTests { [TestMethod] diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Cells/XLCellTest.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Cells/XLCellTest.cs deleted file mode 100644 index 4e174c5..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Cells/XLCellTest.cs +++ /dev/null @@ -1,300 +0,0 @@ -using System.Collections.Generic; -using ClosedXML.Excel; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Linq; -using System; - -namespace ClosedXML_Tests -{ - [TestClass] - public class XLCellTest - { - [TestMethod] - public void IsEmpty1() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - var actual = cell.IsEmpty(); - var expected = true; - Assert.AreEqual(expected, actual); - } - - [TestMethod] - public void IsEmpty2() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - var actual = cell.IsEmpty(true); - var expected = true; - Assert.AreEqual(expected, actual); - } - - [TestMethod] - public void IsEmpty3() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.Style.Fill.BackgroundColor = XLColor.Red; - var actual = cell.IsEmpty(); - var expected = true; - Assert.AreEqual(expected, actual); - } - - [TestMethod] - public void IsEmpty4() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.Style.Fill.BackgroundColor = XLColor.Red; - var actual = cell.IsEmpty(false); - var expected = true; - Assert.AreEqual(expected, actual); - } - - [TestMethod] - public void IsEmpty5() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.Style.Fill.BackgroundColor = XLColor.Red; - var actual = cell.IsEmpty(true); - var expected = false; - Assert.AreEqual(expected, actual); - } - - [TestMethod] - public void IsEmpty6() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.Value = "X"; - var actual = cell.IsEmpty(); - var expected = false; - Assert.AreEqual(expected, actual); - } - - [TestMethod] - public void ValueSetToEmptyString() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.Value = new DateTime(2000, 1, 2); - cell.Value = String.Empty; - var actual = cell.GetString(); - var expected = String.Empty; - Assert.AreEqual(expected, actual); - } - - [TestMethod] - public void ValueSetToNull() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.Value = new DateTime(2000, 1, 2); - cell.Value = null; - var actual = cell.GetString(); - var expected = String.Empty; - Assert.AreEqual(expected, actual); - } - - [TestMethod] - public void InsertData1() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var range = ws.Cell(2, 2).InsertData(new[] {"a", "b", "c"}); - Assert.AreEqual("'Sheet1'!B2:B4", range.ToString()); - } - - [TestMethod] - public void CellsUsed() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - ws.Cell(1, 1); - ws.Cell(2, 2); - var count = ws.Range("A1:B2").CellsUsed().Count(); - Assert.AreEqual(0, count); - } - - [TestMethod] - public void TryGetValue_TimeSpan_Good() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - TimeSpan outValue; - var timeSpan = new TimeSpan(1, 1, 1); - var success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out outValue); - Assert.IsTrue(success); - Assert.AreEqual(timeSpan, outValue); - } - - [TestMethod] - public void TryGetValue_TimeSpan_BadString() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - TimeSpan outValue; - var timeSpan = "ABC"; - var success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out outValue); - Assert.IsFalse(success); - } - - [TestMethod] - public void TryGetValue_TimeSpan_GoodString() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - TimeSpan outValue; - var timeSpan = new TimeSpan(1, 1, 1); - var success = ws.Cell("A1").SetValue(timeSpan.ToString()).TryGetValue(out outValue); - Assert.IsTrue(success); - Assert.AreEqual(timeSpan, outValue); - } - - [TestMethod] - public void TryGetValue_RichText_Good() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText outValue; - var cell = ws.Cell("A1"); - cell.RichText.AddText("Anything"); - var success = cell.TryGetValue(out outValue); - Assert.IsTrue(success); - Assert.AreEqual(cell.RichText, outValue); - } - - [TestMethod] - public void TryGetValue_RichText_Bad() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - IXLRichText outValue; - var cell = ws.Cell("A1").SetValue("Anything"); - var success = cell.TryGetValue(out outValue); - Assert.IsTrue(success); - Assert.AreEqual(cell.RichText, outValue); - Assert.AreEqual("Anything", outValue.ToString()); - } - - [TestMethod] - public void TryGetValue_Boolean_True() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - Boolean outValue; - var cell = ws.Cell("A1").SetValue(true); - var success = cell.TryGetValue(out outValue); - Assert.IsTrue(success); - Assert.IsTrue(outValue); - } - - [TestMethod] - public void TryGetValue_Boolean_False() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - Boolean outValue; - var cell = ws.Cell("A1").SetValue(false); - var success = cell.TryGetValue(out outValue); - Assert.IsTrue(success); - Assert.IsFalse(outValue); - } - - [TestMethod] - public void TryGetValue_Boolean_Bad() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - Boolean outValue; - var cell = ws.Cell("A1").SetValue("ABC"); - var success = cell.TryGetValue(out outValue); - Assert.IsFalse(success); - } - - [TestMethod] - public void TryGetValue_Boolean_Good() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - Boolean outValue; - var cell = ws.Cell("A1").SetValue("True"); - var success = cell.TryGetValue(out outValue); - Assert.IsTrue(success); - Assert.IsTrue(outValue); - } - - [TestMethod] - public void TryGetValue_sbyte_Good() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - sbyte outValue; - var cell = ws.Cell("A1").SetValue(5); - var success = cell.TryGetValue(out outValue); - Assert.IsTrue(success); - Assert.AreEqual((sbyte)5, outValue); - } - - [TestMethod] - public void TryGetValue_sbyte_Bad() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - sbyte outValue; - var cell = ws.Cell("A1").SetValue(255); - var success = cell.TryGetValue(out outValue); - Assert.IsFalse(success); - } - - [TestMethod] - public void TryGetValue_sbyte_Good2() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - sbyte outValue; - var cell = ws.Cell("A1").SetValue("5"); - var success = cell.TryGetValue(out outValue); - Assert.IsTrue(success); - Assert.AreEqual((sbyte)5, outValue); - } - - [TestMethod] - public void TryGetValue_sbyte_Bad2() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - sbyte outValue; - var cell = ws.Cell("A1").SetValue("255"); - var success = cell.TryGetValue(out outValue); - Assert.IsFalse(success); - } - - [TestMethod] - public void NaN_is_not_a_number() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell("A1"); - cell.Value = "NaN"; - - Assert.AreNotEqual(XLCellValues.Number ,cell.DataType); - } - - [TestMethod] - public void Nan_is_not_a_number() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell("A1"); - cell.Value = "Nan"; - - Assert.AreNotEqual(XLCellValues.Number, cell.DataType); - } - - [TestMethod] - public void Double_NaN_is_a_string() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell("A1"); - var doubleList = new List {0.0/0.0}; - - cell.Value = doubleList.AsEnumerable(); - Assert.AreNotEqual(XLCellValues.Number, cell.DataType); - } - [TestMethod] - public void Double_Infinity_is_a_string() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell("A1"); - var doubleList = new List { 1.0 / 0.0 }; - - cell.Value = doubleList.AsEnumerable(); - Assert.AreNotEqual(XLCellValues.Number, cell.DataType); - } - } -} \ No newline at end of file diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Cells/XLCellTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Cells/XLCellTests.cs new file mode 100644 index 0000000..7de5ab4 --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Cells/XLCellTests.cs @@ -0,0 +1,300 @@ +using System.Collections.Generic; +using ClosedXML.Excel; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Linq; +using System; + +namespace ClosedXML_Tests +{ + [TestClass] + public class XLCellTests + { + [TestMethod] + public void IsEmpty1() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + var actual = cell.IsEmpty(); + var expected = true; + Assert.AreEqual(expected, actual); + } + + [TestMethod] + public void IsEmpty2() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + var actual = cell.IsEmpty(true); + var expected = true; + Assert.AreEqual(expected, actual); + } + + [TestMethod] + public void IsEmpty3() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.Style.Fill.BackgroundColor = XLColor.Red; + var actual = cell.IsEmpty(); + var expected = true; + Assert.AreEqual(expected, actual); + } + + [TestMethod] + public void IsEmpty4() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.Style.Fill.BackgroundColor = XLColor.Red; + var actual = cell.IsEmpty(false); + var expected = true; + Assert.AreEqual(expected, actual); + } + + [TestMethod] + public void IsEmpty5() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.Style.Fill.BackgroundColor = XLColor.Red; + var actual = cell.IsEmpty(true); + var expected = false; + Assert.AreEqual(expected, actual); + } + + [TestMethod] + public void IsEmpty6() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.Value = "X"; + var actual = cell.IsEmpty(); + var expected = false; + Assert.AreEqual(expected, actual); + } + + [TestMethod] + public void ValueSetToEmptyString() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.Value = new DateTime(2000, 1, 2); + cell.Value = String.Empty; + var actual = cell.GetString(); + var expected = String.Empty; + Assert.AreEqual(expected, actual); + } + + [TestMethod] + public void ValueSetToNull() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.Value = new DateTime(2000, 1, 2); + cell.Value = null; + var actual = cell.GetString(); + var expected = String.Empty; + Assert.AreEqual(expected, actual); + } + + [TestMethod] + public void InsertData1() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var range = ws.Cell(2, 2).InsertData(new[] {"a", "b", "c"}); + Assert.AreEqual("'Sheet1'!B2:B4", range.ToString()); + } + + [TestMethod] + public void CellsUsed() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + ws.Cell(1, 1); + ws.Cell(2, 2); + var count = ws.Range("A1:B2").CellsUsed().Count(); + Assert.AreEqual(0, count); + } + + [TestMethod] + public void TryGetValue_TimeSpan_Good() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + TimeSpan outValue; + var timeSpan = new TimeSpan(1, 1, 1); + var success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out outValue); + Assert.IsTrue(success); + Assert.AreEqual(timeSpan, outValue); + } + + [TestMethod] + public void TryGetValue_TimeSpan_BadString() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + TimeSpan outValue; + var timeSpan = "ABC"; + var success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out outValue); + Assert.IsFalse(success); + } + + [TestMethod] + public void TryGetValue_TimeSpan_GoodString() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + TimeSpan outValue; + var timeSpan = new TimeSpan(1, 1, 1); + var success = ws.Cell("A1").SetValue(timeSpan.ToString()).TryGetValue(out outValue); + Assert.IsTrue(success); + Assert.AreEqual(timeSpan, outValue); + } + + [TestMethod] + public void TryGetValue_RichText_Good() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + IXLRichText outValue; + var cell = ws.Cell("A1"); + cell.RichText.AddText("Anything"); + var success = cell.TryGetValue(out outValue); + Assert.IsTrue(success); + Assert.AreEqual(cell.RichText, outValue); + } + + [TestMethod] + public void TryGetValue_RichText_Bad() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + IXLRichText outValue; + var cell = ws.Cell("A1").SetValue("Anything"); + var success = cell.TryGetValue(out outValue); + Assert.IsTrue(success); + Assert.AreEqual(cell.RichText, outValue); + Assert.AreEqual("Anything", outValue.ToString()); + } + + [TestMethod] + public void TryGetValue_Boolean_True() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + Boolean outValue; + var cell = ws.Cell("A1").SetValue(true); + var success = cell.TryGetValue(out outValue); + Assert.IsTrue(success); + Assert.IsTrue(outValue); + } + + [TestMethod] + public void TryGetValue_Boolean_False() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + Boolean outValue; + var cell = ws.Cell("A1").SetValue(false); + var success = cell.TryGetValue(out outValue); + Assert.IsTrue(success); + Assert.IsFalse(outValue); + } + + [TestMethod] + public void TryGetValue_Boolean_Bad() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + Boolean outValue; + var cell = ws.Cell("A1").SetValue("ABC"); + var success = cell.TryGetValue(out outValue); + Assert.IsFalse(success); + } + + [TestMethod] + public void TryGetValue_Boolean_Good() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + Boolean outValue; + var cell = ws.Cell("A1").SetValue("True"); + var success = cell.TryGetValue(out outValue); + Assert.IsTrue(success); + Assert.IsTrue(outValue); + } + + [TestMethod] + public void TryGetValue_sbyte_Good() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + sbyte outValue; + var cell = ws.Cell("A1").SetValue(5); + var success = cell.TryGetValue(out outValue); + Assert.IsTrue(success); + Assert.AreEqual((sbyte)5, outValue); + } + + [TestMethod] + public void TryGetValue_sbyte_Bad() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + sbyte outValue; + var cell = ws.Cell("A1").SetValue(255); + var success = cell.TryGetValue(out outValue); + Assert.IsFalse(success); + } + + [TestMethod] + public void TryGetValue_sbyte_Good2() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + sbyte outValue; + var cell = ws.Cell("A1").SetValue("5"); + var success = cell.TryGetValue(out outValue); + Assert.IsTrue(success); + Assert.AreEqual((sbyte)5, outValue); + } + + [TestMethod] + public void TryGetValue_sbyte_Bad2() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + sbyte outValue; + var cell = ws.Cell("A1").SetValue("255"); + var success = cell.TryGetValue(out outValue); + Assert.IsFalse(success); + } + + [TestMethod] + public void NaN_is_not_a_number() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1"); + cell.Value = "NaN"; + + Assert.AreNotEqual(XLCellValues.Number ,cell.DataType); + } + + [TestMethod] + public void Nan_is_not_a_number() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1"); + cell.Value = "Nan"; + + Assert.AreNotEqual(XLCellValues.Number, cell.DataType); + } + + [TestMethod] + public void Double_NaN_is_a_string() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1"); + var doubleList = new List {0.0/0.0}; + + cell.Value = doubleList.AsEnumerable(); + Assert.AreNotEqual(XLCellValues.Number, cell.DataType); + } + [TestMethod] + public void Double_Infinity_is_a_string() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell("A1"); + var doubleList = new List { 1.0 / 0.0 }; + + cell.Value = doubleList.AsEnumerable(); + Assert.AreNotEqual(XLCellValues.Number, cell.DataType); + } + } +} \ No newline at end of file diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Columns/ColumnTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Columns/ColumnTests.cs new file mode 100644 index 0000000..bd4e237 --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Columns/ColumnTests.cs @@ -0,0 +1,233 @@ +using ClosedXML.Excel; +using DocumentFormat.OpenXml.Drawing; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; +using System.Linq; + +namespace ClosedXML_Tests.Excel +{ + /// + /// Summary description for UnitTest1 + /// + [TestClass] + public class ColumnTests + { + + [TestMethod] + public void ColumnUsed() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.Cell(2, 1).SetValue("Test"); + ws.Cell(3, 1).SetValue("Test"); + + var fromColumn = ws.Column(1).ColumnUsed(); + Assert.AreEqual("A2:A3", fromColumn.RangeAddress.ToStringRelative()); + + var fromRange = ws.Range("A1:A5").FirstColumn().ColumnUsed(); + Assert.AreEqual("A2:A3", fromRange.RangeAddress.ToStringRelative()); + } + + [TestMethod] + public void NoColumnsUsed() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + Int32 count = 0; + + foreach (var row in ws.ColumnsUsed()) + count++; + + foreach (var row in ws.Range("A1:C3").ColumnsUsed()) + count++; + + Assert.AreEqual(0, count); + } + + [TestMethod] + public void InsertingColumnsBefore1() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + + ws.Columns("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); + ws.Column(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); + ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); + + var column1 = ws.Column(1); + var column2 = ws.Column(2); + var column3 = ws.Column(3); + + var columnIns = ws.Column(1).InsertColumnsBefore(1).First(); + + Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Column(1).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Column(1).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Column(1).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, ws.Column(3).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", ws.Column(3).Cell(2).GetString()); + + + + Assert.AreEqual(ws.Style.Fill.BackgroundColor, columnIns.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(ws.Style.Fill.BackgroundColor, columnIns.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(ws.Style.Fill.BackgroundColor, columnIns.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, column1.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column1.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column1.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, column2.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, column2.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, column2.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, column3.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column3.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column3.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", column2.Cell(2).GetString()); + } + + [TestMethod] + public void InsertingColumnsBefore2() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + + ws.Columns("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); + ws.Column(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); + ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); + + var column1 = ws.Column(1); + var column2 = ws.Column(2); + var column3 = ws.Column(3); + + var columnIns = ws.Column(2).InsertColumnsBefore(1).First(); + var outputPath = System.IO.Path.Combine(TestHelper.TestsOutputDirectory,@"ForTesting\Sandbox.xlsx"); + wb.SaveAs(outputPath); + + Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, ws.Column(3).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", ws.Column(3).Cell(2).GetString()); + + + + Assert.AreEqual(XLColor.Red, columnIns.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, columnIns.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, columnIns.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, column1.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column1.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column1.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, column2.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, column2.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, column2.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, column3.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column3.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column3.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", column2.Cell(2).GetString()); + } + + [TestMethod] + public void InsertingColumnsBefore3() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + + ws.Columns("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); + ws.Column(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); + ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); + + var column1 = ws.Column(1); + var column2 = ws.Column(2); + var column3 = ws.Column(3); + + var columnIns = ws.Column(3).InsertColumnsBefore(1).First(); + + Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, ws.Column(2).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, ws.Column(2).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, ws.Column(2).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, ws.Column(3).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", ws.Column(2).Cell(2).GetString()); + + + Assert.AreEqual(XLColor.Yellow, columnIns.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, columnIns.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, columnIns.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, column1.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column1.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column1.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, column2.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, column2.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, column2.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, column3.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column3.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, column3.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", column2.Cell(2).GetString()); + } + + [TestMethod] + public void UngroupFromAll() + { + var ws = new XLWorkbook().AddWorksheet("Sheet1"); + ws.Columns(1, 2).Group(); + ws.Columns(1, 2).Ungroup(true); + + } + + [TestMethod] + public void CopyColumn() + { + var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Test").Style.Font.SetBold(); + ws.FirstColumn().CopyTo(ws.Column(2)); + + Assert.IsTrue(ws.Cell("B1").Style.Font.Bold); + } + } +} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Columns/ColumnsTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Columns/ColumnsTests.cs deleted file mode 100644 index bd4e237..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Columns/ColumnsTests.cs +++ /dev/null @@ -1,233 +0,0 @@ -using ClosedXML.Excel; -using DocumentFormat.OpenXml.Drawing; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System; -using System.Linq; - -namespace ClosedXML_Tests.Excel -{ - /// - /// Summary description for UnitTest1 - /// - [TestClass] - public class ColumnTests - { - - [TestMethod] - public void ColumnUsed() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - ws.Cell(2, 1).SetValue("Test"); - ws.Cell(3, 1).SetValue("Test"); - - var fromColumn = ws.Column(1).ColumnUsed(); - Assert.AreEqual("A2:A3", fromColumn.RangeAddress.ToStringRelative()); - - var fromRange = ws.Range("A1:A5").FirstColumn().ColumnUsed(); - Assert.AreEqual("A2:A3", fromRange.RangeAddress.ToStringRelative()); - } - - [TestMethod] - public void NoColumnsUsed() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - Int32 count = 0; - - foreach (var row in ws.ColumnsUsed()) - count++; - - foreach (var row in ws.Range("A1:C3").ColumnsUsed()) - count++; - - Assert.AreEqual(0, count); - } - - [TestMethod] - public void InsertingColumnsBefore1() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - - ws.Columns("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); - ws.Column(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); - ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - - var column1 = ws.Column(1); - var column2 = ws.Column(2); - var column3 = ws.Column(3); - - var columnIns = ws.Column(1).InsertColumnsBefore(1).First(); - - Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Column(1).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Column(1).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Column(1).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, ws.Column(3).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", ws.Column(3).Cell(2).GetString()); - - - - Assert.AreEqual(ws.Style.Fill.BackgroundColor, columnIns.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(ws.Style.Fill.BackgroundColor, columnIns.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(ws.Style.Fill.BackgroundColor, columnIns.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, column1.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column1.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column1.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, column2.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, column2.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, column2.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, column3.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column3.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column3.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", column2.Cell(2).GetString()); - } - - [TestMethod] - public void InsertingColumnsBefore2() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - - ws.Columns("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); - ws.Column(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); - ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - - var column1 = ws.Column(1); - var column2 = ws.Column(2); - var column3 = ws.Column(3); - - var columnIns = ws.Column(2).InsertColumnsBefore(1).First(); - var outputPath = System.IO.Path.Combine(TestHelper.TestsOutputDirectory,@"ForTesting\Sandbox.xlsx"); - wb.SaveAs(outputPath); - - Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(2).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, ws.Column(3).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", ws.Column(3).Cell(2).GetString()); - - - - Assert.AreEqual(XLColor.Red, columnIns.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, columnIns.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, columnIns.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, column1.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column1.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column1.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, column2.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, column2.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, column2.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, column3.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column3.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column3.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", column2.Cell(2).GetString()); - } - - [TestMethod] - public void InsertingColumnsBefore3() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - - ws.Columns("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); - ws.Column(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); - ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - - var column1 = ws.Column(1); - var column2 = ws.Column(2); - var column3 = ws.Column(3); - - var columnIns = ws.Column(3).InsertColumnsBefore(1).First(); - - Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, ws.Column(2).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, ws.Column(2).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, ws.Column(2).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, ws.Column(3).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, ws.Column(3).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Column(4).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", ws.Column(2).Cell(2).GetString()); - - - Assert.AreEqual(XLColor.Yellow, columnIns.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, columnIns.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, columnIns.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, column1.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column1.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column1.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, column2.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, column2.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, column2.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, column3.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column3.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, column3.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", column2.Cell(2).GetString()); - } - - [TestMethod] - public void UngroupFromAll() - { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); - ws.Columns(1, 2).Group(); - ws.Columns(1, 2).Ungroup(true); - - } - - [TestMethod] - public void CopyColumn() - { - var wb = new XLWorkbook(); - var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Test").Style.Font.SetBold(); - ws.FirstColumn().CopyTo(ws.Column(2)); - - Assert.IsTrue(ws.Cell("B1").Style.Font.Bold); - } - } -} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Coordinates/XLAddressTest.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Coordinates/XLAddressTest.cs deleted file mode 100644 index 119b7a3..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Coordinates/XLAddressTest.cs +++ /dev/null @@ -1,36 +0,0 @@ -using ClosedXML.Excel; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Linq; -using System; - -namespace ClosedXML_Tests -{ - [TestClass()] - public class XLAddressTest - { - [TestMethod()] - public void ToStringTest() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var address = ws.Cell(1, 1).Address; - - Assert.AreEqual("A1", address.ToString()); - Assert.AreEqual("A1", address.ToString(XLReferenceStyle.A1)); - Assert.AreEqual("R1C1", address.ToString(XLReferenceStyle.R1C1)); - Assert.AreEqual("A1", address.ToString(XLReferenceStyle.Default)); - - Assert.AreEqual("A1", address.ToStringRelative()); - Assert.AreEqual("'Sheet1'!A1", address.ToStringRelative(true)); - - Assert.AreEqual("$A$1", address.ToStringFixed()); - Assert.AreEqual("$A$1", address.ToStringFixed(XLReferenceStyle.A1)); - Assert.AreEqual("R1C1", address.ToStringFixed(XLReferenceStyle.R1C1)); - Assert.AreEqual("$A$1", address.ToStringFixed(XLReferenceStyle.Default)); - Assert.AreEqual("'Sheet1'!$A$1", address.ToStringFixed(XLReferenceStyle.A1, true)); - Assert.AreEqual("'Sheet1'!R1C1", address.ToStringFixed(XLReferenceStyle.R1C1, true)); - Assert.AreEqual("'Sheet1'!$A$1", address.ToStringFixed(XLReferenceStyle.Default, true)); - } - - - } -} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Coordinates/XLAddressTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Coordinates/XLAddressTests.cs new file mode 100644 index 0000000..86cf7b7 --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Coordinates/XLAddressTests.cs @@ -0,0 +1,36 @@ +using ClosedXML.Excel; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Linq; +using System; + +namespace ClosedXML_Tests +{ + [TestClass()] + public class XLAddressTests + { + [TestMethod()] + public void ToStringTest() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var address = ws.Cell(1, 1).Address; + + Assert.AreEqual("A1", address.ToString()); + Assert.AreEqual("A1", address.ToString(XLReferenceStyle.A1)); + Assert.AreEqual("R1C1", address.ToString(XLReferenceStyle.R1C1)); + Assert.AreEqual("A1", address.ToString(XLReferenceStyle.Default)); + + Assert.AreEqual("A1", address.ToStringRelative()); + Assert.AreEqual("'Sheet1'!A1", address.ToStringRelative(true)); + + Assert.AreEqual("$A$1", address.ToStringFixed()); + Assert.AreEqual("$A$1", address.ToStringFixed(XLReferenceStyle.A1)); + Assert.AreEqual("R1C1", address.ToStringFixed(XLReferenceStyle.R1C1)); + Assert.AreEqual("$A$1", address.ToStringFixed(XLReferenceStyle.Default)); + Assert.AreEqual("'Sheet1'!$A$1", address.ToStringFixed(XLReferenceStyle.A1, true)); + Assert.AreEqual("'Sheet1'!R1C1", address.ToStringFixed(XLReferenceStyle.R1C1, true)); + Assert.AreEqual("'Sheet1'!$A$1", address.ToStringFixed(XLReferenceStyle.Default, true)); + } + + + } +} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/CopyContentsTest.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/CopyContentsTest.cs deleted file mode 100644 index 407ffb6..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/CopyContentsTest.cs +++ /dev/null @@ -1,122 +0,0 @@ -using System; -using System.IO; -using System.Text; -using System.Collections.Generic; -using System.Linq; -using ClosedXML.Excel; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace ClosedXML_Tests.Excel.Misc -{ - /// - /// Summary description for UnitTest1 - /// - [TestClass] - public class CopyContentsTest - { - [TestMethod] - public void TestRowCopyContents() - { - var workbook = new XLWorkbook(); - var originalSheet = workbook.Worksheets.Add("original"); - var copyRowSheet = workbook.Worksheets.Add("copy row"); - var copyRowAsRangeSheet = workbook.Worksheets.Add("copy row as range"); - var copyRangeSheet = workbook.Worksheets.Add("copy range"); - - originalSheet.Cell("A2").SetValue("test value"); - originalSheet.Range("A2:E2").Merge(); - - { - var originalRange = originalSheet.Range("A2:E2"); - var destinationRange = copyRangeSheet.Range("A2:E2"); - - originalRange.CopyTo(destinationRange); - } - CopyRowAsRange(originalSheet, 2, copyRowAsRangeSheet, 3); - { - var originalRow = originalSheet.Row(2); - var destinationRow = copyRowSheet.Row(2); - copyRowSheet.Cell("G2").Value = "must be removed after copy"; - originalRow.CopyTo(destinationRow); - } - TestHelper.SaveWorkbook(workbook, @"Misc\CopyRowContents.xlsx"); - } - - private static void CopyRowAsRange(IXLWorksheet originalSheet, int originalRowNumber, IXLWorksheet destSheet, int destRowNumber) - { - { - var destinationRow = destSheet.Row(destRowNumber); - destinationRow.Clear(); - - var originalRow = originalSheet.Row(originalRowNumber); - int columnNumber = originalRow.LastCellUsed(true).Address.ColumnNumber; - - var originalRange = originalSheet.Range(originalRowNumber, 1, originalRowNumber, columnNumber); - var destRange = destSheet.Range(destRowNumber, 1, destRowNumber, columnNumber); - originalRange.CopyTo(destRange); - } - } - - [TestMethod] - public void CopyConditionalFormatsCount() - { - var wb = new XLWorkbook(); - var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().AddConditionalFormat().WhenContains("1").Fill.SetBackgroundColor(XLColor.Blue); - ws.Cell("A2").Value = ws.FirstCell(); - Assert.AreEqual(2, ws.ConditionalFormats.Count()); - } - - [TestMethod] - public void CopyConditionalFormatsRelative() - { - var wb = new XLWorkbook(); - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").Value = "1"; - ws.Cell("B1").Value = "1"; - ws.Cell("A1").AddConditionalFormat().WhenEquals("=B1").Fill.SetBackgroundColor(XLColor.Blue); - ws.Cell("A2").Value = ws.Cell("A1"); - Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "B1" && v.Value.IsFormula))); - Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "B2" && v.Value.IsFormula))); - } - - [TestMethod] - public void CopyConditionalFormatsFixedStringNum() - { - var wb = new XLWorkbook(); - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").Value = "1"; - ws.Cell("B1").Value = "1"; - ws.Cell("A1").AddConditionalFormat().WhenEquals("1").Fill.SetBackgroundColor(XLColor.Blue); - ws.Cell("A2").Value = ws.Cell("A1"); - Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "1" && !v.Value.IsFormula))); - Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "1" && !v.Value.IsFormula))); - } - - [TestMethod] - public void CopyConditionalFormatsFixedString() - { - var wb = new XLWorkbook(); - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").Value = "A"; - ws.Cell("B1").Value = "B"; - ws.Cell("A1").AddConditionalFormat().WhenEquals("A").Fill.SetBackgroundColor(XLColor.Blue); - ws.Cell("A2").Value = ws.Cell("A1"); - Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "A" && !v.Value.IsFormula))); - Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "A" && !v.Value.IsFormula))); - } - - [TestMethod] - public void CopyConditionalFormatsFixedNum() - { - var wb = new XLWorkbook(); - var ws = wb.AddWorksheet("Sheet1"); - ws.Cell("A1").Value = "1"; - ws.Cell("B1").Value = "1"; - ws.Cell("A1").AddConditionalFormat().WhenEquals(1).Fill.SetBackgroundColor(XLColor.Blue); - ws.Cell("A2").Value = ws.Cell("A1"); - Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "1" && !v.Value.IsFormula))); - Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "1" && !v.Value.IsFormula))); - } - } -} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/CopyContentsTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/CopyContentsTests.cs new file mode 100644 index 0000000..8a1fc72 --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/CopyContentsTests.cs @@ -0,0 +1,122 @@ +using System; +using System.IO; +using System.Text; +using System.Collections.Generic; +using System.Linq; +using ClosedXML.Excel; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace ClosedXML_Tests.Excel.Misc +{ + /// + /// Summary description for UnitTest1 + /// + [TestClass] + public class CopyContentsTests + { + [TestMethod] + public void TestRowCopyContents() + { + var workbook = new XLWorkbook(); + var originalSheet = workbook.Worksheets.Add("original"); + var copyRowSheet = workbook.Worksheets.Add("copy row"); + var copyRowAsRangeSheet = workbook.Worksheets.Add("copy row as range"); + var copyRangeSheet = workbook.Worksheets.Add("copy range"); + + originalSheet.Cell("A2").SetValue("test value"); + originalSheet.Range("A2:E2").Merge(); + + { + var originalRange = originalSheet.Range("A2:E2"); + var destinationRange = copyRangeSheet.Range("A2:E2"); + + originalRange.CopyTo(destinationRange); + } + CopyRowAsRange(originalSheet, 2, copyRowAsRangeSheet, 3); + { + var originalRow = originalSheet.Row(2); + var destinationRow = copyRowSheet.Row(2); + copyRowSheet.Cell("G2").Value = "must be removed after copy"; + originalRow.CopyTo(destinationRow); + } + TestHelper.SaveWorkbook(workbook, @"Misc\CopyRowContents.xlsx"); + } + + private static void CopyRowAsRange(IXLWorksheet originalSheet, int originalRowNumber, IXLWorksheet destSheet, int destRowNumber) + { + { + var destinationRow = destSheet.Row(destRowNumber); + destinationRow.Clear(); + + var originalRow = originalSheet.Row(originalRowNumber); + int columnNumber = originalRow.LastCellUsed(true).Address.ColumnNumber; + + var originalRange = originalSheet.Range(originalRowNumber, 1, originalRowNumber, columnNumber); + var destRange = destSheet.Range(destRowNumber, 1, destRowNumber, columnNumber); + originalRange.CopyTo(destRange); + } + } + + [TestMethod] + public void CopyConditionalFormatsCount() + { + var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().AddConditionalFormat().WhenContains("1").Fill.SetBackgroundColor(XLColor.Blue); + ws.Cell("A2").Value = ws.FirstCell(); + Assert.AreEqual(2, ws.ConditionalFormats.Count()); + } + + [TestMethod] + public void CopyConditionalFormatsRelative() + { + var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").Value = "1"; + ws.Cell("B1").Value = "1"; + ws.Cell("A1").AddConditionalFormat().WhenEquals("=B1").Fill.SetBackgroundColor(XLColor.Blue); + ws.Cell("A2").Value = ws.Cell("A1"); + Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "B1" && v.Value.IsFormula))); + Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "B2" && v.Value.IsFormula))); + } + + [TestMethod] + public void CopyConditionalFormatsFixedStringNum() + { + var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").Value = "1"; + ws.Cell("B1").Value = "1"; + ws.Cell("A1").AddConditionalFormat().WhenEquals("1").Fill.SetBackgroundColor(XLColor.Blue); + ws.Cell("A2").Value = ws.Cell("A1"); + Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "1" && !v.Value.IsFormula))); + Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "1" && !v.Value.IsFormula))); + } + + [TestMethod] + public void CopyConditionalFormatsFixedString() + { + var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").Value = "A"; + ws.Cell("B1").Value = "B"; + ws.Cell("A1").AddConditionalFormat().WhenEquals("A").Fill.SetBackgroundColor(XLColor.Blue); + ws.Cell("A2").Value = ws.Cell("A1"); + Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "A" && !v.Value.IsFormula))); + Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "A" && !v.Value.IsFormula))); + } + + [TestMethod] + public void CopyConditionalFormatsFixedNum() + { + var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.Cell("A1").Value = "1"; + ws.Cell("B1").Value = "1"; + ws.Cell("A1").AddConditionalFormat().WhenEquals(1).Fill.SetBackgroundColor(XLColor.Blue); + ws.Cell("A2").Value = ws.Cell("A1"); + Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "1" && !v.Value.IsFormula))); + Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "1" && !v.Value.IsFormula))); + } + } +} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/ExcelHelperTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/ExcelHelperTests.cs deleted file mode 100644 index a675463..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/ExcelHelperTests.cs +++ /dev/null @@ -1,99 +0,0 @@ -using System; -using System.Text; -using System.Collections.Generic; -using System.Linq; -using ClosedXML.Excel; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace ClosedXML_Tests.Excel -{ - /// - /// Summary description for UnitTest1 - /// - [TestClass] - public class XLHelperTests - { - - [TestMethod] - public void TestConvertColumnLetterToNumberAnd() - { - CheckColumnNumber(1); - CheckColumnNumber(27); - CheckColumnNumber(28); - CheckColumnNumber(52); - CheckColumnNumber(53); - CheckColumnNumber(1000); - } - private static void CheckColumnNumber(int column) - { - Assert.AreEqual(column, XLHelper.GetColumnNumberFromLetter(XLHelper.GetColumnLetterFromNumber(column))); - } - - [TestMethod] - public void PlusAA1_Is_Not_an_address() - { - Assert.IsFalse(XLHelper.IsValidA1Address("+AA1")); - } - - [TestMethod] - public void ValidA1Addresses() - { - Assert.IsTrue(XLHelper.IsValidA1Address("A1")); - Assert.IsTrue(XLHelper.IsValidA1Address("A" + XLHelper.MaxRowNumber )); - Assert.IsTrue(XLHelper.IsValidA1Address("Z1")); - Assert.IsTrue(XLHelper.IsValidA1Address("Z" + XLHelper.MaxRowNumber)); - - Assert.IsTrue(XLHelper.IsValidA1Address("AA1")); - Assert.IsTrue(XLHelper.IsValidA1Address("AA" + XLHelper.MaxRowNumber)); - Assert.IsTrue(XLHelper.IsValidA1Address("ZZ1")); - Assert.IsTrue(XLHelper.IsValidA1Address("ZZ" + XLHelper.MaxRowNumber)); - - Assert.IsTrue(XLHelper.IsValidA1Address("AAA1")); - Assert.IsTrue(XLHelper.IsValidA1Address("AAA" + XLHelper.MaxRowNumber)); - Assert.IsTrue(XLHelper.IsValidA1Address(XLHelper.MaxColumnLetter + "1")); - Assert.IsTrue(XLHelper.IsValidA1Address(XLHelper.MaxColumnLetter + XLHelper.MaxRowNumber)); - } - - [TestMethod] - public void InvalidA1Addresses() - { - Assert.IsFalse(XLHelper.IsValidA1Address("")); - Assert.IsFalse(XLHelper.IsValidA1Address("A")); - Assert.IsFalse(XLHelper.IsValidA1Address("a")); - Assert.IsFalse(XLHelper.IsValidA1Address("1")); - Assert.IsFalse(XLHelper.IsValidA1Address("-1")); - Assert.IsFalse(XLHelper.IsValidA1Address("AAAA1")); - Assert.IsFalse(XLHelper.IsValidA1Address("XFG1")); - - Assert.IsFalse(XLHelper.IsValidA1Address("@A1")); - Assert.IsFalse(XLHelper.IsValidA1Address("@AA1")); - Assert.IsFalse(XLHelper.IsValidA1Address("@AAA1")); - Assert.IsFalse(XLHelper.IsValidA1Address("[A1")); - Assert.IsFalse(XLHelper.IsValidA1Address("[AA1")); - Assert.IsFalse(XLHelper.IsValidA1Address("[AAA1")); - Assert.IsFalse(XLHelper.IsValidA1Address("{A1")); - Assert.IsFalse(XLHelper.IsValidA1Address("{AA1")); - Assert.IsFalse(XLHelper.IsValidA1Address("{AAA1")); - - Assert.IsFalse(XLHelper.IsValidA1Address("A1@")); - Assert.IsFalse(XLHelper.IsValidA1Address("AA1@")); - Assert.IsFalse(XLHelper.IsValidA1Address("AAA1@")); - Assert.IsFalse(XLHelper.IsValidA1Address("A1[")); - Assert.IsFalse(XLHelper.IsValidA1Address("AA1[")); - Assert.IsFalse(XLHelper.IsValidA1Address("AAA1[")); - Assert.IsFalse(XLHelper.IsValidA1Address("A1{")); - Assert.IsFalse(XLHelper.IsValidA1Address("AA1{")); - Assert.IsFalse(XLHelper.IsValidA1Address("AAA1{")); - - Assert.IsFalse(XLHelper.IsValidA1Address("@A1@")); - Assert.IsFalse(XLHelper.IsValidA1Address("@AA1@")); - Assert.IsFalse(XLHelper.IsValidA1Address("@AAA1@")); - Assert.IsFalse(XLHelper.IsValidA1Address("[A1[")); - Assert.IsFalse(XLHelper.IsValidA1Address("[AA1[")); - Assert.IsFalse(XLHelper.IsValidA1Address("[AAA1[")); - Assert.IsFalse(XLHelper.IsValidA1Address("{A1{")); - Assert.IsFalse(XLHelper.IsValidA1Address("{AA1{")); - Assert.IsFalse(XLHelper.IsValidA1Address("{AAA1{")); - } - } -} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/ExtensionsTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/ExtensionsTests.cs index 2110151..34d4d80 100644 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/ExtensionsTests.cs +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/ExtensionsTests.cs @@ -11,7 +11,7 @@ /// Summary description for UnitTest1 /// [TestClass] - public class Extensions + public class ExtensionsTests { [TestMethod] diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/StylesTest.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/StylesTest.cs deleted file mode 100644 index a19ac80..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/StylesTest.cs +++ /dev/null @@ -1,73 +0,0 @@ -using System; -using System.IO; -using System.Text; -using System.Collections.Generic; -using System.Linq; -using ClosedXML.Excel; -using Microsoft.VisualStudio.TestTools.UnitTesting; - -namespace ClosedXML_Tests.Excel.Misc -{ - /// - /// Summary description for UnitTest1 - /// - [TestClass] - public class StylesTest - { - [TestMethod] - public void InsideBorderTest() - { - var wb = new XLWorkbook(); - var ws = wb.AddWorksheet("Sheet1"); - var range = ws.Range("B2:D4"); - - SetupBorders(range); - - range.Style.Border.InsideBorder = XLBorderStyleValues.Thin; - range.Style.Border.InsideBorderColor = XLColor.Red; - - var center = range.Cell(2, 2); - - Assert.AreEqual(XLColor.Red, center.Style.Border.TopBorderColor); - Assert.AreEqual(XLColor.Red, center.Style.Border.BottomBorderColor); - Assert.AreEqual(XLColor.Red, center.Style.Border.LeftBorderColor); - Assert.AreEqual(XLColor.Red, center.Style.Border.RightBorderColor); - - Assert.AreEqual(XLBorderStyleValues.None, range.FirstRow().Cell(1).Style.Border.TopBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, range.FirstRow().Cell(2).Style.Border.TopBorder); - Assert.AreEqual(XLBorderStyleValues.Double, range.FirstRow().Cell(3).Style.Border.TopBorder); - - Assert.AreEqual(XLBorderStyleValues.None, range.LastRow().Cell(1).Style.Border.BottomBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, range.LastRow().Cell(2).Style.Border.BottomBorder); - Assert.AreEqual(XLBorderStyleValues.Double, range.LastRow().Cell(3).Style.Border.BottomBorder); - - Assert.AreEqual(XLBorderStyleValues.None, range.FirstColumn().Cell(1).Style.Border.LeftBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, range.FirstColumn().Cell(2).Style.Border.LeftBorder); - Assert.AreEqual(XLBorderStyleValues.Double, range.FirstColumn().Cell(3).Style.Border.LeftBorder); - - Assert.AreEqual(XLBorderStyleValues.None, range.LastColumn().Cell(1).Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.Thick, range.LastColumn().Cell(2).Style.Border.RightBorder); - Assert.AreEqual(XLBorderStyleValues.Double, range.LastColumn().Cell(3).Style.Border.RightBorder); - } - - private static void SetupBorders(IXLRange range) - { - range.FirstRow().Cell(1).Style.Border.TopBorder = XLBorderStyleValues.None; - range.FirstRow().Cell(2).Style.Border.TopBorder = XLBorderStyleValues.Thick; - range.FirstRow().Cell(3).Style.Border.TopBorder = XLBorderStyleValues.Double; - - range.LastRow().Cell(1).Style.Border.BottomBorder = XLBorderStyleValues.None; - range.LastRow().Cell(2).Style.Border.BottomBorder = XLBorderStyleValues.Thick; - range.LastRow().Cell(3).Style.Border.BottomBorder = XLBorderStyleValues.Double; - - range.FirstColumn().Cell(1).Style.Border.LeftBorder = XLBorderStyleValues.None; - range.FirstColumn().Cell(2).Style.Border.LeftBorder = XLBorderStyleValues.Thick; - range.FirstColumn().Cell(3).Style.Border.LeftBorder = XLBorderStyleValues.Double; - - range.LastColumn().Cell(1).Style.Border.RightBorder = XLBorderStyleValues.None; - range.LastColumn().Cell(2).Style.Border.RightBorder = XLBorderStyleValues.Thick; - range.LastColumn().Cell(3).Style.Border.RightBorder = XLBorderStyleValues.Double; - } - - } -} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/StylesTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/StylesTests.cs new file mode 100644 index 0000000..44194a5 --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/StylesTests.cs @@ -0,0 +1,73 @@ +using System; +using System.IO; +using System.Text; +using System.Collections.Generic; +using System.Linq; +using ClosedXML.Excel; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace ClosedXML_Tests.Excel.Misc +{ + /// + /// Summary description for UnitTest1 + /// + [TestClass] + public class StylesTests + { + [TestMethod] + public void InsideBorderTest() + { + var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + var range = ws.Range("B2:D4"); + + SetupBorders(range); + + range.Style.Border.InsideBorder = XLBorderStyleValues.Thin; + range.Style.Border.InsideBorderColor = XLColor.Red; + + var center = range.Cell(2, 2); + + Assert.AreEqual(XLColor.Red, center.Style.Border.TopBorderColor); + Assert.AreEqual(XLColor.Red, center.Style.Border.BottomBorderColor); + Assert.AreEqual(XLColor.Red, center.Style.Border.LeftBorderColor); + Assert.AreEqual(XLColor.Red, center.Style.Border.RightBorderColor); + + Assert.AreEqual(XLBorderStyleValues.None, range.FirstRow().Cell(1).Style.Border.TopBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, range.FirstRow().Cell(2).Style.Border.TopBorder); + Assert.AreEqual(XLBorderStyleValues.Double, range.FirstRow().Cell(3).Style.Border.TopBorder); + + Assert.AreEqual(XLBorderStyleValues.None, range.LastRow().Cell(1).Style.Border.BottomBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, range.LastRow().Cell(2).Style.Border.BottomBorder); + Assert.AreEqual(XLBorderStyleValues.Double, range.LastRow().Cell(3).Style.Border.BottomBorder); + + Assert.AreEqual(XLBorderStyleValues.None, range.FirstColumn().Cell(1).Style.Border.LeftBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, range.FirstColumn().Cell(2).Style.Border.LeftBorder); + Assert.AreEqual(XLBorderStyleValues.Double, range.FirstColumn().Cell(3).Style.Border.LeftBorder); + + Assert.AreEqual(XLBorderStyleValues.None, range.LastColumn().Cell(1).Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.Thick, range.LastColumn().Cell(2).Style.Border.RightBorder); + Assert.AreEqual(XLBorderStyleValues.Double, range.LastColumn().Cell(3).Style.Border.RightBorder); + } + + private static void SetupBorders(IXLRange range) + { + range.FirstRow().Cell(1).Style.Border.TopBorder = XLBorderStyleValues.None; + range.FirstRow().Cell(2).Style.Border.TopBorder = XLBorderStyleValues.Thick; + range.FirstRow().Cell(3).Style.Border.TopBorder = XLBorderStyleValues.Double; + + range.LastRow().Cell(1).Style.Border.BottomBorder = XLBorderStyleValues.None; + range.LastRow().Cell(2).Style.Border.BottomBorder = XLBorderStyleValues.Thick; + range.LastRow().Cell(3).Style.Border.BottomBorder = XLBorderStyleValues.Double; + + range.FirstColumn().Cell(1).Style.Border.LeftBorder = XLBorderStyleValues.None; + range.FirstColumn().Cell(2).Style.Border.LeftBorder = XLBorderStyleValues.Thick; + range.FirstColumn().Cell(3).Style.Border.LeftBorder = XLBorderStyleValues.Double; + + range.LastColumn().Cell(1).Style.Border.RightBorder = XLBorderStyleValues.None; + range.LastColumn().Cell(2).Style.Border.RightBorder = XLBorderStyleValues.Thick; + range.LastColumn().Cell(3).Style.Border.RightBorder = XLBorderStyleValues.Double; + } + + } +} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/XlHelperTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/XlHelperTests.cs new file mode 100644 index 0000000..411074a --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/XlHelperTests.cs @@ -0,0 +1,99 @@ +using System; +using System.Text; +using System.Collections.Generic; +using System.Linq; +using ClosedXML.Excel; +using Microsoft.VisualStudio.TestTools.UnitTesting; + +namespace ClosedXML_Tests.Excel +{ + /// + /// Summary description for UnitTest1 + /// + [TestClass] + public class XlHelperTests + { + + [TestMethod] + public void TestConvertColumnLetterToNumberAnd() + { + CheckColumnNumber(1); + CheckColumnNumber(27); + CheckColumnNumber(28); + CheckColumnNumber(52); + CheckColumnNumber(53); + CheckColumnNumber(1000); + } + private static void CheckColumnNumber(int column) + { + Assert.AreEqual(column, XLHelper.GetColumnNumberFromLetter(XLHelper.GetColumnLetterFromNumber(column))); + } + + [TestMethod] + public void PlusAA1_Is_Not_an_address() + { + Assert.IsFalse(XLHelper.IsValidA1Address("+AA1")); + } + + [TestMethod] + public void ValidA1Addresses() + { + Assert.IsTrue(XLHelper.IsValidA1Address("A1")); + Assert.IsTrue(XLHelper.IsValidA1Address("A" + XLHelper.MaxRowNumber )); + Assert.IsTrue(XLHelper.IsValidA1Address("Z1")); + Assert.IsTrue(XLHelper.IsValidA1Address("Z" + XLHelper.MaxRowNumber)); + + Assert.IsTrue(XLHelper.IsValidA1Address("AA1")); + Assert.IsTrue(XLHelper.IsValidA1Address("AA" + XLHelper.MaxRowNumber)); + Assert.IsTrue(XLHelper.IsValidA1Address("ZZ1")); + Assert.IsTrue(XLHelper.IsValidA1Address("ZZ" + XLHelper.MaxRowNumber)); + + Assert.IsTrue(XLHelper.IsValidA1Address("AAA1")); + Assert.IsTrue(XLHelper.IsValidA1Address("AAA" + XLHelper.MaxRowNumber)); + Assert.IsTrue(XLHelper.IsValidA1Address(XLHelper.MaxColumnLetter + "1")); + Assert.IsTrue(XLHelper.IsValidA1Address(XLHelper.MaxColumnLetter + XLHelper.MaxRowNumber)); + } + + [TestMethod] + public void InvalidA1Addresses() + { + Assert.IsFalse(XLHelper.IsValidA1Address("")); + Assert.IsFalse(XLHelper.IsValidA1Address("A")); + Assert.IsFalse(XLHelper.IsValidA1Address("a")); + Assert.IsFalse(XLHelper.IsValidA1Address("1")); + Assert.IsFalse(XLHelper.IsValidA1Address("-1")); + Assert.IsFalse(XLHelper.IsValidA1Address("AAAA1")); + Assert.IsFalse(XLHelper.IsValidA1Address("XFG1")); + + Assert.IsFalse(XLHelper.IsValidA1Address("@A1")); + Assert.IsFalse(XLHelper.IsValidA1Address("@AA1")); + Assert.IsFalse(XLHelper.IsValidA1Address("@AAA1")); + Assert.IsFalse(XLHelper.IsValidA1Address("[A1")); + Assert.IsFalse(XLHelper.IsValidA1Address("[AA1")); + Assert.IsFalse(XLHelper.IsValidA1Address("[AAA1")); + Assert.IsFalse(XLHelper.IsValidA1Address("{A1")); + Assert.IsFalse(XLHelper.IsValidA1Address("{AA1")); + Assert.IsFalse(XLHelper.IsValidA1Address("{AAA1")); + + Assert.IsFalse(XLHelper.IsValidA1Address("A1@")); + Assert.IsFalse(XLHelper.IsValidA1Address("AA1@")); + Assert.IsFalse(XLHelper.IsValidA1Address("AAA1@")); + Assert.IsFalse(XLHelper.IsValidA1Address("A1[")); + Assert.IsFalse(XLHelper.IsValidA1Address("AA1[")); + Assert.IsFalse(XLHelper.IsValidA1Address("AAA1[")); + Assert.IsFalse(XLHelper.IsValidA1Address("A1{")); + Assert.IsFalse(XLHelper.IsValidA1Address("AA1{")); + Assert.IsFalse(XLHelper.IsValidA1Address("AAA1{")); + + Assert.IsFalse(XLHelper.IsValidA1Address("@A1@")); + Assert.IsFalse(XLHelper.IsValidA1Address("@AA1@")); + Assert.IsFalse(XLHelper.IsValidA1Address("@AAA1@")); + Assert.IsFalse(XLHelper.IsValidA1Address("[A1[")); + Assert.IsFalse(XLHelper.IsValidA1Address("[AA1[")); + Assert.IsFalse(XLHelper.IsValidA1Address("[AAA1[")); + Assert.IsFalse(XLHelper.IsValidA1Address("{A1{")); + Assert.IsFalse(XLHelper.IsValidA1Address("{AA1{")); + Assert.IsFalse(XLHelper.IsValidA1Address("{AAA1{")); + } + } +} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/PivotTables/XLPivotTableTest.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/PivotTables/XLPivotTableTest.cs deleted file mode 100644 index ba9dab7..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/PivotTables/XLPivotTableTest.cs +++ /dev/null @@ -1,20 +0,0 @@ -using ClosedXML.Excel; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Linq; -using System; - -namespace ClosedXML_Tests -{ - [TestClass()] - public class XLPivotTableTest - { - //[TestMethod()] - //public void CreateTable() - //{ - // var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - - - //} - - } -} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/PivotTables/XLPivotTableTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/PivotTables/XLPivotTableTests.cs new file mode 100644 index 0000000..5c3c76f --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/PivotTables/XLPivotTableTests.cs @@ -0,0 +1,20 @@ +using ClosedXML.Excel; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Linq; +using System; + +namespace ClosedXML_Tests +{ + [TestClass()] + public class XLPivotTableTests + { + //[TestMethod()] + //public void CreateTable() + //{ + // var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + + + //} + + } +} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeAddressTest.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeAddressTest.cs deleted file mode 100644 index e1baa58..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeAddressTest.cs +++ /dev/null @@ -1,33 +0,0 @@ -using ClosedXML.Excel; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Linq; -using System; - -namespace ClosedXML_Tests -{ - [TestClass()] - public class XLRangeAddressTest - { - [TestMethod()] - public void ToStringTest() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var address = ws.Cell(1, 1).AsRange().RangeAddress; - - Assert.AreEqual("A1:A1", address.ToString()); - - Assert.AreEqual("A1:A1", address.ToStringRelative()); - Assert.AreEqual("'Sheet1'!A1:A1", address.ToStringRelative(true)); - - Assert.AreEqual("$A$1:$A$1", address.ToStringFixed()); - Assert.AreEqual("$A$1:$A$1", address.ToStringFixed(XLReferenceStyle.A1)); - Assert.AreEqual("R1C1:R1C1", address.ToStringFixed(XLReferenceStyle.R1C1)); - Assert.AreEqual("$A$1:$A$1", address.ToStringFixed(XLReferenceStyle.Default)); - Assert.AreEqual("'Sheet1'!$A$1:$A$1", address.ToStringFixed(XLReferenceStyle.A1, true)); - Assert.AreEqual("'Sheet1'!R1C1:R1C1", address.ToStringFixed(XLReferenceStyle.R1C1, true)); - Assert.AreEqual("'Sheet1'!$A$1:$A$1", address.ToStringFixed(XLReferenceStyle.Default, true)); - } - - - } -} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeAddressTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeAddressTests.cs new file mode 100644 index 0000000..60aaf9f --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeAddressTests.cs @@ -0,0 +1,33 @@ +using ClosedXML.Excel; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Linq; +using System; + +namespace ClosedXML_Tests +{ + [TestClass()] + public class XLRangeAddressTests + { + [TestMethod()] + public void ToStringTest() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var address = ws.Cell(1, 1).AsRange().RangeAddress; + + Assert.AreEqual("A1:A1", address.ToString()); + + Assert.AreEqual("A1:A1", address.ToStringRelative()); + Assert.AreEqual("'Sheet1'!A1:A1", address.ToStringRelative(true)); + + Assert.AreEqual("$A$1:$A$1", address.ToStringFixed()); + Assert.AreEqual("$A$1:$A$1", address.ToStringFixed(XLReferenceStyle.A1)); + Assert.AreEqual("R1C1:R1C1", address.ToStringFixed(XLReferenceStyle.R1C1)); + Assert.AreEqual("$A$1:$A$1", address.ToStringFixed(XLReferenceStyle.Default)); + Assert.AreEqual("'Sheet1'!$A$1:$A$1", address.ToStringFixed(XLReferenceStyle.A1, true)); + Assert.AreEqual("'Sheet1'!R1C1:R1C1", address.ToStringFixed(XLReferenceStyle.R1C1, true)); + Assert.AreEqual("'Sheet1'!$A$1:$A$1", address.ToStringFixed(XLReferenceStyle.Default, true)); + } + + + } +} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeBaseTest.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeBaseTest.cs deleted file mode 100644 index 03cf90c..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeBaseTest.cs +++ /dev/null @@ -1,190 +0,0 @@ -using ClosedXML.Excel; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Linq; -using System; -using System.IO; - -namespace ClosedXML_Tests -{ - [TestClass()] - public class XLRangeBaseTest - { - [TestMethod()] - public void IsEmpty1() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - var range = ws.Range("A1:B2"); - var actual = range.IsEmpty(); - var expected = true; - Assert.AreEqual(expected, actual); - } - - [TestMethod()] - public void IsEmpty2() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - var range = ws.Range("A1:B2"); - var actual = range.IsEmpty(true); - var expected = true; - Assert.AreEqual(expected, actual); - } - - [TestMethod()] - public void IsEmpty3() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.Style.Fill.BackgroundColor = XLColor.Red; - var range = ws.Range("A1:B2"); - var actual = range.IsEmpty(); - var expected = true; - Assert.AreEqual(expected, actual); - } - - [TestMethod()] - public void IsEmpty4() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.Style.Fill.BackgroundColor = XLColor.Red; - var range = ws.Range("A1:B2"); - var actual = range.IsEmpty(false); - var expected = true; - Assert.AreEqual(expected, actual); - } - - [TestMethod()] - public void IsEmpty5() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.Style.Fill.BackgroundColor = XLColor.Red; - var range = ws.Range("A1:B2"); - var actual = range.IsEmpty(true); - var expected = false; - Assert.AreEqual(expected, actual); - } - - [TestMethod()] - public void IsEmpty6() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.Value = "X"; - var range = ws.Range("A1:B2"); - var actual = range.IsEmpty(); - var expected = false; - Assert.AreEqual(expected, actual); - } - - [TestMethod] - public void TableRange() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - var rangeColumn = ws.Column(1).Column(1, 4); - rangeColumn.Cell(1).Value = "FName"; - rangeColumn.Cell(2).Value = "John"; - rangeColumn.Cell(3).Value = "Hank"; - rangeColumn.Cell(4).Value = "Dagny"; - var table = rangeColumn.CreateTable(); - wb.NamedRanges.Add("FNameColumn", String.Format("{0}[{1}]", table.Name, "FName")); - - var namedRange = wb.Range( "FNameColumn" ); - Assert.AreEqual(3, namedRange.Cells().Count()); - Assert.IsTrue(namedRange.CellsUsed().Select(cell => cell.GetString()).SequenceEqual(new[] { "John", "Hank", "Dagny" })); - } - - [TestMethod] - public void SingleCell() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - ws.Cell(1, 1).Value = "Hello World!"; - wb.NamedRanges.Add("SingleCell", "Sheet1!$A$1"); - var range = wb.Range( "SingleCell" ); - Assert.AreEqual( 1, range.CellsUsed().Count() ); - Assert.AreEqual("Hello World!", range.CellsUsed().Single().GetString()); - } - - [TestMethod] - public void WsNamedCell() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - ws.Cell(1, 1).SetValue("Test").AddToNamed("TestCell", XLScope.Worksheet); - Assert.AreEqual("Test", ws.Cell("TestCell").GetString()); - } - - [TestMethod] - public void WsNamedCells() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - ws.Cell(1, 1).SetValue("Test").AddToNamed("TestCell", XLScope.Worksheet); - ws.Cell(2, 1).SetValue("B"); - var cells = ws.Cells("TestCell, A2"); - Assert.AreEqual("Test", cells.First().GetString()); - Assert.AreEqual("B", cells.Last().GetString()); - } - - [TestMethod] - public void WsNamedRange() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - ws.Cell(1, 1).SetValue("A"); - ws.Cell(2, 1).SetValue("B"); - var original = ws.Range("A1:A2"); - original.AddToNamed("TestRange", XLScope.Worksheet); - var named = ws.Range("TestRange"); - Assert.AreEqual(original.RangeAddress.ToStringFixed(), named.RangeAddress.ToString()); - } - - [TestMethod] - public void WsNamedRanges() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - ws.Cell(1, 1).SetValue("A"); - ws.Cell(2, 1).SetValue("B"); - ws.Cell(3, 1).SetValue("C"); - var original = ws.Range("A1:A2"); - original.AddToNamed("TestRange", XLScope.Worksheet); - var namedRanges = ws.Ranges("TestRange, A3"); - Assert.AreEqual(original.RangeAddress.ToStringFixed(), namedRanges.First().RangeAddress.ToString()); - Assert.AreEqual("$A$3:$A$3", namedRanges.Last().RangeAddress.ToStringFixed()); - } - - [TestMethod] - public void WsNamedRangesOneString() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - ws.NamedRanges.Add("TestRange", "Sheet1!$A$1,Sheet1!$A$3"); - var namedRanges = ws.Ranges("TestRange"); - - Assert.AreEqual("$A$1:$A$1", namedRanges.First().RangeAddress.ToStringFixed()); - Assert.AreEqual("$A$3:$A$3", namedRanges.Last().RangeAddress.ToStringFixed()); - } - - //[TestMethod] - //public void WsNamedRangeLiteral() - //{ - // var wb = new XLWorkbook(); - // var ws = wb.Worksheets.Add("Sheet1"); - // ws.NamedRanges.Add("TestRange", "\"Hello\""); - // using (MemoryStream memoryStream = new MemoryStream()) - // { - // wb.SaveAs(memoryStream); - // var wb2 = new XLWorkbook(memoryStream); - // var text = wb2.Worksheet("Sheet1").NamedRanges.First() - // memoryStream.Close(); - // } - - - //} - } -} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeBaseTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeBaseTests.cs new file mode 100644 index 0000000..d420d4f --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeBaseTests.cs @@ -0,0 +1,190 @@ +using ClosedXML.Excel; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Linq; +using System; +using System.IO; + +namespace ClosedXML_Tests +{ + [TestClass()] + public class XLRangeBaseTests + { + [TestMethod()] + public void IsEmpty1() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(); + var expected = true; + Assert.AreEqual(expected, actual); + } + + [TestMethod()] + public void IsEmpty2() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(true); + var expected = true; + Assert.AreEqual(expected, actual); + } + + [TestMethod()] + public void IsEmpty3() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.Style.Fill.BackgroundColor = XLColor.Red; + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(); + var expected = true; + Assert.AreEqual(expected, actual); + } + + [TestMethod()] + public void IsEmpty4() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.Style.Fill.BackgroundColor = XLColor.Red; + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(false); + var expected = true; + Assert.AreEqual(expected, actual); + } + + [TestMethod()] + public void IsEmpty5() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.Style.Fill.BackgroundColor = XLColor.Red; + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(true); + var expected = false; + Assert.AreEqual(expected, actual); + } + + [TestMethod()] + public void IsEmpty6() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.Value = "X"; + var range = ws.Range("A1:B2"); + var actual = range.IsEmpty(); + var expected = false; + Assert.AreEqual(expected, actual); + } + + [TestMethod] + public void TableRange() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + var rangeColumn = ws.Column(1).Column(1, 4); + rangeColumn.Cell(1).Value = "FName"; + rangeColumn.Cell(2).Value = "John"; + rangeColumn.Cell(3).Value = "Hank"; + rangeColumn.Cell(4).Value = "Dagny"; + var table = rangeColumn.CreateTable(); + wb.NamedRanges.Add("FNameColumn", String.Format("{0}[{1}]", table.Name, "FName")); + + var namedRange = wb.Range( "FNameColumn" ); + Assert.AreEqual(3, namedRange.Cells().Count()); + Assert.IsTrue(namedRange.CellsUsed().Select(cell => cell.GetString()).SequenceEqual(new[] { "John", "Hank", "Dagny" })); + } + + [TestMethod] + public void SingleCell() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.Cell(1, 1).Value = "Hello World!"; + wb.NamedRanges.Add("SingleCell", "Sheet1!$A$1"); + var range = wb.Range( "SingleCell" ); + Assert.AreEqual( 1, range.CellsUsed().Count() ); + Assert.AreEqual("Hello World!", range.CellsUsed().Single().GetString()); + } + + [TestMethod] + public void WsNamedCell() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.Cell(1, 1).SetValue("Test").AddToNamed("TestCell", XLScope.Worksheet); + Assert.AreEqual("Test", ws.Cell("TestCell").GetString()); + } + + [TestMethod] + public void WsNamedCells() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.Cell(1, 1).SetValue("Test").AddToNamed("TestCell", XLScope.Worksheet); + ws.Cell(2, 1).SetValue("B"); + var cells = ws.Cells("TestCell, A2"); + Assert.AreEqual("Test", cells.First().GetString()); + Assert.AreEqual("B", cells.Last().GetString()); + } + + [TestMethod] + public void WsNamedRange() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.Cell(1, 1).SetValue("A"); + ws.Cell(2, 1).SetValue("B"); + var original = ws.Range("A1:A2"); + original.AddToNamed("TestRange", XLScope.Worksheet); + var named = ws.Range("TestRange"); + Assert.AreEqual(original.RangeAddress.ToStringFixed(), named.RangeAddress.ToString()); + } + + [TestMethod] + public void WsNamedRanges() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.Cell(1, 1).SetValue("A"); + ws.Cell(2, 1).SetValue("B"); + ws.Cell(3, 1).SetValue("C"); + var original = ws.Range("A1:A2"); + original.AddToNamed("TestRange", XLScope.Worksheet); + var namedRanges = ws.Ranges("TestRange, A3"); + Assert.AreEqual(original.RangeAddress.ToStringFixed(), namedRanges.First().RangeAddress.ToString()); + Assert.AreEqual("$A$3:$A$3", namedRanges.Last().RangeAddress.ToStringFixed()); + } + + [TestMethod] + public void WsNamedRangesOneString() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.NamedRanges.Add("TestRange", "Sheet1!$A$1,Sheet1!$A$3"); + var namedRanges = ws.Ranges("TestRange"); + + Assert.AreEqual("$A$1:$A$1", namedRanges.First().RangeAddress.ToStringFixed()); + Assert.AreEqual("$A$3:$A$3", namedRanges.Last().RangeAddress.ToStringFixed()); + } + + //[TestMethod] + //public void WsNamedRangeLiteral() + //{ + // var wb = new XLWorkbook(); + // var ws = wb.Worksheets.Add("Sheet1"); + // ws.NamedRanges.Add("TestRange", "\"Hello\""); + // using (MemoryStream memoryStream = new MemoryStream()) + // { + // wb.SaveAs(memoryStream); + // var wb2 = new XLWorkbook(memoryStream); + // var text = wb2.Worksheet("Sheet1").NamedRanges.First() + // memoryStream.Close(); + // } + + + //} + } +} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/RichText/XLRichStringTest.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/RichText/XLRichStringTest.cs deleted file mode 100644 index db4f75d..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/RichText/XLRichStringTest.cs +++ /dev/null @@ -1,683 +0,0 @@ -using ClosedXML.Excel; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System.Linq; -using System; - -namespace ClosedXML_Tests -{ - - - /// - ///This is a test class for XLRichStringTest and is intended - ///to contain all XLRichStringTest Unit Tests - /// - [TestClass()] - public class XLRichStringTest - { - - /// - ///A test for ToString - /// - [TestMethod()] - public void ToStringTest() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Hello"); - richString.AddText(" "); - richString.AddText("World"); - string expected = "Hello World"; - string actual = richString.ToString(); - Assert.AreEqual(expected, actual); - - richString.AddText("!"); - expected = "Hello World!"; - actual = richString.ToString(); - Assert.AreEqual(expected, actual); - - richString.ClearText(); - expected = String.Empty; - actual = richString.ToString(); - Assert.AreEqual(expected, actual); - } - - /// - ///A test for AddText - /// - [TestMethod()] - public void AddTextTest1() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - var richString = cell.RichText; - - string text = "Hello"; - richString.AddText(text).SetBold().SetFontColor(XLColor.Red); - - Assert.AreEqual(cell.GetString(), text); - Assert.AreEqual(cell.RichText.First().Bold, true); - Assert.AreEqual(cell.RichText.First().FontColor, XLColor.Red); - - Assert.AreEqual(1, richString.Count); - - richString.AddText("World"); - Assert.AreEqual(richString.First().Text, text, "Item in collection is not the same as the one returned"); - } - - [TestMethod()] - public void AddTextTest2() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - Int32 number = 123; - - cell.SetValue(number).Style - .Font.SetBold() - .Font.SetFontColor(XLColor.Red); - - string text = number.ToString(); - - Assert.AreEqual(cell.RichText.ToString(), text); - Assert.AreEqual(cell.RichText.First().Bold, true); - Assert.AreEqual(cell.RichText.First().FontColor, XLColor.Red); - - Assert.AreEqual(1, cell.RichText.Count); - - cell.RichText.AddText("World"); - Assert.AreEqual(cell.RichText.First().Text, text, "Item in collection is not the same as the one returned"); - } - - [TestMethod()] - public void AddTextTest3() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - Int32 number = 123; - cell.Value = number; - cell.Style - .Font.SetBold() - .Font.SetFontColor(XLColor.Red); - - string text = number.ToString(); - - Assert.AreEqual(cell.RichText.ToString(), text); - Assert.AreEqual(cell.RichText.First().Bold, true); - Assert.AreEqual(cell.RichText.First().FontColor, XLColor.Red); - - Assert.AreEqual(1, cell.RichText.Count); - - cell.RichText.AddText("World"); - Assert.AreEqual(cell.RichText.First().Text, text, "Item in collection is not the same as the one returned"); - } - - [TestMethod()] - public void HasRichTextTest1() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.RichText.AddText("123"); - - Assert.AreEqual(true, cell.HasRichText); - - cell.DataType = XLCellValues.Text; - - Assert.AreEqual(true, cell.HasRichText); - - cell.DataType = XLCellValues.Number; - - Assert.AreEqual(false, cell.HasRichText); - - cell.RichText.AddText("123"); - - Assert.AreEqual(true, cell.HasRichText); - - cell.Value = 123; - - Assert.AreEqual(false, cell.HasRichText); - - cell.RichText.AddText("123"); - - Assert.AreEqual(true, cell.HasRichText); - - cell.SetValue("123"); - - Assert.AreEqual(false, cell.HasRichText); - - } - - [TestMethod()] - public void AccessRichTextTest1() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var cell = ws.Cell(1, 1); - cell.RichText.AddText("12"); - cell.DataType = XLCellValues.Number; - - Assert.AreEqual(12.0, cell.GetDouble()); - - var richText = cell.RichText; - - Assert.AreEqual("12", richText.ToString()); - - richText.AddText("34"); - - Assert.AreEqual("1234", cell.GetString()); - - Assert.AreEqual(XLCellValues.Number, cell.DataType); - - Assert.AreEqual(1234.0, cell.GetDouble()); - - } - - /// - ///A test for Characters - /// - [TestMethod()] - public void Substring_All_From_OneString() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Hello"); - - var actual = richString.Substring(0); - - Assert.AreEqual(richString.First(), actual.First()); - - Assert.AreEqual(1, actual.Count); - - actual.First().SetBold(); - - Assert.AreEqual(true, ws.Cell(1, 1).RichText.First().Bold); - } - - [TestMethod()] - public void Substring_From_OneString_Start() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Hello"); - - var actual = richString.Substring(0, 2); - - Assert.AreEqual(1, actual.Count); // substring was in one piece - - Assert.AreEqual(2, richString.Count); // The text was split because of the substring - - Assert.AreEqual("He", actual.First().Text); - - Assert.AreEqual("He", richString.First().Text); - Assert.AreEqual("llo", richString.Last().Text); - - actual.First().SetBold(); - - Assert.AreEqual(true, ws.Cell(1, 1).RichText.First().Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.Last().Bold); - - richString.Last().SetItalic(); - - Assert.AreEqual(false, ws.Cell(1, 1).RichText.First().Italic); - Assert.AreEqual(true, ws.Cell(1, 1).RichText.Last().Italic); - - Assert.AreEqual(false, actual.First().Italic); - - richString.SetFontSize(20); - - Assert.AreEqual(20, ws.Cell(1, 1).RichText.First().FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.Last().FontSize); - - Assert.AreEqual(20, actual.First().FontSize); - } - - [TestMethod()] - public void Substring_From_OneString_End() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Hello"); - - var actual = richString.Substring(2); - - Assert.AreEqual(1, actual.Count); // substring was in one piece - - Assert.AreEqual(2, richString.Count); // The text was split because of the substring - - Assert.AreEqual("llo", actual.First().Text); - - Assert.AreEqual("He", richString.First().Text); - Assert.AreEqual("llo", richString.Last().Text); - - actual.First().SetBold(); - - Assert.AreEqual(false, ws.Cell(1, 1).RichText.First().Bold); - Assert.AreEqual(true, ws.Cell(1, 1).RichText.Last().Bold); - - richString.Last().SetItalic(); - - Assert.AreEqual(false, ws.Cell(1, 1).RichText.First().Italic); - Assert.AreEqual(true, ws.Cell(1, 1).RichText.Last().Italic); - - Assert.AreEqual(true, actual.First().Italic); - - richString.SetFontSize(20); - - Assert.AreEqual(20, ws.Cell(1, 1).RichText.First().FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.Last().FontSize); - - Assert.AreEqual(20, actual.First().FontSize); - } - - [TestMethod()] - public void Substring_From_OneString_Middle() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Hello"); - - var actual = richString.Substring(2, 2); - - Assert.AreEqual(1, actual.Count); // substring was in one piece - - Assert.AreEqual(3, richString.Count); // The text was split because of the substring - - Assert.AreEqual("ll", actual.First().Text); - - Assert.AreEqual("He", richString.First().Text); - Assert.AreEqual("ll", richString.ElementAt(1).Text); - Assert.AreEqual("o", richString.Last().Text); - - actual.First().SetBold(); - - Assert.AreEqual(false, ws.Cell(1, 1).RichText.First().Bold); - Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(1).Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.Last().Bold); - - richString.Last().SetItalic(); - - Assert.AreEqual(false, ws.Cell(1, 1).RichText.First().Italic); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Italic); - Assert.AreEqual(true, ws.Cell(1, 1).RichText.Last().Italic); - - Assert.AreEqual(false, actual.First().Italic); - - richString.SetFontSize(20); - - Assert.AreEqual(20, ws.Cell(1, 1).RichText.First().FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(1).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.Last().FontSize); - - Assert.AreEqual(20, actual.First().FontSize); - } - - [TestMethod()] - [ExpectedException(typeof(IndexOutOfRangeException))] - public void Substring_IndexOutsideRange1() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Hello"); - - var richText = richString.Substring(50); - } - - [TestMethod()] - [ExpectedException(typeof(IndexOutOfRangeException))] - public void Substring_IndexOutsideRange2() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Hello"); - richString.AddText("World"); - - var richText = richString.Substring(50); - } - - [TestMethod()] - [ExpectedException(typeof(IndexOutOfRangeException))] - public void Substring_IndexOutsideRange3() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Hello"); - - var richText = richString.Substring(1, 10); - } - - [TestMethod()] - [ExpectedException(typeof(IndexOutOfRangeException))] - public void Substring_IndexOutsideRange4() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Hello"); - richString.AddText("World"); - - var richText = richString.Substring(5, 20); - } - - [TestMethod()] - public void Substring_All_From_ThreeStrings() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Good Morning"); - richString.AddText(" my "); - richString.AddText("neighbors!"); - - var actual = richString.Substring(0); - - Assert.AreEqual(richString.ElementAt(0), actual.ElementAt(0)); - Assert.AreEqual(richString.ElementAt(1), actual.ElementAt(1)); - Assert.AreEqual(richString.ElementAt(2), actual.ElementAt(2)); - - Assert.AreEqual(3, actual.Count); - Assert.AreEqual(3, richString.Count); - - actual.First().SetBold(); - - Assert.AreEqual(true, ws.Cell(1, 1).RichText.First().Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.Last().Bold); - } - - [TestMethod()] - public void Substring_From_ThreeStrings_Start1() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Good Morning"); - richString.AddText(" my "); - richString.AddText("neighbors!"); - - var actual = richString.Substring(0, 4); - - Assert.AreEqual(1, actual.Count); // substring was in one piece - - Assert.AreEqual(4, richString.Count); // The text was split because of the substring - - Assert.AreEqual("Good", actual.First().Text); - - Assert.AreEqual("Good", richString.ElementAt(0).Text); - Assert.AreEqual(" Morning", richString.ElementAt(1).Text); - Assert.AreEqual(" my ", richString.ElementAt(2).Text); - Assert.AreEqual("neighbors!", richString.ElementAt(3).Text); - - actual.First().SetBold(); - - Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(0).Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(3).Bold); - - richString.First().SetItalic(); - - Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(0).Italic); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Italic); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Italic); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(3).Italic); - - Assert.AreEqual(true, actual.First().Italic); - - richString.SetFontSize(20); - - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(0).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(1).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(2).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(3).FontSize); - - Assert.AreEqual(20, actual.First().FontSize); - } - - [TestMethod()] - public void Substring_From_ThreeStrings_Start2() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Good Morning"); - richString.AddText(" my "); - richString.AddText("neighbors!"); - - var actual = richString.Substring(0, 15); - - Assert.AreEqual(2, actual.Count); - - Assert.AreEqual(4, richString.Count); // The text was split because of the substring - - Assert.AreEqual("Good Morning", actual.ElementAt(0).Text); - Assert.AreEqual(" my", actual.ElementAt(1).Text); - - Assert.AreEqual("Good Morning", richString.ElementAt(0).Text); - Assert.AreEqual(" my", richString.ElementAt(1).Text); - Assert.AreEqual(" ", richString.ElementAt(2).Text); - Assert.AreEqual("neighbors!", richString.ElementAt(3).Text); - - actual.ElementAt(1).SetBold(); - - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(0).Bold); - Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(1).Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(3).Bold); - - richString.First().SetItalic(); - - Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(0).Italic); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Italic); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Italic); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(3).Italic); - - Assert.AreEqual(true, actual.ElementAt(0).Italic); - Assert.AreEqual(false, actual.ElementAt(1).Italic); - - richString.SetFontSize(20); - - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(0).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(1).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(2).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(3).FontSize); - - Assert.AreEqual(20, actual.ElementAt(0).FontSize); - Assert.AreEqual(20, actual.ElementAt(1).FontSize); - } - - [TestMethod()] - public void Substring_From_ThreeStrings_End1() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Good Morning"); - richString.AddText(" my "); - richString.AddText("neighbors!"); - - var actual = richString.Substring(21); - - Assert.AreEqual(1, actual.Count); // substring was in one piece - - Assert.AreEqual(4, richString.Count); // The text was split because of the substring - - Assert.AreEqual("bors!", actual.First().Text); - - Assert.AreEqual("Good Morning", richString.ElementAt(0).Text); - Assert.AreEqual(" my ", richString.ElementAt(1).Text); - Assert.AreEqual("neigh", richString.ElementAt(2).Text); - Assert.AreEqual("bors!", richString.ElementAt(3).Text); - - actual.First().SetBold(); - - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(0).Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Bold); - Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(3).Bold); - - richString.Last().SetItalic(); - - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(0).Italic); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Italic); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Italic); - Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(3).Italic); - - Assert.AreEqual(true, actual.First().Italic); - - richString.SetFontSize(20); - - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(0).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(1).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(2).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(3).FontSize); - - Assert.AreEqual(20, actual.First().FontSize); - } - - [TestMethod()] - public void Substring_From_ThreeStrings_End2() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Good Morning"); - richString.AddText(" my "); - richString.AddText("neighbors!"); - - var actual = richString.Substring(13); - - Assert.AreEqual(2, actual.Count); - - Assert.AreEqual(4, richString.Count); // The text was split because of the substring - - Assert.AreEqual("my ", actual.ElementAt(0).Text); - Assert.AreEqual("neighbors!", actual.ElementAt(1).Text); - - Assert.AreEqual("Good Morning", richString.ElementAt(0).Text); - Assert.AreEqual(" ", richString.ElementAt(1).Text); - Assert.AreEqual("my ", richString.ElementAt(2).Text); - Assert.AreEqual("neighbors!", richString.ElementAt(3).Text); - - actual.ElementAt(1).SetBold(); - - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(0).Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Bold); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Bold); - Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(3).Bold); - - richString.Last().SetItalic(); - - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(0).Italic); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Italic); - Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Italic); - Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(3).Italic); - - Assert.AreEqual(false, actual.ElementAt(0).Italic); - Assert.AreEqual(true, actual.ElementAt(1).Italic); - - richString.SetFontSize(20); - - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(0).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(1).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(2).FontSize); - Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(3).FontSize); - - Assert.AreEqual(20, actual.ElementAt(0).FontSize); - Assert.AreEqual(20, actual.ElementAt(1).FontSize); - } - - [TestMethod()] - public void Substring_From_ThreeStrings_Mid1() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Good Morning"); - richString.AddText(" my "); - richString.AddText("neighbors!"); - - var actual = richString.Substring(5, 10); - - Assert.AreEqual(2, actual.Count); - - Assert.AreEqual(5, richString.Count); // The text was split because of the substring - - Assert.AreEqual("Morning", actual.ElementAt(0).Text); - Assert.AreEqual(" my", actual.ElementAt(1).Text); - - Assert.AreEqual("Good ", richString.ElementAt(0).Text); - Assert.AreEqual("Morning", richString.ElementAt(1).Text); - Assert.AreEqual(" my", richString.ElementAt(2).Text); - Assert.AreEqual(" ", richString.ElementAt(3).Text); - Assert.AreEqual("neighbors!", richString.ElementAt(4).Text); - } - - [TestMethod()] - public void Substring_From_ThreeStrings_Mid2() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Good Morning"); - richString.AddText(" my "); - richString.AddText("neighbors!"); - - var actual = richString.Substring(5, 15); - - Assert.AreEqual(3, actual.Count); - - Assert.AreEqual(5, richString.Count); // The text was split because of the substring - - Assert.AreEqual("Morning", actual.ElementAt(0).Text); - Assert.AreEqual(" my ", actual.ElementAt(1).Text); - Assert.AreEqual("neig", actual.ElementAt(2).Text); - - Assert.AreEqual("Good ", richString.ElementAt(0).Text); - Assert.AreEqual("Morning", richString.ElementAt(1).Text); - Assert.AreEqual(" my ", richString.ElementAt(2).Text); - Assert.AreEqual("neig", richString.ElementAt(3).Text); - Assert.AreEqual("hbors!", richString.ElementAt(4).Text); - } - - - /// - ///A test for Clear - /// - [TestMethod()] - public void ClearTest() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Hello"); - richString.AddText(" "); - richString.AddText("World!"); - - richString.ClearText(); - String expected = String.Empty; - String actual = richString.ToString(); - Assert.AreEqual(expected, actual); - - Assert.AreEqual(0, richString.Count); - } - - [TestMethod()] - public void CountTest() - { - var ws = new XLWorkbook().Worksheets.Add("Sheet1"); - var richString = ws.Cell(1, 1).RichText; - - richString.AddText("Hello"); - richString.AddText(" "); - richString.AddText("World!"); - - Assert.AreEqual(3, richString.Count); - } - - } -} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/RichText/XLRichStringTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/RichText/XLRichStringTests.cs new file mode 100644 index 0000000..602b37f --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/RichText/XLRichStringTests.cs @@ -0,0 +1,683 @@ +using ClosedXML.Excel; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System.Linq; +using System; + +namespace ClosedXML_Tests +{ + + + /// + ///This is a test class for XLRichStringTests and is intended + ///to contain all XLRichStringTests Unit Tests + /// + [TestClass()] + public class XLRichStringTests + { + + /// + ///A test for ToString + /// + [TestMethod()] + public void ToStringTest() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Hello"); + richString.AddText(" "); + richString.AddText("World"); + string expected = "Hello World"; + string actual = richString.ToString(); + Assert.AreEqual(expected, actual); + + richString.AddText("!"); + expected = "Hello World!"; + actual = richString.ToString(); + Assert.AreEqual(expected, actual); + + richString.ClearText(); + expected = String.Empty; + actual = richString.ToString(); + Assert.AreEqual(expected, actual); + } + + /// + ///A test for AddText + /// + [TestMethod()] + public void AddTextTest1() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + var richString = cell.RichText; + + string text = "Hello"; + richString.AddText(text).SetBold().SetFontColor(XLColor.Red); + + Assert.AreEqual(cell.GetString(), text); + Assert.AreEqual(cell.RichText.First().Bold, true); + Assert.AreEqual(cell.RichText.First().FontColor, XLColor.Red); + + Assert.AreEqual(1, richString.Count); + + richString.AddText("World"); + Assert.AreEqual(richString.First().Text, text, "Item in collection is not the same as the one returned"); + } + + [TestMethod()] + public void AddTextTest2() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + Int32 number = 123; + + cell.SetValue(number).Style + .Font.SetBold() + .Font.SetFontColor(XLColor.Red); + + string text = number.ToString(); + + Assert.AreEqual(cell.RichText.ToString(), text); + Assert.AreEqual(cell.RichText.First().Bold, true); + Assert.AreEqual(cell.RichText.First().FontColor, XLColor.Red); + + Assert.AreEqual(1, cell.RichText.Count); + + cell.RichText.AddText("World"); + Assert.AreEqual(cell.RichText.First().Text, text, "Item in collection is not the same as the one returned"); + } + + [TestMethod()] + public void AddTextTest3() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + Int32 number = 123; + cell.Value = number; + cell.Style + .Font.SetBold() + .Font.SetFontColor(XLColor.Red); + + string text = number.ToString(); + + Assert.AreEqual(cell.RichText.ToString(), text); + Assert.AreEqual(cell.RichText.First().Bold, true); + Assert.AreEqual(cell.RichText.First().FontColor, XLColor.Red); + + Assert.AreEqual(1, cell.RichText.Count); + + cell.RichText.AddText("World"); + Assert.AreEqual(cell.RichText.First().Text, text, "Item in collection is not the same as the one returned"); + } + + [TestMethod()] + public void HasRichTextTest1() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.RichText.AddText("123"); + + Assert.AreEqual(true, cell.HasRichText); + + cell.DataType = XLCellValues.Text; + + Assert.AreEqual(true, cell.HasRichText); + + cell.DataType = XLCellValues.Number; + + Assert.AreEqual(false, cell.HasRichText); + + cell.RichText.AddText("123"); + + Assert.AreEqual(true, cell.HasRichText); + + cell.Value = 123; + + Assert.AreEqual(false, cell.HasRichText); + + cell.RichText.AddText("123"); + + Assert.AreEqual(true, cell.HasRichText); + + cell.SetValue("123"); + + Assert.AreEqual(false, cell.HasRichText); + + } + + [TestMethod()] + public void AccessRichTextTest1() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var cell = ws.Cell(1, 1); + cell.RichText.AddText("12"); + cell.DataType = XLCellValues.Number; + + Assert.AreEqual(12.0, cell.GetDouble()); + + var richText = cell.RichText; + + Assert.AreEqual("12", richText.ToString()); + + richText.AddText("34"); + + Assert.AreEqual("1234", cell.GetString()); + + Assert.AreEqual(XLCellValues.Number, cell.DataType); + + Assert.AreEqual(1234.0, cell.GetDouble()); + + } + + /// + ///A test for Characters + /// + [TestMethod()] + public void Substring_All_From_OneString() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Hello"); + + var actual = richString.Substring(0); + + Assert.AreEqual(richString.First(), actual.First()); + + Assert.AreEqual(1, actual.Count); + + actual.First().SetBold(); + + Assert.AreEqual(true, ws.Cell(1, 1).RichText.First().Bold); + } + + [TestMethod()] + public void Substring_From_OneString_Start() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Hello"); + + var actual = richString.Substring(0, 2); + + Assert.AreEqual(1, actual.Count); // substring was in one piece + + Assert.AreEqual(2, richString.Count); // The text was split because of the substring + + Assert.AreEqual("He", actual.First().Text); + + Assert.AreEqual("He", richString.First().Text); + Assert.AreEqual("llo", richString.Last().Text); + + actual.First().SetBold(); + + Assert.AreEqual(true, ws.Cell(1, 1).RichText.First().Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.Last().Bold); + + richString.Last().SetItalic(); + + Assert.AreEqual(false, ws.Cell(1, 1).RichText.First().Italic); + Assert.AreEqual(true, ws.Cell(1, 1).RichText.Last().Italic); + + Assert.AreEqual(false, actual.First().Italic); + + richString.SetFontSize(20); + + Assert.AreEqual(20, ws.Cell(1, 1).RichText.First().FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.Last().FontSize); + + Assert.AreEqual(20, actual.First().FontSize); + } + + [TestMethod()] + public void Substring_From_OneString_End() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Hello"); + + var actual = richString.Substring(2); + + Assert.AreEqual(1, actual.Count); // substring was in one piece + + Assert.AreEqual(2, richString.Count); // The text was split because of the substring + + Assert.AreEqual("llo", actual.First().Text); + + Assert.AreEqual("He", richString.First().Text); + Assert.AreEqual("llo", richString.Last().Text); + + actual.First().SetBold(); + + Assert.AreEqual(false, ws.Cell(1, 1).RichText.First().Bold); + Assert.AreEqual(true, ws.Cell(1, 1).RichText.Last().Bold); + + richString.Last().SetItalic(); + + Assert.AreEqual(false, ws.Cell(1, 1).RichText.First().Italic); + Assert.AreEqual(true, ws.Cell(1, 1).RichText.Last().Italic); + + Assert.AreEqual(true, actual.First().Italic); + + richString.SetFontSize(20); + + Assert.AreEqual(20, ws.Cell(1, 1).RichText.First().FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.Last().FontSize); + + Assert.AreEqual(20, actual.First().FontSize); + } + + [TestMethod()] + public void Substring_From_OneString_Middle() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Hello"); + + var actual = richString.Substring(2, 2); + + Assert.AreEqual(1, actual.Count); // substring was in one piece + + Assert.AreEqual(3, richString.Count); // The text was split because of the substring + + Assert.AreEqual("ll", actual.First().Text); + + Assert.AreEqual("He", richString.First().Text); + Assert.AreEqual("ll", richString.ElementAt(1).Text); + Assert.AreEqual("o", richString.Last().Text); + + actual.First().SetBold(); + + Assert.AreEqual(false, ws.Cell(1, 1).RichText.First().Bold); + Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(1).Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.Last().Bold); + + richString.Last().SetItalic(); + + Assert.AreEqual(false, ws.Cell(1, 1).RichText.First().Italic); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Italic); + Assert.AreEqual(true, ws.Cell(1, 1).RichText.Last().Italic); + + Assert.AreEqual(false, actual.First().Italic); + + richString.SetFontSize(20); + + Assert.AreEqual(20, ws.Cell(1, 1).RichText.First().FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(1).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.Last().FontSize); + + Assert.AreEqual(20, actual.First().FontSize); + } + + [TestMethod()] + [ExpectedException(typeof(IndexOutOfRangeException))] + public void Substring_IndexOutsideRange1() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Hello"); + + var richText = richString.Substring(50); + } + + [TestMethod()] + [ExpectedException(typeof(IndexOutOfRangeException))] + public void Substring_IndexOutsideRange2() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Hello"); + richString.AddText("World"); + + var richText = richString.Substring(50); + } + + [TestMethod()] + [ExpectedException(typeof(IndexOutOfRangeException))] + public void Substring_IndexOutsideRange3() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Hello"); + + var richText = richString.Substring(1, 10); + } + + [TestMethod()] + [ExpectedException(typeof(IndexOutOfRangeException))] + public void Substring_IndexOutsideRange4() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Hello"); + richString.AddText("World"); + + var richText = richString.Substring(5, 20); + } + + [TestMethod()] + public void Substring_All_From_ThreeStrings() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Good Morning"); + richString.AddText(" my "); + richString.AddText("neighbors!"); + + var actual = richString.Substring(0); + + Assert.AreEqual(richString.ElementAt(0), actual.ElementAt(0)); + Assert.AreEqual(richString.ElementAt(1), actual.ElementAt(1)); + Assert.AreEqual(richString.ElementAt(2), actual.ElementAt(2)); + + Assert.AreEqual(3, actual.Count); + Assert.AreEqual(3, richString.Count); + + actual.First().SetBold(); + + Assert.AreEqual(true, ws.Cell(1, 1).RichText.First().Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.Last().Bold); + } + + [TestMethod()] + public void Substring_From_ThreeStrings_Start1() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Good Morning"); + richString.AddText(" my "); + richString.AddText("neighbors!"); + + var actual = richString.Substring(0, 4); + + Assert.AreEqual(1, actual.Count); // substring was in one piece + + Assert.AreEqual(4, richString.Count); // The text was split because of the substring + + Assert.AreEqual("Good", actual.First().Text); + + Assert.AreEqual("Good", richString.ElementAt(0).Text); + Assert.AreEqual(" Morning", richString.ElementAt(1).Text); + Assert.AreEqual(" my ", richString.ElementAt(2).Text); + Assert.AreEqual("neighbors!", richString.ElementAt(3).Text); + + actual.First().SetBold(); + + Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(0).Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(3).Bold); + + richString.First().SetItalic(); + + Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(0).Italic); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Italic); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Italic); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(3).Italic); + + Assert.AreEqual(true, actual.First().Italic); + + richString.SetFontSize(20); + + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(0).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(1).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(2).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(3).FontSize); + + Assert.AreEqual(20, actual.First().FontSize); + } + + [TestMethod()] + public void Substring_From_ThreeStrings_Start2() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Good Morning"); + richString.AddText(" my "); + richString.AddText("neighbors!"); + + var actual = richString.Substring(0, 15); + + Assert.AreEqual(2, actual.Count); + + Assert.AreEqual(4, richString.Count); // The text was split because of the substring + + Assert.AreEqual("Good Morning", actual.ElementAt(0).Text); + Assert.AreEqual(" my", actual.ElementAt(1).Text); + + Assert.AreEqual("Good Morning", richString.ElementAt(0).Text); + Assert.AreEqual(" my", richString.ElementAt(1).Text); + Assert.AreEqual(" ", richString.ElementAt(2).Text); + Assert.AreEqual("neighbors!", richString.ElementAt(3).Text); + + actual.ElementAt(1).SetBold(); + + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(0).Bold); + Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(1).Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(3).Bold); + + richString.First().SetItalic(); + + Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(0).Italic); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Italic); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Italic); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(3).Italic); + + Assert.AreEqual(true, actual.ElementAt(0).Italic); + Assert.AreEqual(false, actual.ElementAt(1).Italic); + + richString.SetFontSize(20); + + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(0).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(1).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(2).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(3).FontSize); + + Assert.AreEqual(20, actual.ElementAt(0).FontSize); + Assert.AreEqual(20, actual.ElementAt(1).FontSize); + } + + [TestMethod()] + public void Substring_From_ThreeStrings_End1() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Good Morning"); + richString.AddText(" my "); + richString.AddText("neighbors!"); + + var actual = richString.Substring(21); + + Assert.AreEqual(1, actual.Count); // substring was in one piece + + Assert.AreEqual(4, richString.Count); // The text was split because of the substring + + Assert.AreEqual("bors!", actual.First().Text); + + Assert.AreEqual("Good Morning", richString.ElementAt(0).Text); + Assert.AreEqual(" my ", richString.ElementAt(1).Text); + Assert.AreEqual("neigh", richString.ElementAt(2).Text); + Assert.AreEqual("bors!", richString.ElementAt(3).Text); + + actual.First().SetBold(); + + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(0).Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Bold); + Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(3).Bold); + + richString.Last().SetItalic(); + + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(0).Italic); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Italic); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Italic); + Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(3).Italic); + + Assert.AreEqual(true, actual.First().Italic); + + richString.SetFontSize(20); + + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(0).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(1).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(2).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(3).FontSize); + + Assert.AreEqual(20, actual.First().FontSize); + } + + [TestMethod()] + public void Substring_From_ThreeStrings_End2() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Good Morning"); + richString.AddText(" my "); + richString.AddText("neighbors!"); + + var actual = richString.Substring(13); + + Assert.AreEqual(2, actual.Count); + + Assert.AreEqual(4, richString.Count); // The text was split because of the substring + + Assert.AreEqual("my ", actual.ElementAt(0).Text); + Assert.AreEqual("neighbors!", actual.ElementAt(1).Text); + + Assert.AreEqual("Good Morning", richString.ElementAt(0).Text); + Assert.AreEqual(" ", richString.ElementAt(1).Text); + Assert.AreEqual("my ", richString.ElementAt(2).Text); + Assert.AreEqual("neighbors!", richString.ElementAt(3).Text); + + actual.ElementAt(1).SetBold(); + + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(0).Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Bold); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Bold); + Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(3).Bold); + + richString.Last().SetItalic(); + + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(0).Italic); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(1).Italic); + Assert.AreEqual(false, ws.Cell(1, 1).RichText.ElementAt(2).Italic); + Assert.AreEqual(true, ws.Cell(1, 1).RichText.ElementAt(3).Italic); + + Assert.AreEqual(false, actual.ElementAt(0).Italic); + Assert.AreEqual(true, actual.ElementAt(1).Italic); + + richString.SetFontSize(20); + + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(0).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(1).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(2).FontSize); + Assert.AreEqual(20, ws.Cell(1, 1).RichText.ElementAt(3).FontSize); + + Assert.AreEqual(20, actual.ElementAt(0).FontSize); + Assert.AreEqual(20, actual.ElementAt(1).FontSize); + } + + [TestMethod()] + public void Substring_From_ThreeStrings_Mid1() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Good Morning"); + richString.AddText(" my "); + richString.AddText("neighbors!"); + + var actual = richString.Substring(5, 10); + + Assert.AreEqual(2, actual.Count); + + Assert.AreEqual(5, richString.Count); // The text was split because of the substring + + Assert.AreEqual("Morning", actual.ElementAt(0).Text); + Assert.AreEqual(" my", actual.ElementAt(1).Text); + + Assert.AreEqual("Good ", richString.ElementAt(0).Text); + Assert.AreEqual("Morning", richString.ElementAt(1).Text); + Assert.AreEqual(" my", richString.ElementAt(2).Text); + Assert.AreEqual(" ", richString.ElementAt(3).Text); + Assert.AreEqual("neighbors!", richString.ElementAt(4).Text); + } + + [TestMethod()] + public void Substring_From_ThreeStrings_Mid2() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Good Morning"); + richString.AddText(" my "); + richString.AddText("neighbors!"); + + var actual = richString.Substring(5, 15); + + Assert.AreEqual(3, actual.Count); + + Assert.AreEqual(5, richString.Count); // The text was split because of the substring + + Assert.AreEqual("Morning", actual.ElementAt(0).Text); + Assert.AreEqual(" my ", actual.ElementAt(1).Text); + Assert.AreEqual("neig", actual.ElementAt(2).Text); + + Assert.AreEqual("Good ", richString.ElementAt(0).Text); + Assert.AreEqual("Morning", richString.ElementAt(1).Text); + Assert.AreEqual(" my ", richString.ElementAt(2).Text); + Assert.AreEqual("neig", richString.ElementAt(3).Text); + Assert.AreEqual("hbors!", richString.ElementAt(4).Text); + } + + + /// + ///A test for Clear + /// + [TestMethod()] + public void ClearTest() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Hello"); + richString.AddText(" "); + richString.AddText("World!"); + + richString.ClearText(); + String expected = String.Empty; + String actual = richString.ToString(); + Assert.AreEqual(expected, actual); + + Assert.AreEqual(0, richString.Count); + } + + [TestMethod()] + public void CountTest() + { + var ws = new XLWorkbook().Worksheets.Add("Sheet1"); + var richString = ws.Cell(1, 1).RichText; + + richString.AddText("Hello"); + richString.AddText(" "); + richString.AddText("World!"); + + Assert.AreEqual(3, richString.Count); + } + + } +} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Rows/RowTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Rows/RowTests.cs new file mode 100644 index 0000000..40b21d1 --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Rows/RowTests.cs @@ -0,0 +1,232 @@ +using ClosedXML.Excel; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; +using System.Linq; + +namespace ClosedXML_Tests.Excel +{ + /// + /// Summary description for UnitTest1 + /// + [TestClass] + public class RowTests + { + + [TestMethod] + public void RowUsed() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + ws.Cell(1, 2).SetValue("Test"); + ws.Cell(1, 3).SetValue("Test"); + + var fromRow = ws.Row(1).RowUsed(); + Assert.AreEqual("B1:C1", fromRow.RangeAddress.ToStringRelative()); + + var fromRange = ws.Range("A1:E1").FirstRow().RowUsed(); + Assert.AreEqual("B1:C1", fromRange.RangeAddress.ToStringRelative()); + } + + + [TestMethod] + public void NoRowsUsed() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + Int32 count = 0; + + foreach (var row in ws.RowsUsed()) + count++; + + foreach (var row in ws.Range("A1:C3").RowsUsed()) + count++; + + Assert.AreEqual(0, count); + } + + [TestMethod] + public void InsertingRowsAbove1() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + + ws.Rows("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); + ws.Row(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); + ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); + + var row1 = ws.Row(1); + var row2 = ws.Row(2); + var row3 = ws.Row(3); + + var rowIns = ws.Row(1).InsertRowsAbove(1).First(); + + Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Row(1).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Row(1).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Row(1).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, ws.Row(3).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", ws.Row(3).Cell(2).GetString()); + + + + Assert.AreEqual(ws.Style.Fill.BackgroundColor, rowIns.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(ws.Style.Fill.BackgroundColor, rowIns.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(ws.Style.Fill.BackgroundColor, rowIns.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, row1.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row1.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row1.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, row2.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, row2.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, row2.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, row3.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row3.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row3.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", row2.Cell(2).GetString()); + } + + [TestMethod] + public void InsertingRowsAbove2() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + + ws.Rows("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); + ws.Row(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); + ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); + + var row1 = ws.Row(1); + var row2 = ws.Row(2); + var row3 = ws.Row(3); + + var rowIns = ws.Row(2).InsertRowsAbove(1).First(); + + Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, ws.Row(3).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", ws.Row(3).Cell(2).GetString()); + + + + Assert.AreEqual(XLColor.Red, rowIns.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, rowIns.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, rowIns.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, row1.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row1.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row1.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, row2.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, row2.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, row2.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, row3.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row3.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row3.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", row2.Cell(2).GetString()); + } + + [TestMethod] + public void InsertingRowsAbove3() + { + var wb = new XLWorkbook(); + var ws = wb.Worksheets.Add("Sheet1"); + + ws.Rows("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); + ws.Row(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); + ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); + + var row1 = ws.Row(1); + var row2 = ws.Row(2); + var row3 = ws.Row(3); + + var rowIns = ws.Row(3).InsertRowsAbove(1).First(); + + Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, ws.Row(2).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, ws.Row(2).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, ws.Row(2).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, ws.Row(3).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", ws.Row(2).Cell(2).GetString()); + + + Assert.AreEqual(XLColor.Yellow, rowIns.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, rowIns.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, rowIns.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, row1.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row1.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row1.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Yellow, row2.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Green, row2.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Yellow, row2.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual(XLColor.Red, row3.Cell(1).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row3.Cell(2).Style.Fill.BackgroundColor); + Assert.AreEqual(XLColor.Red, row3.Cell(3).Style.Fill.BackgroundColor); + + Assert.AreEqual("X", row2.Cell(2).GetString()); + } + + + [TestMethod] + public void UngroupFromAll() + { + var ws = new XLWorkbook().AddWorksheet("Sheet1"); + ws.Rows(1,2).Group(); + ws.Rows(1,2).Ungroup(true); + + } + + [TestMethod] + public void CopyRow() + { + var wb = new XLWorkbook(); + var ws = wb.AddWorksheet("Sheet1"); + ws.FirstCell().SetValue("Test").Style.Font.SetBold(); + ws.FirstRow().CopyTo(ws.Row(2)); + + Assert.IsTrue(ws.Cell("A2").Style.Font.Bold); + } + } +} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Rows/RowsTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Rows/RowsTests.cs deleted file mode 100644 index 40b21d1..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Rows/RowsTests.cs +++ /dev/null @@ -1,232 +0,0 @@ -using ClosedXML.Excel; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System; -using System.Linq; - -namespace ClosedXML_Tests.Excel -{ - /// - /// Summary description for UnitTest1 - /// - [TestClass] - public class RowTests - { - - [TestMethod] - public void RowUsed() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - ws.Cell(1, 2).SetValue("Test"); - ws.Cell(1, 3).SetValue("Test"); - - var fromRow = ws.Row(1).RowUsed(); - Assert.AreEqual("B1:C1", fromRow.RangeAddress.ToStringRelative()); - - var fromRange = ws.Range("A1:E1").FirstRow().RowUsed(); - Assert.AreEqual("B1:C1", fromRange.RangeAddress.ToStringRelative()); - } - - - [TestMethod] - public void NoRowsUsed() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - Int32 count = 0; - - foreach (var row in ws.RowsUsed()) - count++; - - foreach (var row in ws.Range("A1:C3").RowsUsed()) - count++; - - Assert.AreEqual(0, count); - } - - [TestMethod] - public void InsertingRowsAbove1() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - - ws.Rows("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); - ws.Row(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); - ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - - var row1 = ws.Row(1); - var row2 = ws.Row(2); - var row3 = ws.Row(3); - - var rowIns = ws.Row(1).InsertRowsAbove(1).First(); - - Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Row(1).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Row(1).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Row(1).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, ws.Row(3).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", ws.Row(3).Cell(2).GetString()); - - - - Assert.AreEqual(ws.Style.Fill.BackgroundColor, rowIns.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(ws.Style.Fill.BackgroundColor, rowIns.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(ws.Style.Fill.BackgroundColor, rowIns.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, row1.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row1.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row1.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, row2.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, row2.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, row2.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, row3.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row3.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row3.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", row2.Cell(2).GetString()); - } - - [TestMethod] - public void InsertingRowsAbove2() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - - ws.Rows("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); - ws.Row(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); - ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - - var row1 = ws.Row(1); - var row2 = ws.Row(2); - var row3 = ws.Row(3); - - var rowIns = ws.Row(2).InsertRowsAbove(1).First(); - - Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(2).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, ws.Row(3).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", ws.Row(3).Cell(2).GetString()); - - - - Assert.AreEqual(XLColor.Red, rowIns.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, rowIns.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, rowIns.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, row1.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row1.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row1.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, row2.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, row2.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, row2.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, row3.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row3.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row3.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", row2.Cell(2).GetString()); - } - - [TestMethod] - public void InsertingRowsAbove3() - { - var wb = new XLWorkbook(); - var ws = wb.Worksheets.Add("Sheet1"); - - ws.Rows("1,3").Style.Fill.SetBackgroundColor(XLColor.Red); - ws.Row(2).Style.Fill.SetBackgroundColor(XLColor.Yellow); - ws.Cell(2, 2).SetValue("X").Style.Fill.SetBackgroundColor(XLColor.Green); - - var row1 = ws.Row(1); - var row2 = ws.Row(2); - var row3 = ws.Row(3); - - var rowIns = ws.Row(3).InsertRowsAbove(1).First(); - - Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(1).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, ws.Row(2).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, ws.Row(2).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, ws.Row(2).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, ws.Row(3).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, ws.Row(3).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, ws.Row(4).Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", ws.Row(2).Cell(2).GetString()); - - - Assert.AreEqual(XLColor.Yellow, rowIns.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, rowIns.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, rowIns.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, row1.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row1.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row1.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Yellow, row2.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Green, row2.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Yellow, row2.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual(XLColor.Red, row3.Cell(1).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row3.Cell(2).Style.Fill.BackgroundColor); - Assert.AreEqual(XLColor.Red, row3.Cell(3).Style.Fill.BackgroundColor); - - Assert.AreEqual("X", row2.Cell(2).GetString()); - } - - - [TestMethod] - public void UngroupFromAll() - { - var ws = new XLWorkbook().AddWorksheet("Sheet1"); - ws.Rows(1,2).Group(); - ws.Rows(1,2).Ungroup(true); - - } - - [TestMethod] - public void CopyRow() - { - var wb = new XLWorkbook(); - var ws = wb.AddWorksheet("Sheet1"); - ws.FirstCell().SetValue("Test").Style.Font.SetBold(); - ws.FirstRow().CopyTo(ws.Row(2)); - - Assert.IsTrue(ws.Cell("A2").Style.Font.Bold); - } - } -} diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/ExcelHelperTest.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/ExcelHelperTest.cs deleted file mode 100644 index b7f8cd1..0000000 --- a/ClosedXML/ClosedXML/ClosedXML_Tests/ExcelHelperTest.cs +++ /dev/null @@ -1,157 +0,0 @@ -using ClosedXML.Excel; -using Microsoft.VisualStudio.TestTools.UnitTesting; -using System; - -namespace ClosedXML_Tests -{ - /// - /// This is a test class for XLHelperTest and is intended - /// to contain all XLHelperTest Unit Tests - /// - [TestClass] - public class XLHelperTest - { - /// - /// Gets or sets the test context which provides - /// information about and functionality for the current test run. - /// - public TestContext TestContext { get; set; } - - #region Additional test attributes - - // - //You can use the following additional attributes as you write your tests: - // - //Use ClassInitialize to run code before running the first test in the class - //[ClassInitialize()] - //public static void MyClassInitialize(TestContext testContext) - //{ - //} - // - //Use ClassCleanup to run code after all tests in a class have run - //[ClassCleanup()] - //public static void MyClassCleanup() - //{ - //} - // - //Use TestInitialize to run code before running each test - //[TestInitialize()] - //public void MyTestInitialize() - //{ - //} - // - //Use TestCleanup to run code after each test has run - //[TestCleanup()] - //public void MyTestCleanup() - //{ - //} - // - - #endregion - - /// - /// A test for IsValidColumn - /// - [TestMethod] - public void IsValidColumnTest() - { - Assert.AreEqual(false, XLHelper.IsValidColumn("")); - Assert.AreEqual(false, XLHelper.IsValidColumn("1")); - Assert.AreEqual(false, XLHelper.IsValidColumn("A1")); - Assert.AreEqual(false, XLHelper.IsValidColumn("AA1")); - Assert.AreEqual(true, XLHelper.IsValidColumn("A")); - Assert.AreEqual(true, XLHelper.IsValidColumn("AA")); - Assert.AreEqual(true, XLHelper.IsValidColumn("AAA")); - Assert.AreEqual(true, XLHelper.IsValidColumn("Z")); - Assert.AreEqual(true, XLHelper.IsValidColumn("ZZ")); - Assert.AreEqual(true, XLHelper.IsValidColumn("XFD")); - Assert.AreEqual(false, XLHelper.IsValidColumn("ZAA")); - Assert.AreEqual(false, XLHelper.IsValidColumn("XZA")); - Assert.AreEqual(false, XLHelper.IsValidColumn("XFZ")); - } - - [TestMethod] - public void ReplaceRelative1() - { - var result = XLHelper.ReplaceRelative("A1", 2, "B"); - Assert.AreEqual("B2", result); - } - - [TestMethod] - public void ReplaceRelative2() - { - var result = XLHelper.ReplaceRelative("$A1", 2, "B"); - Assert.AreEqual("$A2", result); - } - - [TestMethod] - public void ReplaceRelative3() - { - var result = XLHelper.ReplaceRelative("A$1", 2, "B"); - Assert.AreEqual("B$1", result); - } - - [TestMethod] - public void ReplaceRelative4() - { - var result = XLHelper.ReplaceRelative("$A$1", 2, "B"); - Assert.AreEqual("$A$1", result); - } - - [TestMethod] - public void ReplaceRelative5() - { - var result = XLHelper.ReplaceRelative("1:1", 2, "B"); - Assert.AreEqual("2:2", result); - } - - [TestMethod] - public void ReplaceRelative6() - { - var result = XLHelper.ReplaceRelative("$1:1", 2, "B"); - Assert.AreEqual("$1:2", result); - } - - [TestMethod] - public void ReplaceRelative7() - { - var result = XLHelper.ReplaceRelative("1:$1", 2, "B"); - Assert.AreEqual("2:$1", result); - } - - [TestMethod] - public void ReplaceRelative8() - { - var result = XLHelper.ReplaceRelative("$1:$1", 2, "B"); - Assert.AreEqual("$1:$1", result); - } - - [TestMethod] - public void ReplaceRelative9() - { - var result = XLHelper.ReplaceRelative("A:A", 2, "B"); - Assert.AreEqual("B:B", result); - } - - [TestMethod] - public void ReplaceRelativeA() - { - var result = XLHelper.ReplaceRelative("$A:A", 2, "B"); - Assert.AreEqual("$A:B", result); - } - - [TestMethod] - public void ReplaceRelativeB() - { - var result = XLHelper.ReplaceRelative("A:$A", 2, "B"); - Assert.AreEqual("B:$A", result); - } - - [TestMethod] - public void ReplaceRelativeC() - { - var result = XLHelper.ReplaceRelative("$A:$A", 2, "B"); - Assert.AreEqual("$A:$A", result); - } - } -} \ No newline at end of file diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/XLHelperTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/XLHelperTests.cs new file mode 100644 index 0000000..a4c9658 --- /dev/null +++ b/ClosedXML/ClosedXML/ClosedXML_Tests/XLHelperTests.cs @@ -0,0 +1,157 @@ +using ClosedXML.Excel; +using Microsoft.VisualStudio.TestTools.UnitTesting; +using System; + +namespace ClosedXML_Tests +{ + /// + /// This is a test class for XLHelperTests and is intended + /// to contain all XLHelperTests Unit Tests + /// + [TestClass] + public class XLHelperTests + { + /// + /// Gets or sets the test context which provides + /// information about and functionality for the current test run. + /// + public TestContext TestContext { get; set; } + + #region Additional test attributes + + // + //You can use the following additional attributes as you write your tests: + // + //Use ClassInitialize to run code before running the first test in the class + //[ClassInitialize()] + //public static void MyClassInitialize(TestContext testContext) + //{ + //} + // + //Use ClassCleanup to run code after all tests in a class have run + //[ClassCleanup()] + //public static void MyClassCleanup() + //{ + //} + // + //Use TestInitialize to run code before running each test + //[TestInitialize()] + //public void MyTestInitialize() + //{ + //} + // + //Use TestCleanup to run code after each test has run + //[TestCleanup()] + //public void MyTestCleanup() + //{ + //} + // + + #endregion + + /// + /// A test for IsValidColumn + /// + [TestMethod] + public void IsValidColumnTest() + { + Assert.AreEqual(false, XLHelper.IsValidColumn("")); + Assert.AreEqual(false, XLHelper.IsValidColumn("1")); + Assert.AreEqual(false, XLHelper.IsValidColumn("A1")); + Assert.AreEqual(false, XLHelper.IsValidColumn("AA1")); + Assert.AreEqual(true, XLHelper.IsValidColumn("A")); + Assert.AreEqual(true, XLHelper.IsValidColumn("AA")); + Assert.AreEqual(true, XLHelper.IsValidColumn("AAA")); + Assert.AreEqual(true, XLHelper.IsValidColumn("Z")); + Assert.AreEqual(true, XLHelper.IsValidColumn("ZZ")); + Assert.AreEqual(true, XLHelper.IsValidColumn("XFD")); + Assert.AreEqual(false, XLHelper.IsValidColumn("ZAA")); + Assert.AreEqual(false, XLHelper.IsValidColumn("XZA")); + Assert.AreEqual(false, XLHelper.IsValidColumn("XFZ")); + } + + [TestMethod] + public void ReplaceRelative1() + { + var result = XLHelper.ReplaceRelative("A1", 2, "B"); + Assert.AreEqual("B2", result); + } + + [TestMethod] + public void ReplaceRelative2() + { + var result = XLHelper.ReplaceRelative("$A1", 2, "B"); + Assert.AreEqual("$A2", result); + } + + [TestMethod] + public void ReplaceRelative3() + { + var result = XLHelper.ReplaceRelative("A$1", 2, "B"); + Assert.AreEqual("B$1", result); + } + + [TestMethod] + public void ReplaceRelative4() + { + var result = XLHelper.ReplaceRelative("$A$1", 2, "B"); + Assert.AreEqual("$A$1", result); + } + + [TestMethod] + public void ReplaceRelative5() + { + var result = XLHelper.ReplaceRelative("1:1", 2, "B"); + Assert.AreEqual("2:2", result); + } + + [TestMethod] + public void ReplaceRelative6() + { + var result = XLHelper.ReplaceRelative("$1:1", 2, "B"); + Assert.AreEqual("$1:2", result); + } + + [TestMethod] + public void ReplaceRelative7() + { + var result = XLHelper.ReplaceRelative("1:$1", 2, "B"); + Assert.AreEqual("2:$1", result); + } + + [TestMethod] + public void ReplaceRelative8() + { + var result = XLHelper.ReplaceRelative("$1:$1", 2, "B"); + Assert.AreEqual("$1:$1", result); + } + + [TestMethod] + public void ReplaceRelative9() + { + var result = XLHelper.ReplaceRelative("A:A", 2, "B"); + Assert.AreEqual("B:B", result); + } + + [TestMethod] + public void ReplaceRelativeA() + { + var result = XLHelper.ReplaceRelative("$A:A", 2, "B"); + Assert.AreEqual("$A:B", result); + } + + [TestMethod] + public void ReplaceRelativeB() + { + var result = XLHelper.ReplaceRelative("A:$A", 2, "B"); + Assert.AreEqual("B:$A", result); + } + + [TestMethod] + public void ReplaceRelativeC() + { + var result = XLHelper.ReplaceRelative("$A:$A", 2, "B"); + Assert.AreEqual("$A:$A", result); + } + } +} \ No newline at end of file