diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/ClosedXML_Tests.csproj b/ClosedXML/ClosedXML/ClosedXML_Tests/ClosedXML_Tests.csproj
index 91b7b38..53e0a32 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/ClosedXML_Tests.csproj
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/ClosedXML_Tests.csproj
@@ -47,7 +47,9 @@
..\DocumentFormat.OpenXml.dll
-
+
+ ..\packages\NUnit.2.6.3\lib\nunit.framework.dll
+
@@ -238,6 +240,7 @@
+
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/AutoFilterTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/AutoFilterTests.cs
index da3c747..5541af7 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/AutoFilterTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/AutoFilterTests.cs
@@ -1,33 +1,33 @@
using ClosedXML_Examples;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Examples
{
- [TestClass]
+ [TestFixture]
public class AutoFilterTests
{
-
- [TestMethod]
- public void RegularAutoFilter()
- {
- TestHelper.RunTestExample(@"AutoFilter\RegularAutoFilter.xlsx");
- }
- [TestMethod]
+ [Test]
public void CustomAutoFilter()
{
TestHelper.RunTestExample(@"AutoFilter\CustomAutoFilter.xlsx");
}
- [TestMethod]
- public void TopBottomAutoFilter()
- {
- TestHelper.RunTestExample(@"AutoFilter\TopBottomAutoFilter.xlsx");
- }
-
- [TestMethod]
- public void DynamicAutoFilter()
+ [Test]
+ public void DynamicAutoFilter()
{
TestHelper.RunTestExample(@"AutoFilter\DynamicAutoFilter.xlsx");
}
+
+ [Test]
+ public void RegularAutoFilter()
+ {
+ TestHelper.RunTestExample(@"AutoFilter\RegularAutoFilter.xlsx");
+ }
+
+ [Test]
+ public void TopBottomAutoFilter()
+ {
+ TestHelper.RunTestExample(@"AutoFilter\TopBottomAutoFilter.xlsx");
+ }
}
}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/ColumnsTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/ColumnsTests.cs
index df5fe5f..c523d57 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/ColumnsTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/ColumnsTests.cs
@@ -1,32 +1,34 @@
using ClosedXML_Examples;
using ClosedXML_Examples.Columns;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Examples
{
- [TestClass]
+ [TestFixture]
public class ColumnsTests
{
- [TestMethod]
+ [Test]
public void ColumnCells()
{
TestHelper.RunTestExample(@"Columns\ColumnCells.xlsx");
}
- [TestMethod]
+
+ [Test]
public void ColumnCollections()
{
TestHelper.RunTestExample(@"Columns\ColumnCollection.xlsx");
}
- [TestMethod]
+
+ [Test]
public void ColumnSettings()
{
TestHelper.RunTestExample(@"Columns\ColumnSettings.xlsx");
}
- [TestMethod]
+
+ [Test]
public void DeletingColumns()
{
TestHelper.RunTestExample(@"Columns\DeletingColumns.xlsx");
}
-
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/CommentsTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/CommentsTests.cs
index 1531c87..b4cb1e9 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/CommentsTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/CommentsTests.cs
@@ -1,17 +1,15 @@
using ClosedXML_Examples;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Examples
{
- [TestClass]
+ [TestFixture]
public class CommentsTests
{
-
- [TestMethod]
- public void AddingComments()
- {
- TestHelper.RunTestExample(@"Comments\AddingComments.xlsx");
- }
-
+ [Test]
+ public void AddingComments()
+ {
+ TestHelper.RunTestExample(@"Comments\AddingComments.xlsx");
+ }
}
}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/ConditionalFormattingTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/ConditionalFormattingTests.cs
index 5e6585f..f5e9bcd 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/ConditionalFormattingTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/ConditionalFormattingTests.cs
@@ -1,127 +1,127 @@
using ClosedXML_Examples;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Examples
{
- [TestClass]
+ [TestFixture]
public class ConditionalFormattingTests
{
-
- [TestMethod]
- public void CFColorScaleLowMidHigh()
- {
- TestHelper.RunTestExample(@"ConditionalFormatting\CFColorScaleLowMidHigh.xlsx");
- }
-
- [TestMethod]
+ [Test]
public void CFColorScaleLowHigh()
{
TestHelper.RunTestExample(@"ConditionalFormatting\CFColorScaleLowHigh.xlsx");
}
- [TestMethod]
- public void CFStartsWith()
+ [Test]
+ public void CFColorScaleLowMidHigh()
{
- TestHelper.RunTestExample(@"ConditionalFormatting\CFStartsWith.xlsx");
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFColorScaleLowMidHigh.xlsx");
}
- [TestMethod]
- public void CFEndsWith()
- {
- TestHelper.RunTestExample(@"ConditionalFormatting\CFEndsWith.xlsx");
- }
-
- [TestMethod]
- public void CFIsBlank()
- {
- TestHelper.RunTestExample(@"ConditionalFormatting\CFIsBlank.xlsx");
- }
-
- [TestMethod]
- public void CFNotBlank()
- {
- TestHelper.RunTestExample(@"ConditionalFormatting\CFNotBlank.xlsx");
- }
-
- [TestMethod]
- public void CFIsError()
- {
- TestHelper.RunTestExample(@"ConditionalFormatting\CFIsError.xlsx");
- }
-
- [TestMethod]
- public void CFNotError()
- {
- TestHelper.RunTestExample(@"ConditionalFormatting\CFNotError.xlsx");
- }
-
- [TestMethod]
+ [Test]
public void CFContains()
{
TestHelper.RunTestExample(@"ConditionalFormatting\CFContains.xlsx");
}
- [TestMethod]
- public void CFNotContains()
- {
- TestHelper.RunTestExample(@"ConditionalFormatting\CFNotContains.xlsx");
- }
-
- [TestMethod]
- public void CFEqualsString()
- {
- TestHelper.RunTestExample(@"ConditionalFormatting\CFEqualsString.xlsx");
- }
-
- [TestMethod]
- public void CFEqualsNumber()
- {
- TestHelper.RunTestExample(@"ConditionalFormatting\CFEqualsNumber.xlsx");
- }
-
- [TestMethod]
- public void CFNotEqualsString()
- {
- TestHelper.RunTestExample(@"ConditionalFormatting\CFNotEqualsString.xlsx");
- }
-
- [TestMethod]
- public void CFNotEqualsNumber()
- {
- TestHelper.RunTestExample(@"ConditionalFormatting\CFNotEqualsNumber.xlsx");
- }
-
- [TestMethod]
+ [Test]
public void CFDataBar()
{
TestHelper.RunTestExample(@"ConditionalFormatting\CFDataBar.xlsx");
}
- [TestMethod]
+ [Test]
+ public void CFEndsWith()
+ {
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFEndsWith.xlsx");
+ }
+
+ [Test]
+ public void CFEqualsNumber()
+ {
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFEqualsNumber.xlsx");
+ }
+
+ [Test]
+ public void CFEqualsString()
+ {
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFEqualsString.xlsx");
+ }
+
+ [Test]
public void CFIconSet()
{
TestHelper.RunTestExample(@"ConditionalFormatting\CFIconSet.xlsx");
}
+
+ [Test]
+ public void CFIsBlank()
+ {
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFIsBlank.xlsx");
+ }
+
+ [Test]
+ public void CFIsError()
+ {
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFIsError.xlsx");
+ }
+
+ [Test]
+ public void CFNotBlank()
+ {
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFNotBlank.xlsx");
+ }
+
+ [Test]
+ public void CFNotContains()
+ {
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFNotContains.xlsx");
+ }
+
+ [Test]
+ public void CFNotEqualsNumber()
+ {
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFNotEqualsNumber.xlsx");
+ }
+
+ [Test]
+ public void CFNotEqualsString()
+ {
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFNotEqualsString.xlsx");
+ }
+
+ [Test]
+ public void CFNotError()
+ {
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFNotError.xlsx");
+ }
+
+ [Test]
+ public void CFStartsWith()
+ {
+ TestHelper.RunTestExample(@"ConditionalFormatting\CFStartsWith.xlsx");
+ }
+
//
- //[TestMethod]
+ //[Test]
//public void XXX()
//{
// TestHelper.RunTestExample(@"ConditionalFormatting\XXX.xlsx");
//}
//
- //[TestMethod]
+ //[Test]
//public void XXX()
//{
// TestHelper.RunTestExample(@"ConditionalFormatting\XXX.xlsx");
//}
//
- //[TestMethod]
+ //[Test]
//public void XXX()
//{
// TestHelper.RunTestExample(@"ConditionalFormatting\XXX.xlsx");
//}
//
- //[TestMethod]
+ //[Test]
//public void XXX()
//{
// TestHelper.RunTestExample(@"ConditionalFormatting\XXX.xlsx");
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/DeleteTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/DeleteTests.cs
index 55e3424..b6e56ee 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/DeleteTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/DeleteTests.cs
@@ -1,22 +1,21 @@
using ClosedXML_Examples.Delete;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Examples
{
- [TestClass]
+ [TestFixture]
public class DeleteTests
{
- [TestMethod]
- public void RemoveRows()
- {
- TestHelper.RunTestExample(@"Delete\RemoveRows.xlsx");
- }
-
- [TestMethod]
+ [Test]
public void DeleteFewWorksheets()
{
TestHelper.RunTestExample(@"Delete\DeleteFewWorksheets.xlsx");
}
+ [Test]
+ public void RemoveRows()
+ {
+ TestHelper.RunTestExample(@"Delete\RemoveRows.xlsx");
+ }
}
}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/LoadingTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/LoadingTests.cs
index 7a20166..2391d19 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/LoadingTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/LoadingTests.cs
@@ -1,16 +1,15 @@
using ClosedXML_Examples;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Examples
{
- [TestClass]
+ [TestFixture]
public class LoadingTests
{
- [TestMethod]
+ [Test]
public void ChangingBasicTable()
{
TestHelper.RunTestExample(@"Loading\ChangingBasicTable.xlsx");
}
-
}
}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/MiscTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/MiscTests.cs
index cd6283a..2433aab 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/MiscTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/MiscTests.cs
@@ -1,151 +1,178 @@
using ClosedXML_Examples;
using ClosedXML_Examples.Misc;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Examples
{
- [TestClass]
+ [TestFixture]
public class MiscTests
{
- [TestMethod]
+ [Test]
public void AddingDataSet()
{
TestHelper.RunTestExample(@"Misc\AddingDataSet.xlsx");
}
- [TestMethod]
+
+ [Test]
public void AddingDataTableAsWorksheet()
{
TestHelper.RunTestExample(@"Misc\AddingDataTableAsWorksheet.xlsx");
}
- [TestMethod]
+
+ [Test]
public void AdjustToContents()
{
TestHelper.RunTestExample(@"Misc\AdjustToContents.xlsx");
}
- [TestMethod]
+
+ [Test]
public void AutoFilter()
{
TestHelper.RunTestExample(@"Misc\AutoFilter.xlsx");
}
- [TestMethod]
+
+ [Test]
+ public void BasicTable()
+ {
+ TestHelper.RunTestExample(@"Misc\BasicTable.xlsx");
+ }
+
+ [Test]
public void BlankCells()
{
TestHelper.RunTestExample(@"Misc\BlankCells.xlsx");
}
- [TestMethod]
+
+ [Test]
public void CellValues()
{
TestHelper.RunTestExample(@"Misc\CellValues.xlsx");
}
- [TestMethod]
+
+ [Test]
public void Collections()
{
TestHelper.RunTestExample(@"Misc\Collections.xlsx");
}
- [TestMethod]
- public void CopyingWorksheets()
- {
- TestHelper.RunTestExample(@"Misc\CopyingWorksheets.xlsx");
- }
- [TestMethod]
- public void DataTypes()
- {
- TestHelper.RunTestExample(@"Misc\DataTypes.xlsx");
- }
- [TestMethod]
- public void DataValidation()
- {
- TestHelper.RunTestExample(@"Misc\DataValidation.xlsx");
- }
- [TestMethod]
- public void Formulas()
- {
- TestHelper.RunTestExample(@"Misc\Formulas.xlsx");
- }
- [TestMethod]
- public void FreezePanes()
- {
- TestHelper.RunTestExample(@"Misc\FreezePanes.xlsx");
- }
- [TestMethod]
- public void HideSheets()
- {
- TestHelper.RunTestExample(@"Misc\HideSheets.xlsx");
- }
- [TestMethod]
- public void HideUnhide()
- {
- TestHelper.RunTestExample(@"Misc\HideUnhide.xlsx");
- }
- [TestMethod]
- public void Hyperlinks()
- {
- TestHelper.RunTestExample(@"Misc\Hyperlinks.xlsx");
- }
- [TestMethod]
- public void InsertingData()
- {
- TestHelper.RunTestExample(@"Misc\InsertingData.xlsx");
- }
- [TestMethod]
- public void InsertingTables()
- {
- TestHelper.RunTestExample(@"Misc\InsertingTables.xlsx");
- }
- [TestMethod]
- public void LambdaExpressions()
- {
- TestHelper.RunTestExample(@"Misc\LambdaExpressions.xlsx");
- }
- [TestMethod]
- public void MergeCells()
- {
- TestHelper.RunTestExample(@"Misc\MergeCells.xlsx");
- }
- [TestMethod]
- public void MergeMoves()
- {
- TestHelper.RunTestExample(@"Misc\MergeMoves.xlsx");
- }
- [TestMethod]
- public void Outline()
- {
- TestHelper.RunTestExample(@"Misc\Outline.xlsx");
- }
- [TestMethod]
- public void SheetProtection()
- {
- TestHelper.RunTestExample(@"Misc\SheetProtection.xlsx");
- }
- [TestMethod]
- public void ShiftingFormulas()
- {
- TestHelper.RunTestExample(@"Misc\ShiftingFormulas.xlsx");
- }
- [TestMethod]
- public void ShowCase()
- {
- TestHelper.RunTestExample(@"Misc\ShowCase.xlsx");
- }
- [TestMethod]
- public void TabColors()
- {
- TestHelper.RunTestExample(@"Misc\TabColors.xlsx");
- }
- [TestMethod]
- public void WorkbookProperties()
- {
- TestHelper.RunTestExample(@"Misc\WorkbookProperties.xlsx");
- }
- [TestMethod]
+
+ [Test]
public void CopyingRowsAndColumns()
{
TestHelper.RunTestExample(@"Misc\CopyingRowsAndColumns.xlsx");
}
- [TestMethod]
- public void BasicTable()
+
+ [Test]
+ public void CopyingWorksheets()
{
- TestHelper.RunTestExample(@"Misc\BasicTable.xlsx");
+ TestHelper.RunTestExample(@"Misc\CopyingWorksheets.xlsx");
+ }
+
+ [Test]
+ public void DataTypes()
+ {
+ TestHelper.RunTestExample(@"Misc\DataTypes.xlsx");
+ }
+
+ [Test]
+ public void DataValidation()
+ {
+ TestHelper.RunTestExample(@"Misc\DataValidation.xlsx");
+ }
+
+ [Test]
+ public void Formulas()
+ {
+ TestHelper.RunTestExample(@"Misc\Formulas.xlsx");
+ }
+
+ [Test]
+ public void FreezePanes()
+ {
+ TestHelper.RunTestExample(@"Misc\FreezePanes.xlsx");
+ }
+
+ [Test]
+ public void HideSheets()
+ {
+ TestHelper.RunTestExample(@"Misc\HideSheets.xlsx");
+ }
+
+ [Test]
+ public void HideUnhide()
+ {
+ TestHelper.RunTestExample(@"Misc\HideUnhide.xlsx");
+ }
+
+ [Test]
+ public void Hyperlinks()
+ {
+ TestHelper.RunTestExample(@"Misc\Hyperlinks.xlsx");
+ }
+
+ [Test]
+ public void InsertingData()
+ {
+ TestHelper.RunTestExample(@"Misc\InsertingData.xlsx");
+ }
+
+ [Test]
+ public void InsertingTables()
+ {
+ TestHelper.RunTestExample(@"Misc\InsertingTables.xlsx");
+ }
+
+ [Test]
+ public void LambdaExpressions()
+ {
+ TestHelper.RunTestExample(@"Misc\LambdaExpressions.xlsx");
+ }
+
+ [Test]
+ public void MergeCells()
+ {
+ TestHelper.RunTestExample(@"Misc\MergeCells.xlsx");
+ }
+
+ [Test]
+ public void MergeMoves()
+ {
+ TestHelper.RunTestExample(@"Misc\MergeMoves.xlsx");
+ }
+
+ [Test]
+ public void Outline()
+ {
+ TestHelper.RunTestExample(@"Misc\Outline.xlsx");
+ }
+
+ [Test]
+ public void SheetProtection()
+ {
+ TestHelper.RunTestExample(@"Misc\SheetProtection.xlsx");
+ }
+
+ [Test]
+ public void ShiftingFormulas()
+ {
+ TestHelper.RunTestExample(@"Misc\ShiftingFormulas.xlsx");
+ }
+
+ [Test]
+ public void ShowCase()
+ {
+ TestHelper.RunTestExample(@"Misc\ShowCase.xlsx");
+ }
+
+ [Test]
+ public void TabColors()
+ {
+ TestHelper.RunTestExample(@"Misc\TabColors.xlsx");
+ }
+
+ [Test]
+ public void WorkbookProperties()
+ {
+ TestHelper.RunTestExample(@"Misc\WorkbookProperties.xlsx");
}
}
}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/PageSetupTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/PageSetupTests.cs
index 584c8f0..588ef50 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/PageSetupTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/PageSetupTests.cs
@@ -1,41 +1,45 @@
using ClosedXML_Examples.PageSetup;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Examples
{
- [TestClass]
+ [TestFixture]
public class PageSetupTests
{
- [TestMethod]
+ [Test]
public void HeaderFooters()
{
TestHelper.RunTestExample(@"PageSetup\HeaderFooters.xlsx");
}
- [TestMethod]
+
+ [Test]
public void Margins()
{
TestHelper.RunTestExample(@"PageSetup\Margins.xlsx");
}
- [TestMethod]
+
+ [Test]
public void Page()
{
TestHelper.RunTestExample(@"PageSetup\Page.xlsx");
}
- [TestMethod]
- public void Sheets()
- {
- TestHelper.RunTestExample(@"PageSetup\Sheets.xlsx");
- }
- [TestMethod]
+
+ [Test]
public void SheetTab()
{
TestHelper.RunTestExample(@"PageSetup\SheetTab.xlsx");
}
- [TestMethod]
+
+ [Test]
+ public void Sheets()
+ {
+ TestHelper.RunTestExample(@"PageSetup\Sheets.xlsx");
+ }
+
+ [Test]
public void TwoPages()
{
TestHelper.RunTestExample(@"PageSetup\TwoPages.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
index 2569679..07dae9f 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RangesTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RangesTests.cs
@@ -1,98 +1,113 @@
using ClosedXML_Examples;
using ClosedXML_Examples.Misc;
using ClosedXML_Examples.Ranges;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Examples
{
- [TestClass]
+ [TestFixture]
public class RangesTests
{
- [TestMethod]
+ [Test]
public void ClearingRanges()
{
TestHelper.RunTestExample(@"Ranges\ClearingRanges.xlsx");
}
- [TestMethod]
+
+ [Test]
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]
+
+ [Test]
public void CurrentRowColumn()
{
TestHelper.RunTestExample(@"Ranges\CurrentRowColumn.xlsx");
}
- [TestMethod]
+ [Test]
+ public void DefiningRanges()
+ {
+ TestHelper.RunTestExample(@"Ranges\DefiningRanges.xlsx");
+ }
+
+ [Test]
+ public void DeletingRanges()
+ {
+ TestHelper.RunTestExample(@"Ranges\DeletingRanges.xlsx");
+ }
+
+ [Test]
+ public void InsertingDeletingColumns()
+ {
+ TestHelper.RunTestExample(@"Ranges\InsertingDeletingColumns.xlsx");
+ }
+
+ [Test]
+ public void InsertingDeletingRows()
+ {
+ TestHelper.RunTestExample(@"Ranges\InsertingDeletingRows.xlsx");
+ }
+
+ [Test]
+ public void MultipleRanges()
+ {
+ TestHelper.RunTestExample(@"Ranges\MultipleRanges.xlsx");
+ }
+
+ [Test]
+ public void NamedRanges()
+ {
+ TestHelper.RunTestExample(@"Ranges\NamedRanges.xlsx");
+ }
+
+ [Test]
public void SelectingRanges()
{
TestHelper.RunTestExample(@"Ranges\SelectingRanges.xlsx");
}
+
+ [Test]
+ public void ShiftingRanges()
+ {
+ TestHelper.RunTestExample(@"Ranges\ShiftingRanges.xlsx");
+ }
+
+ [Test]
+ public void SortExample()
+ {
+ TestHelper.RunTestExample(@"Ranges\SortExample.xlsx");
+ }
+
+ [Test]
+ public void Sorting()
+ {
+ TestHelper.RunTestExample(@"Ranges\Sorting.xlsx");
+ }
+
+ [Test]
+ public void TransposeRanges()
+ {
+ TestHelper.RunTestExample(@"Ranges\TransposeRanges.xlsx");
+ }
+
+ [Test]
+ public void TransposeRangesPlus()
+ {
+ TestHelper.RunTestExample(@"Ranges\TransposeRangesPlus.xlsx");
+ }
+
+ [Test]
+ public void UsingTables()
+ {
+ TestHelper.RunTestExample(@"Ranges\UsingTables.xlsx");
+ }
+
+ [Test]
+ public void WalkingRanges()
+ {
+ TestHelper.RunTestExample(@"Ranges\WalkingRanges.xlsx");
+ }
}
}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RowsTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RowsTests.cs
index fd7fa76..917a985 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RowsTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/RowsTests.cs
@@ -1,27 +1,28 @@
using ClosedXML_Examples;
using ClosedXML_Examples.Rows;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Examples
{
- [TestClass]
+ [TestFixture]
public class RowsTests
{
- [TestMethod]
+ [Test]
public void RowCells()
{
TestHelper.RunTestExample(@"Rows\RowCells.xlsx");
}
- [TestMethod]
+
+ [Test]
public void RowCollection()
{
TestHelper.RunTestExample(@"Rows\RowCollection.xlsx");
}
- [TestMethod]
+
+ [Test]
public void RowSettings()
{
TestHelper.RunTestExample(@"Rows\RowSettings.xlsx");
}
-
}
}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/StylesTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/StylesTests.cs
index 27bf012..77e0bf4 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/StylesTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Examples/StylesTests.cs
@@ -1,68 +1,75 @@
using ClosedXML_Examples.Styles;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Examples
{
- [TestClass]
+ [TestFixture]
public class StylesTests
{
- [TestMethod]
+ [Test]
public void DefaultStyles()
{
TestHelper.RunTestExample(@"Styles\DefaultStyles.xlsx");
}
- [TestMethod]
+
+ [Test]
+ public void PurpleWorksheet()
+ {
+ TestHelper.RunTestExample(@"Styles\PurpleWorksheet.xlsx");
+ }
+
+ [Test]
public void StyleAlignment()
{
TestHelper.RunTestExample(@"Styles\StyleAlignment.xlsx");
}
- [TestMethod]
+
+ [Test]
public void StyleBorder()
{
TestHelper.RunTestExample(@"Styles\StyleBorder.xlsx");
}
- [TestMethod]
+
+ [Test]
public void StyleFill()
{
TestHelper.RunTestExample(@"Styles\StyleFill.xlsx");
}
- [TestMethod]
+
+ [Test]
public void StyleFont()
{
TestHelper.RunTestExample(@"Styles\StyleFont.xlsx");
}
- [TestMethod]
+
+ [Test]
public void StyleNumberFormat()
{
TestHelper.RunTestExample(@"Styles\StyleNumberFormat.xlsx");
}
- [TestMethod]
+
+ [Test]
public void StyleRowsColumns()
{
TestHelper.RunTestExample(@"Styles\StyleRowsColumns.xlsx");
}
- [TestMethod]
+
+ [Test]
public void StyleWorksheet()
{
TestHelper.RunTestExample(@"Styles\StyleWorksheet.xlsx");
}
-
- [TestMethod]
+
+ [Test]
+ public void UsingColors()
+ {
+ TestHelper.RunTestExample(@"Styles\UsingColors.xlsx");
+ }
+
+ [Test]
public void UsingRichText()
{
TestHelper.RunTestExample(@"Styles\UsingRichText.xlsx");
}
-
- [TestMethod]
- public void PurpleWorksheet()
- {
- TestHelper.RunTestExample(@"Styles\PurpleWorksheet.xlsx");
- }
-
- [TestMethod]
- public void UsingColors()
- {
- TestHelper.RunTestExample(@"Styles\UsingColors.xlsx");
- }
}
}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/AutoFilters/AutoFilterTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/AutoFilters/AutoFilterTests.cs
index 8353b2c..c4e3e7d 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/AutoFilters/AutoFilterTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/AutoFilters/AutoFilterTests.cs
@@ -1,46 +1,26 @@
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
using System.Linq;
-using System;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- using System.Collections.Generic;
-
- [TestClass]
+ [TestFixture]
public class AutoFilterTests
{
- [TestMethod]
- public void AutoFilterSortWhenNotInFirstRow()
- {
- using (var wb = new XLWorkbook())
- {
- using (var ws = wb.Worksheets.Add("Sheet1"))
- {
- ws.Cell(3, 3).SetValue("Names")
- .CellBelow().SetValue("Manuel")
- .CellBelow().SetValue("Carlos")
- .CellBelow().SetValue("Dominic");
- ws.RangeUsed().SetAutoFilter().Sort();
- Assert.AreEqual(ws.Cell(4, 3).GetString(), "Carlos");
- }
-
- }
-
- }
-
- [TestMethod]
+ [Test]
public void AutoFilterExpandsWithTable()
{
using (var wb = new XLWorkbook())
{
- using (var ws = wb.Worksheets.Add("Sheet1"))
+ using (IXLWorksheet ws = wb.Worksheets.Add("Sheet1"))
{
ws.FirstCell().SetValue("Categories")
- .CellBelow().SetValue("1")
- .CellBelow().SetValue("2");
+ .CellBelow().SetValue("1")
+ .CellBelow().SetValue("2");
- var table = ws.RangeUsed().CreateTable();
+ IXLTable table = ws.RangeUsed().CreateTable();
var listOfArr = new List();
listOfArr.Add(3);
@@ -53,9 +33,24 @@
Assert.AreEqual("A1:A5", table.AutoFilter.Range.RangeAddress.ToStringRelative());
}
-
}
-
+ }
+
+ [Test]
+ public void AutoFilterSortWhenNotInFirstRow()
+ {
+ using (var wb = new XLWorkbook())
+ {
+ using (IXLWorksheet ws = wb.Worksheets.Add("Sheet1"))
+ {
+ ws.Cell(3, 3).SetValue("Names")
+ .CellBelow().SetValue("Manuel")
+ .CellBelow().SetValue("Carlos")
+ .CellBelow().SetValue("Dominic");
+ ws.RangeUsed().SetAutoFilter().Sort();
+ Assert.AreEqual(ws.Cell(4, 3).GetString(), "Carlos");
+ }
+ }
}
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/DateAndTimeTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/DateAndTimeTests.cs
index 0c4645f..a5c20dc 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/DateAndTimeTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/DateAndTimeTests.cs
@@ -1,199 +1,139 @@
using System;
-using System.IO;
-using System.Text;
-using System.Collections.Generic;
-using System.Linq;
using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel.DataValidations
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class DateAndTimeTests
{
- [TestMethod]
+ [Test]
public void Date()
{
Object actual = XLWorkbook.EvaluateExpr("Date(2008, 1, 1)");
Assert.AreEqual(39448, actual);
}
- [TestMethod]
+ [Test]
public void Datevalue()
{
Object actual = XLWorkbook.EvaluateExpr("DateValue(\"8/22/2008\")");
Assert.AreEqual(39682, actual);
}
- [TestMethod]
+ [Test]
public void Day()
{
Object actual = XLWorkbook.EvaluateExpr("Day(\"8/22/2008\")");
Assert.AreEqual(22, actual);
}
- [TestMethod]
- public void Month()
- {
- Object actual = XLWorkbook.EvaluateExpr("Month(\"8/22/2008\")");
- Assert.AreEqual(8, actual);
- }
-
- [TestMethod]
- public void Year()
- {
- Object actual = XLWorkbook.EvaluateExpr("Year(\"8/22/2008\")");
- Assert.AreEqual(2008, actual);
- }
-
- [TestMethod]
- public void Second()
- {
- Object actual = XLWorkbook.EvaluateExpr("Second(\"8/22/2008 3:30:45 AM\")");
- Assert.AreEqual(45, actual);
- }
-
- [TestMethod]
- public void Minute()
- {
- Object actual = XLWorkbook.EvaluateExpr("Minute(\"8/22/2008 3:30:45 AM\")");
- Assert.AreEqual(30, actual);
- }
-
- [TestMethod]
- public void Hour()
- {
- Object actual = XLWorkbook.EvaluateExpr("Hour(\"8/22/2008 3:30:45 PM\")");
- Assert.AreEqual(15, actual);
- }
-
- [TestMethod]
- public void Time()
- {
- Object actual = XLWorkbook.EvaluateExpr("Time(1,2,3)");
- Assert.AreEqual(new TimeSpan(1, 2, 3), actual);
- }
-
- [TestMethod]
- public void TimeValue1()
- {
- Object actual = XLWorkbook.EvaluateExpr("TimeValue(\"2:24 AM\")");
- Assert.IsTrue(XLHelper.AreEqual(0.1, (double)actual));
- }
-
- [TestMethod]
- public void TimeValue2()
- {
- Object actual = XLWorkbook.EvaluateExpr("TimeValue(\"22-Aug-2008 6:35 AM\")");
- Assert.IsTrue(XLHelper.AreEqual(0.27430555555555558, (double)actual));
- }
-
- [TestMethod]
- public void Today()
- {
- Object actual = XLWorkbook.EvaluateExpr("Today()");
- Assert.AreEqual(DateTime.Now.Date, actual);
- }
-
- [TestMethod]
+ [Test]
public void Days360_Default()
{
Object actual = XLWorkbook.EvaluateExpr("Days360(\"1/30/2008\", \"2/1/2008\")");
Assert.AreEqual(1, actual);
}
- [TestMethod]
- public void Days360_US1()
- {
- Object actual = XLWorkbook.EvaluateExpr("DAYS360(\"1/1/2008\", \"3/31/2008\",FALSE)");
- Assert.AreEqual(90, actual);
- }
-
- [TestMethod]
- public void Days360_US2()
- {
- Object actual = XLWorkbook.EvaluateExpr("DAYS360(\"3/31/2008\", \"1/1/2008\",FALSE)");
- Assert.AreEqual(-89, actual);
- }
-
- [TestMethod]
+ [Test]
public void Days360_Europe1()
{
Object actual = XLWorkbook.EvaluateExpr("DAYS360(\"1/1/2008\", \"3/31/2008\",TRUE)");
Assert.AreEqual(89, actual);
}
- [TestMethod]
+ [Test]
public void Days360_Europe2()
{
Object actual = XLWorkbook.EvaluateExpr("DAYS360(\"3/31/2008\", \"1/1/2008\",TRUE)");
Assert.AreEqual(-89, actual);
}
- [TestMethod]
- public void EDate_Positive1()
+ [Test]
+ public void Days360_US1()
{
- Object actual = XLWorkbook.EvaluateExpr("EDate(\"3/1/2008\", 1)");
- Assert.AreEqual(new DateTime(2008, 4, 1), actual);
+ Object actual = XLWorkbook.EvaluateExpr("DAYS360(\"1/1/2008\", \"3/31/2008\",FALSE)");
+ Assert.AreEqual(90, actual);
}
- [TestMethod]
- public void EDate_Positive2()
+ [Test]
+ public void Days360_US2()
{
- Object actual = XLWorkbook.EvaluateExpr("EDate(\"3/31/2008\", 1)");
- Assert.AreEqual(new DateTime(2008, 4, 30), actual);
+ Object actual = XLWorkbook.EvaluateExpr("DAYS360(\"3/31/2008\", \"1/1/2008\",FALSE)");
+ Assert.AreEqual(-89, actual);
}
- [TestMethod]
+ [Test]
public void EDate_Negative1()
{
Object actual = XLWorkbook.EvaluateExpr("EDate(\"3/1/2008\", -1)");
Assert.AreEqual(new DateTime(2008, 2, 1), actual);
}
- [TestMethod]
+ [Test]
public void EDate_Negative2()
{
Object actual = XLWorkbook.EvaluateExpr("EDate(\"3/31/2008\", -1)");
Assert.AreEqual(new DateTime(2008, 2, 29), actual);
}
- [TestMethod]
- public void EOMonth_Positive()
+ [Test]
+ public void EDate_Positive1()
{
- Object actual = XLWorkbook.EvaluateExpr("EOMonth(\"3/31/2008\", 1)");
+ Object actual = XLWorkbook.EvaluateExpr("EDate(\"3/1/2008\", 1)");
+ Assert.AreEqual(new DateTime(2008, 4, 1), actual);
+ }
+
+ [Test]
+ public void EDate_Positive2()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("EDate(\"3/31/2008\", 1)");
Assert.AreEqual(new DateTime(2008, 4, 30), actual);
}
- [TestMethod]
+ [Test]
public void EOMonth_Negative()
{
Object actual = XLWorkbook.EvaluateExpr("EOMonth(\"3/1/2008\", -1)");
Assert.AreEqual(new DateTime(2008, 2, 29), actual);
}
- [TestMethod]
- public void Networkdays_NoHolidaysGiven()
+ [Test]
+ public void EOMonth_Positive()
{
- Object actual = XLWorkbook.EvaluateExpr("Networkdays(\"10/01/2008\", \"3/01/2009\")");
- Assert.AreEqual(108, actual);
+ Object actual = XLWorkbook.EvaluateExpr("EOMonth(\"3/31/2008\", 1)");
+ Assert.AreEqual(new DateTime(2008, 4, 30), actual);
}
- [TestMethod]
- public void Networkdays_OneHolidaysGiven()
+ [Test]
+ public void Hour()
{
- Object actual = XLWorkbook.EvaluateExpr("Networkdays(\"10/01/2008\", \"3/01/2009\", \"11/26/2008\")");
- Assert.AreEqual(107, actual);
+ Object actual = XLWorkbook.EvaluateExpr("Hour(\"8/22/2008 3:30:45 PM\")");
+ Assert.AreEqual(15, actual);
}
- [TestMethod]
+ [Test]
+ public void Minute()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("Minute(\"8/22/2008 3:30:45 AM\")");
+ Assert.AreEqual(30, actual);
+ }
+
+ [Test]
+ public void Month()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("Month(\"8/22/2008\")");
+ Assert.AreEqual(8, actual);
+ }
+
+ [Test]
public void Networkdays_MultipleHolidaysGiven()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
ws.FirstCell().SetValue("Date")
.CellBelow().SetValue(new DateTime(2008, 10, 1))
.CellBelow().SetValue(new DateTime(2009, 3, 1))
@@ -204,102 +144,215 @@
Assert.AreEqual(105, actual);
}
- [TestMethod]
- public void Weekday_Omitted()
+ [Test]
+ public void Networkdays_NoHolidaysGiven()
{
- Object actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\")");
- Assert.AreEqual(5, actual);
+ Object actual = XLWorkbook.EvaluateExpr("Networkdays(\"10/01/2008\", \"3/01/2009\")");
+ Assert.AreEqual(108, actual);
}
- [TestMethod]
+ [Test]
+ public void Networkdays_OneHolidaysGiven()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("Networkdays(\"10/01/2008\", \"3/01/2009\", \"11/26/2008\")");
+ Assert.AreEqual(107, actual);
+ }
+
+ [Test]
+ public void Second()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("Second(\"8/22/2008 3:30:45 AM\")");
+ Assert.AreEqual(45, actual);
+ }
+
+ [Test]
+ public void Time()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("Time(1,2,3)");
+ Assert.AreEqual(new TimeSpan(1, 2, 3), actual);
+ }
+
+ [Test]
+ public void TimeValue1()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("TimeValue(\"2:24 AM\")");
+ Assert.IsTrue(XLHelper.AreEqual(0.1, (double) actual));
+ }
+
+ [Test]
+ public void TimeValue2()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("TimeValue(\"22-Aug-2008 6:35 AM\")");
+ Assert.IsTrue(XLHelper.AreEqual(0.27430555555555558, (double) actual));
+ }
+
+ [Test]
+ public void Today()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("Today()");
+ Assert.AreEqual(DateTime.Now.Date, actual);
+ }
+
+ [Test]
public void Weekday_1()
{
Object actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\", 1)");
Assert.AreEqual(5, actual);
}
- [TestMethod]
+ [Test]
public void Weekday_2()
{
Object actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\", 2)");
Assert.AreEqual(4, actual);
}
- [TestMethod]
+ [Test]
public void Weekday_3()
{
Object actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\", 3)");
Assert.AreEqual(3, actual);
}
- [TestMethod]
+ [Test]
+ public void Weekday_Omitted()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("Weekday(\"2/14/2008\")");
+ Assert.AreEqual(5, actual);
+ }
+
+ [Test]
+ public void Weeknum_1()
+ {
+ Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2000\", 1)"));
+ }
+
+ [Test]
+ public void Weeknum_10()
+ {
+ Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2004\", 2)"));
+ }
+
+ [Test]
+ public void Weeknum_11()
+ {
+ Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2005\", 1)"));
+ }
+
+ [Test]
+ public void Weeknum_12()
+ {
+ Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2005\", 2)"));
+ }
+
+ [Test]
+ public void Weeknum_13()
+ {
+ Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2006\", 1)"));
+ }
+
+ [Test]
+ public void Weeknum_14()
+ {
+ Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2006\", 2)"));
+ }
+
+ [Test]
+ public void Weeknum_15()
+ {
+ Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2007\", 1)"));
+ }
+
+ [Test]
+ public void Weeknum_16()
+ {
+ Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2007\", 2)"));
+ }
+
+ [Test]
+ public void Weeknum_17()
+ {
+ Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2008\", 1)"));
+ }
+
+ [Test]
+ public void Weeknum_18()
+ {
+ Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2008\", 2)"));
+ }
+
+ [Test]
+ public void Weeknum_19()
+ {
+ Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2009\", 1)"));
+ }
+
+ [Test]
+ public void Weeknum_2()
+ {
+ Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2000\", 2)"));
+ }
+
+ [Test]
+ public void Weeknum_20()
+ {
+ Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2009\", 2)"));
+ }
+
+ [Test]
+ public void Weeknum_3()
+ {
+ Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2001\", 1)"));
+ }
+
+ [Test]
+ public void Weeknum_4()
+ {
+ Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2001\", 2)"));
+ }
+
+ [Test]
+ public void Weeknum_5()
+ {
+ Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2002\", 1)"));
+ }
+
+ [Test]
+ public void Weeknum_6()
+ {
+ Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2002\", 2)"));
+ }
+
+ [Test]
+ public void Weeknum_7()
+ {
+ Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2003\", 1)"));
+ }
+
+ [Test]
+ public void Weeknum_8()
+ {
+ Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2003\", 2)"));
+ }
+
+ [Test]
+ public void Weeknum_9()
+ {
+ Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2004\", 1)"));
+ }
+
+ [Test]
public void Weeknum_Default()
{
Object actual = XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2008\")");
Assert.AreEqual(11, actual);
}
- [TestMethod]
- public void Weeknum_1() { Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2000\", 1)")); }
- [TestMethod]
- public void Weeknum_2() { Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2000\", 2)")); }
- [TestMethod]
- public void Weeknum_3() { Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2001\", 1)")); }
- [TestMethod]
- public void Weeknum_4() { Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2001\", 2)")); }
- [TestMethod]
- public void Weeknum_5() { Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2002\", 1)")); }
- [TestMethod]
- public void Weeknum_6() { Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2002\", 2)")); }
- [TestMethod]
- public void Weeknum_7() { Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2003\", 1)")); }
- [TestMethod]
- public void Weeknum_8() { Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2003\", 2)")); }
- [TestMethod]
- public void Weeknum_9() { Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2004\", 1)")); }
- [TestMethod]
- public void Weeknum_10() { Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2004\", 2)")); }
- [TestMethod]
- public void Weeknum_11() { Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2005\", 1)")); }
- [TestMethod]
- public void Weeknum_12() { Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2005\", 2)")); }
- [TestMethod]
- public void Weeknum_13() { Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2006\", 1)")); }
- [TestMethod]
- public void Weeknum_14() { Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2006\", 2)")); }
- [TestMethod]
- public void Weeknum_15() { Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2007\", 1)")); }
- [TestMethod]
- public void Weeknum_16() { Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2007\", 2)")); }
- [TestMethod]
- public void Weeknum_17() { Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2008\", 1)")); }
- [TestMethod]
- public void Weeknum_18() { Assert.AreEqual(10, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2008\", 2)")); }
- [TestMethod]
- public void Weeknum_19() { Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2009\", 1)")); }
- [TestMethod]
- public void Weeknum_20() { Assert.AreEqual(11, XLWorkbook.EvaluateExpr("Weeknum(\"3/9/2009\", 2)")); }
-
-
- [TestMethod]
- public void Workdays_NoHolidaysGiven()
- {
- Object actual = XLWorkbook.EvaluateExpr("Workday(\"10/01/2008\", 151)");
- Assert.AreEqual(new DateTime(2009, 4,30), actual);
- }
-
- [TestMethod]
- public void Workdays_OneHolidaysGiven()
- {
- Object actual = XLWorkbook.EvaluateExpr("Workday(\"10/01/2008\", 152, \"11/26/2008\")");
- Assert.AreEqual(new DateTime(2009, 5, 4), actual);
- }
-
- [TestMethod]
+ [Test]
public void Workdays_MultipleHolidaysGiven()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
ws.FirstCell().SetValue("Date")
.CellBelow().SetValue(new DateTime(2008, 10, 1))
.CellBelow().SetValue(151)
@@ -310,74 +363,96 @@
Assert.AreEqual(new DateTime(2009, 5, 5), actual);
}
- [TestMethod]
+
+ [Test]
+ public void Workdays_NoHolidaysGiven()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("Workday(\"10/01/2008\", 151)");
+ Assert.AreEqual(new DateTime(2009, 4, 30), actual);
+ }
+
+ [Test]
+ public void Workdays_OneHolidaysGiven()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("Workday(\"10/01/2008\", 152, \"11/26/2008\")");
+ Assert.AreEqual(new DateTime(2009, 5, 4), actual);
+ }
+
+ [Test]
+ public void Year()
+ {
+ Object actual = XLWorkbook.EvaluateExpr("Year(\"8/22/2008\")");
+ Assert.AreEqual(2008, actual);
+ }
+
+ [Test]
public void Yearfrac_1_base0()
{
Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",0)");
- Assert.IsTrue(XLHelper.AreEqual(0.25, (double)actual));
+ Assert.IsTrue(XLHelper.AreEqual(0.25, (double) actual));
}
- [TestMethod]
+ [Test]
public void Yearfrac_1_base1()
{
Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",1)");
- Assert.IsTrue(XLHelper.AreEqual(0.24590163934426229, (double)actual));
+ Assert.IsTrue(XLHelper.AreEqual(0.24590163934426229, (double) actual));
}
- [TestMethod]
+ [Test]
public void Yearfrac_1_base2()
{
Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",2)");
- Assert.IsTrue(XLHelper.AreEqual(0.25, (double)actual));
+ Assert.IsTrue(XLHelper.AreEqual(0.25, (double) actual));
}
- [TestMethod]
+ [Test]
public void Yearfrac_1_base3()
{
Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",3)");
- Assert.IsTrue(XLHelper.AreEqual(0.24657534246575341, (double)actual));
+ Assert.IsTrue(XLHelper.AreEqual(0.24657534246575341, (double) actual));
}
- [TestMethod]
+ [Test]
public void Yearfrac_1_base4()
{
Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2008\",4)");
- Assert.IsTrue(XLHelper.AreEqual(0.24722222222222223, (double)actual));
+ Assert.IsTrue(XLHelper.AreEqual(0.24722222222222223, (double) actual));
}
- [TestMethod]
+ [Test]
public void Yearfrac_2_base0()
{
Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",0)");
- Assert.IsTrue(XLHelper.AreEqual(5.25, (double)actual));
+ Assert.IsTrue(XLHelper.AreEqual(5.25, (double) actual));
}
- [TestMethod]
+ [Test]
public void Yearfrac_2_base1()
{
Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",1)");
- Assert.IsTrue(XLHelper.AreEqual(5.24452554744526, (double)actual));
+ Assert.IsTrue(XLHelper.AreEqual(5.24452554744526, (double) actual));
}
- [TestMethod]
+ [Test]
public void Yearfrac_2_base2()
{
Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",2)");
- Assert.IsTrue(XLHelper.AreEqual(5.32222222222222, (double)actual));
+ Assert.IsTrue(XLHelper.AreEqual(5.32222222222222, (double) actual));
}
- [TestMethod]
+ [Test]
public void Yearfrac_2_base3()
{
Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",3)");
- Assert.IsTrue(XLHelper.AreEqual(5.24931506849315, (double)actual));
+ Assert.IsTrue(XLHelper.AreEqual(5.24931506849315, (double) actual));
}
- [TestMethod]
+ [Test]
public void Yearfrac_2_base4()
{
Object actual = XLWorkbook.EvaluateExpr("Yearfrac(\"1/1/2008\", \"3/31/2013\",4)");
- Assert.IsTrue(XLHelper.AreEqual(5.24722222222222, (double)actual));
+ Assert.IsTrue(XLHelper.AreEqual(5.24722222222222, (double) actual));
}
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/FunctionsTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/FunctionsTests.cs
index 4444276..b535017 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/FunctionsTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/FunctionsTests.cs
@@ -1,154 +1,64 @@
using System;
-using System.IO;
-using System.Text;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel.DataValidations
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class FunctionsTests
{
+ [Test]
+ public void Asc()
+ {
+ Object actual;
- [TestMethod]
+ actual = XLWorkbook.EvaluateExpr(@"Asc(""Text"")");
+ Assert.AreEqual("Text", actual);
+ }
+
+ [Test]
+ public void Clean()
+ {
+ Object actual;
+
+ actual = XLWorkbook.EvaluateExpr(String.Format(@"Clean(""A{0}B"")", Environment.NewLine));
+ Assert.AreEqual("AB", actual);
+ }
+
+ [Test]
public void Combin()
{
- var actual1 = XLWorkbook.EvaluateExpr("Combin(200, 2)");
+ object actual1 = XLWorkbook.EvaluateExpr("Combin(200, 2)");
Assert.AreEqual(19900.0, actual1);
- var actual2 = XLWorkbook.EvaluateExpr("Combin(20.1, 2.9)");
+ object actual2 = XLWorkbook.EvaluateExpr("Combin(20.1, 2.9)");
Assert.AreEqual(190.0, actual2);
}
- [TestMethod]
+ [Test]
public void Degrees()
{
- var actual1 = XLWorkbook.EvaluateExpr("Degrees(180)");
- Assert.IsTrue(Math.PI - (double)actual1 < XLHelper.Epsilon);
+ object actual1 = XLWorkbook.EvaluateExpr("Degrees(180)");
+ Assert.IsTrue(Math.PI - (double) actual1 < XLHelper.Epsilon);
}
- [TestMethod]
- public void Fact()
+ [Test]
+ public void Dollar()
{
- var actual = XLWorkbook.EvaluateExpr("Fact(5.9)");
- Assert.AreEqual(120.0, actual);
+ object actual = XLWorkbook.EvaluateExpr("Dollar(12345.123)");
+ Assert.AreEqual(TestHelper.CurrencySymbol + "12,345.12", actual);
+
+ actual = XLWorkbook.EvaluateExpr("Dollar(12345.123, 1)");
+ Assert.AreEqual(TestHelper.CurrencySymbol + "12,345.1", actual);
}
- [TestMethod]
- public void FactDouble()
- {
- var actual1 = XLWorkbook.EvaluateExpr("FactDouble(6)");
- Assert.AreEqual(48.0, actual1);
- var actual2 = XLWorkbook.EvaluateExpr("FactDouble(7)");
- Assert.AreEqual(105.0, actual2);
- }
-
- [TestMethod]
- public void Gcd()
- {
- var actual = XLWorkbook.EvaluateExpr("Gcd(24, 36)");
- Assert.AreEqual(12, actual);
-
- var actual1 = XLWorkbook.EvaluateExpr("Gcd(5, 0)");
- Assert.AreEqual(5, actual1);
-
- var actual2 = XLWorkbook.EvaluateExpr("Gcd(0, 5)");
- Assert.AreEqual(5, actual2);
-
- var actual3 = XLWorkbook.EvaluateExpr("Gcd(240, 360, 30)");
- Assert.AreEqual(30, actual3);
- }
-
- [TestMethod]
- public void Lcm()
- {
- var actual = XLWorkbook.EvaluateExpr("Lcm(24, 36)");
- Assert.AreEqual(72, actual);
-
- var actual1 = XLWorkbook.EvaluateExpr("Lcm(5, 0)");
- Assert.AreEqual(0, actual1);
-
- var actual2 = XLWorkbook.EvaluateExpr("Lcm(0, 5)");
- Assert.AreEqual(0, actual2);
-
- var actual3 = XLWorkbook.EvaluateExpr("Lcm(240, 360, 30)");
- Assert.AreEqual(720, actual3);
- }
-
- [TestMethod]
- public void Mod()
- {
- var actual = XLWorkbook.EvaluateExpr("Mod(3, 2)");
- Assert.AreEqual(1, actual);
-
- var actual1 = XLWorkbook.EvaluateExpr("Mod(-3, 2)");
- Assert.AreEqual(1, actual1);
-
- var actual2 = XLWorkbook.EvaluateExpr("Mod(3, -2)");
- Assert.AreEqual(-1, actual2);
-
- var actual3 = XLWorkbook.EvaluateExpr("Mod(-3, -2)");
- Assert.AreEqual(-1, actual3);
- }
-
- [TestMethod]
- public void MRound()
- {
- var actual = XLWorkbook.EvaluateExpr("MRound(10, 3)");
- Assert.AreEqual(9m, actual);
-
- var actual3 = XLWorkbook.EvaluateExpr("MRound(10.5, 3)");
- Assert.AreEqual(12m, actual3);
-
- var actual4 = XLWorkbook.EvaluateExpr("MRound(10.4, 3)");
- Assert.AreEqual(9m, actual4);
-
- var actual1 = XLWorkbook.EvaluateExpr("MRound(-10, -3)");
- Assert.AreEqual(-9m, actual1);
-
- var actual2 = XLWorkbook.EvaluateExpr("MRound(1.3, 0.2)");
- Assert.AreEqual(1.4m, actual2);
- }
-
- [TestMethod]
- public void Multinomial()
- {
- var actual = XLWorkbook.EvaluateExpr("Multinomial(2,3,4)");
- Assert.AreEqual(1260.0, actual);
- }
-
- [TestMethod]
- public void Odd()
- {
- var actual = XLWorkbook.EvaluateExpr("Odd(1.5)");
- Assert.AreEqual(3, actual);
-
- var actual1 = XLWorkbook.EvaluateExpr("Odd(3)");
- Assert.AreEqual(3, actual1);
-
- var actual2 = XLWorkbook.EvaluateExpr("Odd(2)");
- Assert.AreEqual(3, actual2);
-
- var actual3 = XLWorkbook.EvaluateExpr("Odd(-1)");
- Assert.AreEqual(-1, actual3);
-
- var actual4 = XLWorkbook.EvaluateExpr("Odd(-2)");
- Assert.AreEqual(-3, actual4);
-
- actual = XLWorkbook.EvaluateExpr("Odd(0)");
- Assert.AreEqual(1, actual);
- }
-
- [TestMethod]
+ [Test]
public void Even()
{
- var actual = XLWorkbook.EvaluateExpr("Even(3)");
+ object actual = XLWorkbook.EvaluateExpr("Even(3)");
Assert.AreEqual(4, actual);
actual = XLWorkbook.EvaluateExpr("Even(2)");
@@ -170,17 +80,248 @@
Assert.AreEqual(4, actual);
}
- [TestMethod]
+ [Test]
+ public void Exact()
+ {
+ Object actual;
+
+ actual = XLWorkbook.EvaluateExpr("Exact(\"A\", \"A\")");
+ Assert.AreEqual(true, actual);
+
+ actual = XLWorkbook.EvaluateExpr("Exact(\"A\", \"a\")");
+ Assert.AreEqual(false, actual);
+ }
+
+ [Test]
+ public void Fact()
+ {
+ object actual = XLWorkbook.EvaluateExpr("Fact(5.9)");
+ Assert.AreEqual(120.0, actual);
+ }
+
+ [Test]
+ public void FactDouble()
+ {
+ object actual1 = XLWorkbook.EvaluateExpr("FactDouble(6)");
+ Assert.AreEqual(48.0, actual1);
+ object actual2 = XLWorkbook.EvaluateExpr("FactDouble(7)");
+ Assert.AreEqual(105.0, actual2);
+ }
+
+ [Test]
+ public void Fixed()
+ {
+ Object actual;
+
+ actual = XLWorkbook.EvaluateExpr("Fixed(12345.123)");
+ Assert.AreEqual("12,345.12", actual);
+
+ actual = XLWorkbook.EvaluateExpr("Fixed(12345.123, 1)");
+ Assert.AreEqual("12,345.1", actual);
+
+ actual = XLWorkbook.EvaluateExpr("Fixed(12345.123, 1, FALSE)");
+ Assert.AreEqual("12345.1", actual);
+ }
+
+ [Test]
+ public void Formula_from_another_sheet()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws1 = wb.AddWorksheet("ws1");
+ ws1.FirstCell().SetValue(1).CellRight().SetFormulaA1("A1 + 1");
+ IXLWorksheet ws2 = wb.AddWorksheet("ws2");
+ ws2.FirstCell().SetFormulaA1("ws1!B1 + 1");
+ object v = ws2.FirstCell().Value;
+ Assert.AreEqual(3.0, v);
+ }
+
+ [Test]
+ public void Gcd()
+ {
+ object actual = XLWorkbook.EvaluateExpr("Gcd(24, 36)");
+ Assert.AreEqual(12, actual);
+
+ object actual1 = XLWorkbook.EvaluateExpr("Gcd(5, 0)");
+ Assert.AreEqual(5, actual1);
+
+ object actual2 = XLWorkbook.EvaluateExpr("Gcd(0, 5)");
+ Assert.AreEqual(5, actual2);
+
+ object actual3 = XLWorkbook.EvaluateExpr("Gcd(240, 360, 30)");
+ Assert.AreEqual(30, actual3);
+ }
+
+ [Test]
+ public void Lcm()
+ {
+ object actual = XLWorkbook.EvaluateExpr("Lcm(24, 36)");
+ Assert.AreEqual(72, actual);
+
+ object actual1 = XLWorkbook.EvaluateExpr("Lcm(5, 0)");
+ Assert.AreEqual(0, actual1);
+
+ object actual2 = XLWorkbook.EvaluateExpr("Lcm(0, 5)");
+ Assert.AreEqual(0, actual2);
+
+ object actual3 = XLWorkbook.EvaluateExpr("Lcm(240, 360, 30)");
+ Assert.AreEqual(720, actual3);
+ }
+
+ [Test]
+ public void MDetem()
+ {
+ IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1");
+ ws.Cell("A1").SetValue(2).CellRight().SetValue(4);
+ ws.Cell("A2").SetValue(3).CellRight().SetValue(5);
+
+
+ Object actual;
+
+ ws.Cell("A5").FormulaA1 = "MDeterm(A1:B2)";
+ actual = ws.Cell("A5").Value;
+
+ Assert.IsTrue(XLHelper.AreEqual(-2.0, (double) actual));
+
+ ws.Cell("A6").FormulaA1 = "Sum(A5)";
+ actual = ws.Cell("A6").Value;
+
+ Assert.IsTrue(XLHelper.AreEqual(-2.0, (double) actual));
+
+ ws.Cell("A7").FormulaA1 = "Sum(MDeterm(A1:B2))";
+ actual = ws.Cell("A7").Value;
+
+ Assert.IsTrue(XLHelper.AreEqual(-2.0, (double) actual));
+ }
+
+ [Test]
+ public void MInverse()
+ {
+ IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1");
+ ws.Cell("A1").SetValue(1).CellRight().SetValue(2).CellRight().SetValue(1);
+ ws.Cell("A2").SetValue(3).CellRight().SetValue(4).CellRight().SetValue(-1);
+ ws.Cell("A3").SetValue(0).CellRight().SetValue(2).CellRight().SetValue(0);
+
+
+ Object actual;
+
+ ws.Cell("A5").FormulaA1 = "MInverse(A1:C3)";
+ actual = ws.Cell("A5").Value;
+
+ Assert.IsTrue(XLHelper.AreEqual(0.25, (double) actual));
+
+ ws.Cell("A6").FormulaA1 = "Sum(A5)";
+ actual = ws.Cell("A6").Value;
+
+ Assert.IsTrue(XLHelper.AreEqual(0.25, (double) actual));
+
+ ws.Cell("A7").FormulaA1 = "Sum(MInverse(A1:C3))";
+ actual = ws.Cell("A7").Value;
+
+ Assert.IsTrue(XLHelper.AreEqual(0.5, (double) actual));
+ }
+
+ [Test]
+ public void MMult()
+ {
+ IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1");
+ ws.Cell("A1").SetValue(2).CellRight().SetValue(4);
+ ws.Cell("A2").SetValue(3).CellRight().SetValue(5);
+ ws.Cell("A3").SetValue(2).CellRight().SetValue(4);
+ ws.Cell("A4").SetValue(3).CellRight().SetValue(5);
+
+ Object actual;
+
+ ws.Cell("A5").FormulaA1 = "MMult(A1:B2, A3:B4)";
+ actual = ws.Cell("A5").Value;
+
+ Assert.AreEqual(16.0, actual);
+
+ ws.Cell("A6").FormulaA1 = "Sum(A5)";
+ actual = ws.Cell("A6").Value;
+
+ Assert.AreEqual(16.0, actual);
+
+ ws.Cell("A7").FormulaA1 = "Sum(MMult(A1:B2, A3:B4))";
+ actual = ws.Cell("A7").Value;
+
+ Assert.AreEqual(102.0, actual);
+ }
+
+ [Test]
+ public void MRound()
+ {
+ object actual = XLWorkbook.EvaluateExpr("MRound(10, 3)");
+ Assert.AreEqual(9m, actual);
+
+ object actual3 = XLWorkbook.EvaluateExpr("MRound(10.5, 3)");
+ Assert.AreEqual(12m, actual3);
+
+ object actual4 = XLWorkbook.EvaluateExpr("MRound(10.4, 3)");
+ Assert.AreEqual(9m, actual4);
+
+ object actual1 = XLWorkbook.EvaluateExpr("MRound(-10, -3)");
+ Assert.AreEqual(-9m, actual1);
+
+ object actual2 = XLWorkbook.EvaluateExpr("MRound(1.3, 0.2)");
+ Assert.AreEqual(1.4m, actual2);
+ }
+
+ [Test]
+ public void Mod()
+ {
+ object actual = XLWorkbook.EvaluateExpr("Mod(3, 2)");
+ Assert.AreEqual(1, actual);
+
+ object actual1 = XLWorkbook.EvaluateExpr("Mod(-3, 2)");
+ Assert.AreEqual(1, actual1);
+
+ object actual2 = XLWorkbook.EvaluateExpr("Mod(3, -2)");
+ Assert.AreEqual(-1, actual2);
+
+ object actual3 = XLWorkbook.EvaluateExpr("Mod(-3, -2)");
+ Assert.AreEqual(-1, actual3);
+ }
+
+ [Test]
+ public void Multinomial()
+ {
+ object actual = XLWorkbook.EvaluateExpr("Multinomial(2,3,4)");
+ Assert.AreEqual(1260.0, actual);
+ }
+
+ [Test]
+ public void Odd()
+ {
+ object actual = XLWorkbook.EvaluateExpr("Odd(1.5)");
+ Assert.AreEqual(3, actual);
+
+ object actual1 = XLWorkbook.EvaluateExpr("Odd(3)");
+ Assert.AreEqual(3, actual1);
+
+ object actual2 = XLWorkbook.EvaluateExpr("Odd(2)");
+ Assert.AreEqual(3, actual2);
+
+ object actual3 = XLWorkbook.EvaluateExpr("Odd(-1)");
+ Assert.AreEqual(-1, actual3);
+
+ object actual4 = XLWorkbook.EvaluateExpr("Odd(-2)");
+ Assert.AreEqual(-3, actual4);
+
+ actual = XLWorkbook.EvaluateExpr("Odd(0)");
+ Assert.AreEqual(1, actual);
+ }
+
+ [Test]
public void Product()
{
- var actual = XLWorkbook.EvaluateExpr("Product(2,3,4)");
+ object actual = XLWorkbook.EvaluateExpr("Product(2,3,4)");
Assert.AreEqual(24.0, actual);
}
- [TestMethod]
+ [Test]
public void Quotient()
{
- var actual = XLWorkbook.EvaluateExpr("Quotient(5,2)");
+ object actual = XLWorkbook.EvaluateExpr("Quotient(5,2)");
Assert.AreEqual(2, actual);
actual = XLWorkbook.EvaluateExpr("Quotient(4.5,3.1)");
@@ -190,17 +331,17 @@
Assert.AreEqual(-3, actual);
}
- [TestMethod]
+ [Test]
public void Radians()
{
- var actual = XLWorkbook.EvaluateExpr("Radians(270)");
- Assert.IsTrue(Math.Abs(4.71238898038469 - (double)actual) < XLHelper.Epsilon);
+ object actual = XLWorkbook.EvaluateExpr("Radians(270)");
+ Assert.IsTrue(Math.Abs(4.71238898038469 - (double) actual) < XLHelper.Epsilon);
}
- [TestMethod]
+ [Test]
public void Roman()
{
- var actual = XLWorkbook.EvaluateExpr("Roman(3046, 1)");
+ object actual = XLWorkbook.EvaluateExpr("Roman(3046, 1)");
Assert.AreEqual("MMMXLVI", actual);
actual = XLWorkbook.EvaluateExpr("Roman(270)");
@@ -210,10 +351,10 @@
Assert.AreEqual("MMMCMXCIX", actual);
}
- [TestMethod]
+ [Test]
public void Round()
{
- var actual = XLWorkbook.EvaluateExpr("Round(2.15, 1)");
+ object actual = XLWorkbook.EvaluateExpr("Round(2.15, 1)");
Assert.AreEqual(2.2, actual);
actual = XLWorkbook.EvaluateExpr("Round(2.149, 1)");
@@ -235,10 +376,10 @@
Assert.AreEqual(-100.0, actual);
}
- [TestMethod]
+ [Test]
public void RoundDown()
{
- var actual = XLWorkbook.EvaluateExpr("RoundDown(3.2, 0)");
+ object actual = XLWorkbook.EvaluateExpr("RoundDown(3.2, 0)");
Assert.AreEqual(3.0, actual);
actual = XLWorkbook.EvaluateExpr("RoundDown(76.9, 0)");
@@ -257,10 +398,10 @@
Assert.AreEqual(0.0, actual);
}
- [TestMethod]
+ [Test]
public void RoundUp()
{
- var actual = XLWorkbook.EvaluateExpr("RoundUp(3.2, 0)");
+ object actual = XLWorkbook.EvaluateExpr("RoundUp(3.2, 0)");
Assert.AreEqual(4.0, actual);
actual = XLWorkbook.EvaluateExpr("RoundUp(76.9, 0)");
@@ -279,14 +420,14 @@
Assert.AreEqual(0.0, actual);
}
- [TestMethod]
+ [Test]
public void SeriesSum()
{
- var actual = XLWorkbook.EvaluateExpr("SERIESSUM(2,3,4,5)");
+ object actual = XLWorkbook.EvaluateExpr("SERIESSUM(2,3,4,5)");
Assert.AreEqual(40.0, actual);
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
ws.Cell("A2").FormulaA1 = "PI()/4";
ws.Cell("A3").Value = 1;
ws.Cell("A4").FormulaA1 = "-1/FACT(2)";
@@ -294,40 +435,40 @@
ws.Cell("A6").FormulaA1 = "-1/FACT(6)";
actual = ws.Evaluate("SERIESSUM(A2,0,2,A3:A6)");
- Assert.IsTrue(Math.Abs(0.70710321482284566 - (double)actual) < XLHelper.Epsilon);
+ Assert.IsTrue(Math.Abs(0.70710321482284566 - (double) actual) < XLHelper.Epsilon);
}
- [TestMethod]
+ [Test]
public void SqrtPi()
{
- var actual = XLWorkbook.EvaluateExpr("SqrtPi(1)");
- Assert.IsTrue(Math.Abs(1.7724538509055159 - (double)actual) < XLHelper.Epsilon);
+ object actual = XLWorkbook.EvaluateExpr("SqrtPi(1)");
+ Assert.IsTrue(Math.Abs(1.7724538509055159 - (double) actual) < XLHelper.Epsilon);
actual = XLWorkbook.EvaluateExpr("SqrtPi(2)");
- Assert.IsTrue(Math.Abs(2.5066282746310002 - (double)actual) < XLHelper.Epsilon);
+ Assert.IsTrue(Math.Abs(2.5066282746310002 - (double) actual) < XLHelper.Epsilon);
}
- [TestMethod]
+ [Test]
public void SubtotalAverage()
{
- var actual = XLWorkbook.EvaluateExpr("Subtotal(1,2,3)");
+ object actual = XLWorkbook.EvaluateExpr("Subtotal(1,2,3)");
Assert.AreEqual(2.5, actual);
actual = XLWorkbook.EvaluateExpr(@"Subtotal(1,""A"",3, 2)");
Assert.AreEqual(2.5, actual);
}
- [TestMethod]
+ [Test]
public void SubtotalCount()
{
- var actual = XLWorkbook.EvaluateExpr("Subtotal(2,2,3)");
+ object actual = XLWorkbook.EvaluateExpr("Subtotal(2,2,3)");
Assert.AreEqual(2.0, actual);
actual = XLWorkbook.EvaluateExpr(@"Subtotal(2,""A"",3)");
Assert.AreEqual(2.0, actual);
}
- [TestMethod]
+ [Test]
public void SubtotalCountA()
{
Object actual;
@@ -339,7 +480,7 @@
Assert.AreEqual(1.0, actual);
}
- [TestMethod]
+ [Test]
public void SubtotalMax()
{
Object actual;
@@ -348,7 +489,7 @@
Assert.AreEqual(3.0, actual);
}
- [TestMethod]
+ [Test]
public void SubtotalMin()
{
Object actual;
@@ -357,7 +498,7 @@
Assert.AreEqual(2.0, actual);
}
- [TestMethod]
+ [Test]
public void SubtotalProduct()
{
Object actual;
@@ -366,16 +507,16 @@
Assert.AreEqual(6.0, actual);
}
- [TestMethod]
+ [Test]
public void SubtotalStDev()
{
Object actual;
actual = XLWorkbook.EvaluateExpr(@"Subtotal(7,2,3,""A"")");
- Assert.IsTrue(Math.Abs(0.70710678118654757 - (double)actual) < XLHelper.Epsilon);
+ Assert.IsTrue(Math.Abs(0.70710678118654757 - (double) actual) < XLHelper.Epsilon);
}
- [TestMethod]
+ [Test]
public void SubtotalStDevP()
{
Object actual;
@@ -384,7 +525,7 @@
Assert.AreEqual(0.5, actual);
}
- [TestMethod]
+ [Test]
public void SubtotalSum()
{
Object actual;
@@ -393,16 +534,16 @@
Assert.AreEqual(5.0, actual);
}
- [TestMethod]
+ [Test]
public void SubtotalVar()
{
Object actual;
actual = XLWorkbook.EvaluateExpr(@"Subtotal(10,2,3,""A"")");
- Assert.IsTrue(Math.Abs(0.5 - (double)actual) < XLHelper.Epsilon);
+ Assert.IsTrue(Math.Abs(0.5 - (double) actual) < XLHelper.Epsilon);
}
- [TestMethod]
+ [Test]
public void SubtotalVarP()
{
Object actual;
@@ -411,7 +552,17 @@
Assert.AreEqual(0.25, actual);
}
- [TestMethod]
+ [Test]
+ public void Sum()
+ {
+ IXLCell cell = new XLWorkbook().AddWorksheet("Sheet1").FirstCell();
+ IXLCell fCell = cell.SetValue(1).CellBelow().SetValue(2).CellBelow();
+ fCell.FormulaA1 = "sum(A1:A2)";
+
+ Assert.AreEqual(3.0, fCell.Value);
+ }
+
+ [Test]
public void SumSq()
{
Object actual;
@@ -420,156 +571,11 @@
Assert.AreEqual(25.0, actual);
}
- [TestMethod]
- public void Asc()
- {
- Object actual;
-
- actual = XLWorkbook.EvaluateExpr(@"Asc(""Text"")");
- Assert.AreEqual("Text", actual);
- }
-
- [TestMethod]
- public void Clean()
- {
- Object actual;
-
- actual = XLWorkbook.EvaluateExpr(String.Format(@"Clean(""A{0}B"")", Environment.NewLine));
- Assert.AreEqual("AB", actual);
- }
-
- [TestMethod]
- public void Dollar()
- {
- var actual = XLWorkbook.EvaluateExpr("Dollar(12345.123)");
- Assert.AreEqual(TestHelper.CurrencySymbol + " 12,345.12", actual);
-
- actual = XLWorkbook.EvaluateExpr("Dollar(12345.123, 1)");
- Assert.AreEqual(TestHelper.CurrencySymbol + " 12,345.1", actual);
- }
-
- [TestMethod]
- public void Exact()
- {
- Object actual;
-
- actual = XLWorkbook.EvaluateExpr("Exact(\"A\", \"A\")");
- Assert.AreEqual(true, actual);
-
- actual = XLWorkbook.EvaluateExpr("Exact(\"A\", \"a\")");
- Assert.AreEqual(false, actual);
- }
-
- [TestMethod]
- public void Fixed()
- {
- Object actual;
-
- actual = XLWorkbook.EvaluateExpr("Fixed(12345.123)");
- Assert.AreEqual("12,345.12", actual);
-
- actual = XLWorkbook.EvaluateExpr("Fixed(12345.123, 1)");
- Assert.AreEqual("12,345.1", actual);
-
- actual = XLWorkbook.EvaluateExpr("Fixed(12345.123, 1, FALSE)");
- Assert.AreEqual("12345.1", actual);
- }
-
- [TestMethod]
- public void Sum()
- {
- var cell = new XLWorkbook().AddWorksheet("Sheet1").FirstCell();
- var fCell = cell.SetValue(1).CellBelow().SetValue(2).CellBelow();
- fCell.FormulaA1 = "sum(A1:A2)";
-
- Assert.AreEqual(3.0, fCell.Value);
- }
-
- [TestMethod]
- public void MMult()
- {
- var ws = new XLWorkbook().AddWorksheet("Sheet1");
- ws.Cell("A1").SetValue(2).CellRight().SetValue(4);
- ws.Cell("A2").SetValue(3).CellRight().SetValue(5);
- ws.Cell("A3").SetValue(2).CellRight().SetValue(4);
- ws.Cell("A4").SetValue(3).CellRight().SetValue(5);
-
- Object actual;
-
- ws.Cell("A5").FormulaA1 = "MMult(A1:B2, A3:B4)";
- actual = ws.Cell("A5").Value;
-
- Assert.AreEqual(16.0, actual);
-
- ws.Cell("A6").FormulaA1 = "Sum(A5)";
- actual = ws.Cell("A6").Value;
-
- Assert.AreEqual(16.0, actual);
-
- ws.Cell("A7").FormulaA1 = "Sum(MMult(A1:B2, A3:B4))";
- actual = ws.Cell("A7").Value;
-
- Assert.AreEqual(102.0, actual);
- }
-
- [TestMethod]
- public void MDetem()
- {
- var ws = new XLWorkbook().AddWorksheet("Sheet1");
- ws.Cell("A1").SetValue(2).CellRight().SetValue(4);
- ws.Cell("A2").SetValue(3).CellRight().SetValue(5);
-
-
- Object actual;
-
- ws.Cell("A5").FormulaA1 = "MDeterm(A1:B2)";
- actual = ws.Cell("A5").Value;
-
- Assert.IsTrue(XLHelper.AreEqual(-2.0, (double)actual));
-
- ws.Cell("A6").FormulaA1 = "Sum(A5)";
- actual = ws.Cell("A6").Value;
-
- Assert.IsTrue(XLHelper.AreEqual(-2.0, (double)actual));
-
- ws.Cell("A7").FormulaA1 = "Sum(MDeterm(A1:B2))";
- actual = ws.Cell("A7").Value;
-
- Assert.IsTrue(XLHelper.AreEqual(-2.0, (double)actual));
- }
-
- [TestMethod]
- public void MInverse()
- {
- var ws = new XLWorkbook().AddWorksheet("Sheet1");
- ws.Cell("A1").SetValue(1).CellRight().SetValue(2).CellRight().SetValue(1);
- ws.Cell("A2").SetValue(3).CellRight().SetValue(4).CellRight().SetValue(-1);
- ws.Cell("A3").SetValue(0).CellRight().SetValue(2).CellRight().SetValue(0);
-
-
- Object actual;
-
- ws.Cell("A5").FormulaA1 = "MInverse(A1:C3)";
- actual = ws.Cell("A5").Value;
-
- Assert.IsTrue(XLHelper.AreEqual(0.25, (double)actual));
-
- ws.Cell("A6").FormulaA1 = "Sum(A5)";
- actual = ws.Cell("A6").Value;
-
- Assert.IsTrue(XLHelper.AreEqual(0.25, (double)actual));
-
- ws.Cell("A7").FormulaA1 = "Sum(MInverse(A1:C3))";
- actual = ws.Cell("A7").Value;
-
- Assert.IsTrue(XLHelper.AreEqual(0.5, (double)actual));
- }
-
- [TestMethod]
+ [Test]
public void TextConcat()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
ws.Cell("A1").Value = 1;
ws.Cell("A2").Value = 1;
ws.Cell("B1").Value = 1;
@@ -577,20 +583,8 @@
ws.Cell("C1").FormulaA1 = "\"The total value is: \" & SUM(A1:B2)";
- var r = ws.Cell("C1").Value;
+ object r = ws.Cell("C1").Value;
Assert.AreEqual("The total value is: 4", r.ToString());
}
-
- [TestMethod]
- public void Formula_from_another_sheet()
- {
- var wb = new XLWorkbook();
- var ws1 = wb.AddWorksheet("ws1");
- ws1.FirstCell().SetValue(1).CellRight().SetFormulaA1("A1 + 1");
- var ws2 = wb.AddWorksheet("ws2");
- ws2.FirstCell().SetFormulaA1("ws1!B1 + 1");
- var v = ws2.FirstCell().Value;
- Assert.AreEqual(3.0, v);
- }
}
-}
+}
\ 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 f310d2a..aaade5c 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/XLMathTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/CalcEngine/XLMathTests.cs
@@ -1,29 +1,26 @@
-using System;
-using ClosedXML.Excel;
-using ClosedXML.Excel.CalcEngine.Functions;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ClosedXML.Excel.CalcEngine.Functions;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel.CalcEngine
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class XLMathTests
{
-
- [TestMethod]
+ [Test]
public void IsEven()
{
Assert.IsTrue(XLMath.IsEven(2));
Assert.IsFalse(XLMath.IsEven(3));
}
- [TestMethod]
+ [Test]
public void IsOdd()
{
Assert.IsTrue(XLMath.IsOdd(3));
Assert.IsFalse(XLMath.IsOdd(2));
}
}
-}
+}
\ 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
index 7de5ab4..2d10741 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Cells/XLCellTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Cells/XLCellTests.cs
@@ -1,300 +1,301 @@
-using System.Collections.Generic;
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
using System.Linq;
-using System;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- [TestClass]
+ [TestFixture]
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]
+ [Test]
public void CellsUsed()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
ws.Cell(1, 1);
ws.Cell(2, 2);
- var count = ws.Range("A1:B2").CellsUsed().Count();
+ int count = ws.Range("A1:B2").CellsUsed().Count();
Assert.AreEqual(0, count);
}
- [TestMethod]
- public void TryGetValue_TimeSpan_Good()
+ [Test]
+ public void Double_Infinity_is_a_string()
{
- 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);
- }
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell("A1");
+ var doubleList = new List {1.0/0.0};
- [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";
-
+ cell.Value = doubleList.AsEnumerable();
Assert.AreNotEqual(XLCellValues.Number, cell.DataType);
}
- [TestMethod]
+ [Test]
public void Double_NaN_is_a_string()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var cell = ws.Cell("A1");
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell 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();
+ [Test]
+ public void InsertData1()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRange range = ws.Cell(2, 2).InsertData(new[] {"a", "b", "c"});
+ Assert.AreEqual("'Sheet1'!B2:B4", range.ToString());
+ }
+
+ [Test]
+ public void IsEmpty1()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ bool actual = cell.IsEmpty();
+ bool expected = true;
+ Assert.AreEqual(expected, actual);
+ }
+
+ [Test]
+ public void IsEmpty2()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ bool actual = cell.IsEmpty(true);
+ bool expected = true;
+ Assert.AreEqual(expected, actual);
+ }
+
+ [Test]
+ public void IsEmpty3()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ cell.Style.Fill.BackgroundColor = XLColor.Red;
+ bool actual = cell.IsEmpty();
+ bool expected = true;
+ Assert.AreEqual(expected, actual);
+ }
+
+ [Test]
+ public void IsEmpty4()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ cell.Style.Fill.BackgroundColor = XLColor.Red;
+ bool actual = cell.IsEmpty(false);
+ bool expected = true;
+ Assert.AreEqual(expected, actual);
+ }
+
+ [Test]
+ public void IsEmpty5()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ cell.Style.Fill.BackgroundColor = XLColor.Red;
+ bool actual = cell.IsEmpty(true);
+ bool expected = false;
+ Assert.AreEqual(expected, actual);
+ }
+
+ [Test]
+ public void IsEmpty6()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ cell.Value = "X";
+ bool actual = cell.IsEmpty();
+ bool expected = false;
+ Assert.AreEqual(expected, actual);
+ }
+
+ [Test]
+ public void NaN_is_not_a_number()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell("A1");
+ cell.Value = "NaN";
+
Assert.AreNotEqual(XLCellValues.Number, cell.DataType);
}
+
+ [Test]
+ public void Nan_is_not_a_number()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell("A1");
+ cell.Value = "Nan";
+
+ Assert.AreNotEqual(XLCellValues.Number, cell.DataType);
+ }
+
+ [Test]
+ public void TryGetValue_Boolean_Bad()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ Boolean outValue;
+ IXLCell cell = ws.Cell("A1").SetValue("ABC");
+ bool success = cell.TryGetValue(out outValue);
+ Assert.IsFalse(success);
+ }
+
+ [Test]
+ public void TryGetValue_Boolean_False()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ Boolean outValue;
+ IXLCell cell = ws.Cell("A1").SetValue(false);
+ bool success = cell.TryGetValue(out outValue);
+ Assert.IsTrue(success);
+ Assert.IsFalse(outValue);
+ }
+
+ [Test]
+ public void TryGetValue_Boolean_Good()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ Boolean outValue;
+ IXLCell cell = ws.Cell("A1").SetValue("True");
+ bool success = cell.TryGetValue(out outValue);
+ Assert.IsTrue(success);
+ Assert.IsTrue(outValue);
+ }
+
+ [Test]
+ public void TryGetValue_Boolean_True()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ Boolean outValue;
+ IXLCell cell = ws.Cell("A1").SetValue(true);
+ bool success = cell.TryGetValue(out outValue);
+ Assert.IsTrue(success);
+ Assert.IsTrue(outValue);
+ }
+
+ [Test]
+ public void TryGetValue_RichText_Bad()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText outValue;
+ IXLCell cell = ws.Cell("A1").SetValue("Anything");
+ bool success = cell.TryGetValue(out outValue);
+ Assert.IsTrue(success);
+ Assert.AreEqual(cell.RichText, outValue);
+ Assert.AreEqual("Anything", outValue.ToString());
+ }
+
+ [Test]
+ public void TryGetValue_RichText_Good()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText outValue;
+ IXLCell cell = ws.Cell("A1");
+ cell.RichText.AddText("Anything");
+ bool success = cell.TryGetValue(out outValue);
+ Assert.IsTrue(success);
+ Assert.AreEqual(cell.RichText, outValue);
+ }
+
+ [Test]
+ public void TryGetValue_TimeSpan_BadString()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ TimeSpan outValue;
+ string timeSpan = "ABC";
+ bool success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out outValue);
+ Assert.IsFalse(success);
+ }
+
+ [Test]
+ public void TryGetValue_TimeSpan_Good()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ TimeSpan outValue;
+ var timeSpan = new TimeSpan(1, 1, 1);
+ bool success = ws.Cell("A1").SetValue(timeSpan).TryGetValue(out outValue);
+ Assert.IsTrue(success);
+ Assert.AreEqual(timeSpan, outValue);
+ }
+
+ [Test]
+ public void TryGetValue_TimeSpan_GoodString()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ TimeSpan outValue;
+ var timeSpan = new TimeSpan(1, 1, 1);
+ bool success = ws.Cell("A1").SetValue(timeSpan.ToString()).TryGetValue(out outValue);
+ Assert.IsTrue(success);
+ Assert.AreEqual(timeSpan, outValue);
+ }
+
+ [Test]
+ public void TryGetValue_sbyte_Bad()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ sbyte outValue;
+ IXLCell cell = ws.Cell("A1").SetValue(255);
+ bool success = cell.TryGetValue(out outValue);
+ Assert.IsFalse(success);
+ }
+
+ [Test]
+ public void TryGetValue_sbyte_Bad2()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ sbyte outValue;
+ IXLCell cell = ws.Cell("A1").SetValue("255");
+ bool success = cell.TryGetValue(out outValue);
+ Assert.IsFalse(success);
+ }
+
+ [Test]
+ public void TryGetValue_sbyte_Good()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ sbyte outValue;
+ IXLCell cell = ws.Cell("A1").SetValue(5);
+ bool success = cell.TryGetValue(out outValue);
+ Assert.IsTrue(success);
+ Assert.AreEqual(5, outValue);
+ }
+
+ [Test]
+ public void TryGetValue_sbyte_Good2()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ sbyte outValue;
+ IXLCell cell = ws.Cell("A1").SetValue("5");
+ bool success = cell.TryGetValue(out outValue);
+ Assert.IsTrue(success);
+ Assert.AreEqual(5, outValue);
+ }
+
+ [Test]
+ public void ValueSetToEmptyString()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ cell.Value = new DateTime(2000, 1, 2);
+ cell.Value = String.Empty;
+ string actual = cell.GetString();
+ string expected = String.Empty;
+ Assert.AreEqual(expected, actual);
+ }
+
+ [Test]
+ public void ValueSetToNull()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ cell.Value = new DateTime(2000, 1, 2);
+ cell.Value = null;
+ string actual = cell.GetString();
+ string expected = String.Empty;
+ Assert.AreEqual(expected, actual);
+ }
}
}
\ 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
index bd4e237..c4d1747 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Columns/ColumnTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Columns/ColumnTests.cs
@@ -1,64 +1,58 @@
-using ClosedXML.Excel;
-using DocumentFormat.OpenXml.Drawing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
+using System;
+using System.IO;
using System.Linq;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class ColumnTests
{
-
- [TestMethod]
+ [Test]
public void ColumnUsed()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell(2, 1).SetValue("Test");
ws.Cell(3, 1).SetValue("Test");
- var fromColumn = ws.Column(1).ColumnUsed();
+ IXLRangeColumn fromColumn = ws.Column(1).ColumnUsed();
Assert.AreEqual("A2:A3", fromColumn.RangeAddress.ToStringRelative());
- var fromRange = ws.Range("A1:A5").FirstColumn().ColumnUsed();
+ IXLRangeColumn fromRange = ws.Range("A1:A5").FirstColumn().ColumnUsed();
Assert.AreEqual("A2:A3", fromRange.RangeAddress.ToStringRelative());
}
- [TestMethod]
- public void NoColumnsUsed()
+ [Test]
+ public void CopyColumn()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
- Int32 count = 0;
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue("Test").Style.Font.SetBold();
+ ws.FirstColumn().CopyTo(ws.Column(2));
- foreach (var row in ws.ColumnsUsed())
- count++;
-
- foreach (var row in ws.Range("A1:C3").ColumnsUsed())
- count++;
-
- Assert.AreEqual(0, count);
+ Assert.IsTrue(ws.Cell("B1").Style.Font.Bold);
}
- [TestMethod]
+ [Test]
public void InsertingColumnsBefore1()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet 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);
+ IXLColumn column1 = ws.Column(1);
+ IXLColumn column2 = ws.Column(2);
+ IXLColumn column3 = ws.Column(3);
- var columnIns = ws.Column(1).InsertColumnsBefore(1).First();
+ IXLColumn 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);
@@ -79,7 +73,6 @@
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);
@@ -99,22 +92,22 @@
Assert.AreEqual("X", column2.Cell(2).GetString());
}
- [TestMethod]
+ [Test]
public void InsertingColumnsBefore2()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet 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);
+ IXLColumn column1 = ws.Column(1);
+ IXLColumn column2 = ws.Column(2);
+ IXLColumn column3 = ws.Column(3);
- var columnIns = ws.Column(2).InsertColumnsBefore(1).First();
- var outputPath = System.IO.Path.Combine(TestHelper.TestsOutputDirectory,@"ForTesting\Sandbox.xlsx");
+ IXLColumn columnIns = ws.Column(2).InsertColumnsBefore(1).First();
+ string outputPath = Path.Combine(TestHelper.TestsOutputDirectory, @"ForTesting\Sandbox.xlsx");
wb.SaveAs(outputPath);
Assert.AreEqual(XLColor.Red, ws.Column(1).Cell(1).Style.Fill.BackgroundColor);
@@ -136,7 +129,6 @@
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);
@@ -156,21 +148,21 @@
Assert.AreEqual("X", column2.Cell(2).GetString());
}
- [TestMethod]
+ [Test]
public void InsertingColumnsBefore3()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet 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);
+ IXLColumn column1 = ws.Column(1);
+ IXLColumn column2 = ws.Column(2);
+ IXLColumn column3 = ws.Column(3);
- var columnIns = ws.Column(3).InsertColumnsBefore(1).First();
+ IXLColumn 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);
@@ -210,24 +202,28 @@
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()
+ [Test]
+ public void NoColumnsUsed()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue("Test").Style.Font.SetBold();
- ws.FirstColumn().CopyTo(ws.Column(2));
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
+ Int32 count = 0;
- Assert.IsTrue(ws.Cell("B1").Style.Font.Bold);
+ foreach (IXLColumn row in ws.ColumnsUsed())
+ count++;
+
+ foreach (IXLRangeColumn row in ws.Range("A1:C3").ColumnsUsed())
+ count++;
+
+ Assert.AreEqual(0, count);
+ }
+
+ [Test]
+ public void UngroupFromAll()
+ {
+ IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1");
+ ws.Columns(1, 2).Group();
+ ws.Columns(1, 2).Ungroup(true);
}
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Coordinates/XLAddressTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Coordinates/XLAddressTests.cs
index 86cf7b7..526ae67 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Coordinates/XLAddressTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Coordinates/XLAddressTests.cs
@@ -1,19 +1,17 @@
using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Linq;
-using System;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- [TestClass()]
+ [TestFixture]
public class XLAddressTests
{
- [TestMethod()]
+ [Test]
public void ToStringTest()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var address = ws.Cell(1, 1).Address;
-
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLAddress 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));
@@ -30,7 +28,5 @@
Assert.AreEqual("'Sheet1'!R1C1", address.ToStringFixed(XLReferenceStyle.R1C1, true));
Assert.AreEqual("'Sheet1'!$A$1", address.ToStringFixed(XLReferenceStyle.Default, true));
}
-
-
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/DataValidations/DataValidationTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/DataValidations/DataValidationTests.cs
index 923a287..4a31837 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/DataValidations/DataValidationTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/DataValidations/DataValidationTests.cs
@@ -1,60 +1,21 @@
-using System;
-using System.IO;
-using System.Text;
-using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel.DataValidations
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class DataValidationTests
{
- [TestMethod]
- public void Validation_persists_on_Worksheet_DataValidations()
- {
- var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("People");
-
- ws.FirstCell().SetValue("Categories")
- .CellBelow().SetValue("A");
-
- var table = ws.RangeUsed().CreateTable();
-
- var dv = table.DataRange.SetDataValidation();
- dv.ErrorTitle = "Error";
-
- Assert.AreEqual("Error", ws.DataValidations.Single().ErrorTitle);
- }
-
- [TestMethod]
- public void Validation_persists_on_Cell_DataValidation()
- {
- var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("People");
-
- ws.FirstCell().SetValue("Categories")
- .CellBelow().SetValue("A")
- .CellBelow().SetValue("B");
-
- var table = ws.RangeUsed().CreateTable();
-
- var dv = table.DataRange.SetDataValidation();
- dv.ErrorTitle = "Error";
-
- Assert.AreEqual("Error", table.DataRange.FirstCell().DataValidation.ErrorTitle);
- }
-
- [TestMethod]
+ [Test]
public void Validation_1()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Data Validation Issue");
- var cell = ws.Cell("E1");
+ IXLWorksheet ws = wb.Worksheets.Add("Data Validation Issue");
+ IXLCell cell = ws.Cell("E1");
cell.SetValue("Value 1");
cell = cell.CellBelow();
cell.SetValue("Value 2");
@@ -99,26 +60,26 @@
Assert.AreEqual(cell.DataValidation.InputMessage, "Message for D2");
}
- [TestMethod]
+ [Test]
public void Validation_2()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell("A1").SetValue("A");
ws.Cell("B1").SetDataValidation().Custom("Sheet1!A1");
- var ws2 = wb.AddWorksheet("Sheet2");
+ IXLWorksheet ws2 = wb.AddWorksheet("Sheet2");
ws2.Cell("A1").SetValue("B");
ws.Cell("B1").CopyTo(ws2.Cell("B1"));
Assert.AreEqual("Sheet1!A1", ws2.Cell("B1").DataValidation.Value);
}
- [TestMethod]
+ [Test]
public void Validation_3()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell("A1").SetValue("A");
ws.Cell("B1").SetDataValidation().Custom("A1");
ws.FirstRow().InsertRowsAbove(1);
@@ -126,22 +87,22 @@
Assert.AreEqual("A2", ws.Cell("B2").DataValidation.Value);
}
- [TestMethod]
+ [Test]
public void Validation_4()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell("A1").SetValue("A");
ws.Cell("B1").SetDataValidation().Custom("A1");
ws.Cell("B1").CopyTo(ws.Cell("B2"));
Assert.AreEqual("A2", ws.Cell("B2").DataValidation.Value);
}
- [TestMethod]
+ [Test]
public void Validation_5()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell("A1").SetValue("A");
ws.Cell("B1").SetDataValidation().Custom("A1");
ws.FirstColumn().InsertColumnsBefore(1);
@@ -149,15 +110,50 @@
Assert.AreEqual("B1", ws.Cell("C1").DataValidation.Value);
}
- [TestMethod]
+ [Test]
public void Validation_6()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell("A1").SetValue("A");
ws.Cell("B1").SetDataValidation().Custom("A1");
ws.Cell("B1").CopyTo(ws.Cell("C1"));
Assert.AreEqual("B1", ws.Cell("C1").DataValidation.Value);
}
+
+ [Test]
+ public void Validation_persists_on_Cell_DataValidation()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.Worksheets.Add("People");
+
+ ws.FirstCell().SetValue("Categories")
+ .CellBelow().SetValue("A")
+ .CellBelow().SetValue("B");
+
+ IXLTable table = ws.RangeUsed().CreateTable();
+
+ IXLDataValidation dv = table.DataRange.SetDataValidation();
+ dv.ErrorTitle = "Error";
+
+ Assert.AreEqual("Error", table.DataRange.FirstCell().DataValidation.ErrorTitle);
+ }
+
+ [Test]
+ public void Validation_persists_on_Worksheet_DataValidations()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.Worksheets.Add("People");
+
+ ws.FirstCell().SetValue("Categories")
+ .CellBelow().SetValue("A");
+
+ IXLTable table = ws.RangeUsed().CreateTable();
+
+ IXLDataValidation dv = table.DataRange.SetDataValidation();
+ dv.ErrorTitle = "Error";
+
+ Assert.AreEqual("Error", ws.DataValidations.Single().ErrorTitle);
+ }
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/CopyContentsTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/CopyContentsTests.cs
index 8a1fc72..ce055cc 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/CopyContentsTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/CopyContentsTests.cs
@@ -1,103 +1,59 @@
-using System;
-using System.IO;
-using System.Text;
-using System.Collections.Generic;
-using System.Linq;
+using System.Linq;
using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel.Misc
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
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)
+ private static void CopyRowAsRange(IXLWorksheet originalSheet, int originalRowNumber, IXLWorksheet destSheet,
+ int destRowNumber)
{
{
- var destinationRow = destSheet.Row(destRowNumber);
+ IXLRow destinationRow = destSheet.Row(destRowNumber);
destinationRow.Clear();
- var originalRow = originalSheet.Row(originalRowNumber);
+ IXLRow 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);
+ IXLRange originalRange = originalSheet.Range(originalRowNumber, 1, originalRowNumber, columnNumber);
+ IXLRange destRange = destSheet.Range(destRowNumber, 1, destRowNumber, columnNumber);
originalRange.CopyTo(destRange);
}
}
- [TestMethod]
+ [Test]
public void CopyConditionalFormatsCount()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet 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()
+ [Test]
+ public void CopyConditionalFormatsFixedNum()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet 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("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]
+ [Test]
public void CopyConditionalFormatsFixedString()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
ws.Cell("A1").Value = "A";
ws.Cell("B1").Value = "B";
ws.Cell("A1").AddConditionalFormat().WhenEquals("A").Fill.SetBackgroundColor(XLColor.Blue);
@@ -106,17 +62,58 @@
Assert.IsTrue(ws.ConditionalFormats.Any(cf => cf.Values.Any(v => v.Value.Value == "A" && !v.Value.IsFormula)));
}
- [TestMethod]
- public void CopyConditionalFormatsFixedNum()
+ [Test]
+ public void CopyConditionalFormatsFixedStringNum()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet 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("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)));
}
+
+ [Test]
+ public void CopyConditionalFormatsRelative()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet 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)));
+ }
+
+ [Test]
+ public void TestRowCopyContents()
+ {
+ var workbook = new XLWorkbook();
+ IXLWorksheet originalSheet = workbook.Worksheets.Add("original");
+ IXLWorksheet copyRowSheet = workbook.Worksheets.Add("copy row");
+ IXLWorksheet copyRowAsRangeSheet = workbook.Worksheets.Add("copy row as range");
+ IXLWorksheet copyRangeSheet = workbook.Worksheets.Add("copy range");
+
+ originalSheet.Cell("A2").SetValue("test value");
+ originalSheet.Range("A2:E2").Merge();
+
+ {
+ IXLRange originalRange = originalSheet.Range("A2:E2");
+ IXLRange destinationRange = copyRangeSheet.Range("A2:E2");
+
+ originalRange.CopyTo(destinationRange);
+ }
+ CopyRowAsRange(originalSheet, 2, copyRowAsRangeSheet, 3);
+ {
+ IXLRow originalRow = originalSheet.Row(2);
+ IXLRow destinationRow = copyRowSheet.Row(2);
+ copyRowSheet.Cell("G2").Value = "must be removed after copy";
+ originalRow.CopyTo(destinationRow);
+ }
+ TestHelper.SaveWorkbook(workbook, @"Misc\CopyRowContents.xlsx");
+ }
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/ExtensionsTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/ExtensionsTests.cs
index 34d4d80..89f2370 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/ExtensionsTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/ExtensionsTests.cs
@@ -1,20 +1,16 @@
using System;
-using System.Text;
-using System.Collections.Generic;
-using System.Linq;
using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class ExtensionsTests
{
-
- [TestMethod]
+ [Test]
public void FixNewLines()
{
Assert.AreEqual("\n".FixNewLines(), Environment.NewLine);
@@ -22,7 +18,5 @@
Assert.AreEqual("\rS\n".FixNewLines(), "\rS" + Environment.NewLine);
Assert.AreEqual("\r\n\n".FixNewLines(), Environment.NewLine + Environment.NewLine);
}
-
-
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/FormulaTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/FormulaTests.cs
index 394c64f..9d7cc15 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/FormulaTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/FormulaTests.cs
@@ -1,28 +1,22 @@
-using System;
-using System.Text;
-using System.Collections.Generic;
-using System.Linq;
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class FormulaTests
{
-
- [TestMethod]
+ [Test]
public void CopyFormula()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell("A1").FormulaA1 = "B1";
ws.Cell("A1").CopyTo("A2");
Assert.AreEqual("B2", ws.Cell("A2").FormulaA1);
}
-
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/StylesTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/StylesTests.cs
index 44194a5..a00a47e 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/StylesTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/StylesTests.cs
@@ -1,32 +1,46 @@
-using System;
-using System.IO;
-using System.Text;
-using System.Collections.Generic;
-using System.Linq;
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel.Misc
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class StylesTests
{
- [TestMethod]
+ 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;
+ }
+
+ [Test]
public void InsideBorderTest()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- var range = ws.Range("B2:D4");
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ IXLRange 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);
+ IXLCell center = range.Cell(2, 2);
Assert.AreEqual(XLColor.Red, center.Style.Border.TopBorderColor);
Assert.AreEqual(XLColor.Red, center.Style.Border.BottomBorderColor);
@@ -49,25 +63,5 @@
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;
- }
-
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/XLWorkbookTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/XLWorkbookTests.cs
index 2dac212..601bc06 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/XLWorkbookTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/XLWorkbookTests.cs
@@ -1,263 +1,259 @@
using System;
-using System.Text;
-using System.Collections.Generic;
using System.Linq;
using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class XLWorkbookTests
{
+ [Test]
+ public void Cell1()
+ {
+ var wb = new XLWorkbook();
+ IXLCell cell = wb.Cell("ABC");
+ Assert.IsNull(cell);
+ }
- [TestMethod]
+ [Test]
+ public void Cell2()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet);
+ IXLCell cell = wb.Cell("Sheet1!Result");
+ Assert.IsNotNull(cell);
+ Assert.AreEqual(1, cell.GetValue());
+ }
+
+ [Test]
+ public void Cell3()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue(1).AddToNamed("Result");
+ IXLCell cell = wb.Cell("Sheet1!Result");
+ Assert.IsNotNull(cell);
+ Assert.AreEqual(1, cell.GetValue());
+ }
+
+ [Test]
+ public void Cells1()
+ {
+ var wb = new XLWorkbook();
+ IXLCells cells = wb.Cells("ABC");
+ Assert.IsNotNull(cells);
+ Assert.AreEqual(0, cells.Count());
+ }
+
+ [Test]
+ public void Cells2()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet);
+ IXLCells cells = wb.Cells("Sheet1!Result, ABC");
+ Assert.IsNotNull(cells);
+ Assert.AreEqual(1, cells.Count());
+ Assert.AreEqual(1, cells.First().GetValue());
+ }
+
+ [Test]
+ public void Cells3()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue(1).AddToNamed("Result");
+ IXLCells cells = wb.Cells("Sheet1!Result, ABC");
+ Assert.IsNotNull(cells);
+ Assert.AreEqual(1, cells.Count());
+ Assert.AreEqual(1, cells.First().GetValue());
+ }
+
+ [Test]
+ public void NamedRange1()
+ {
+ var wb = new XLWorkbook();
+ IXLNamedRange range = wb.NamedRange("ABC");
+ Assert.IsNull(range);
+ }
+
+ [Test]
+ public void NamedRange2()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet);
+ IXLNamedRange range = wb.NamedRange("Sheet1!Result");
+ Assert.IsNotNull(range);
+ Assert.AreEqual(1, range.Ranges.Count);
+ Assert.AreEqual(1, range.Ranges.Cells().Count());
+ Assert.AreEqual(1, range.Ranges.First().FirstCell().GetValue());
+ }
+
+ [Test]
+ public void NamedRange3()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ IXLNamedRange range = wb.NamedRange("Sheet1!Result");
+ Assert.IsNull(range);
+ }
+
+ [Test]
+ public void NamedRange4()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue(1).AddToNamed("Result");
+ IXLNamedRange range = wb.NamedRange("Sheet1!Result");
+ Assert.IsNotNull(range);
+ Assert.AreEqual(1, range.Ranges.Count);
+ Assert.AreEqual(1, range.Ranges.Cells().Count());
+ Assert.AreEqual(1, range.Ranges.First().FirstCell().GetValue());
+ }
+
+ [Test]
+ public void Range1()
+ {
+ var wb = new XLWorkbook();
+ IXLRange range = wb.Range("ABC");
+ Assert.IsNull(range);
+ }
+
+ [Test]
+ public void Range2()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet);
+ IXLRange range = wb.Range("Sheet1!Result");
+ Assert.IsNotNull(range);
+ Assert.AreEqual(1, range.Cells().Count());
+ Assert.AreEqual(1, range.FirstCell().GetValue());
+ }
+
+ [Test]
+ public void Range3()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue(1).AddToNamed("Result");
+ IXLRange range = wb.Range("Sheet1!Result");
+ Assert.IsNotNull(range);
+ Assert.AreEqual(1, range.Cells().Count());
+ Assert.AreEqual(1, range.FirstCell().GetValue());
+ }
+
+ [Test]
+ public void Ranges1()
+ {
+ var wb = new XLWorkbook();
+ IXLRanges ranges = wb.Ranges("ABC");
+ Assert.IsNotNull(ranges);
+ Assert.AreEqual(0, ranges.Count());
+ }
+
+ [Test]
+ public void Ranges2()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet);
+ IXLRanges ranges = wb.Ranges("Sheet1!Result, ABC");
+ Assert.IsNotNull(ranges);
+ Assert.AreEqual(1, ranges.Cells().Count());
+ Assert.AreEqual(1, ranges.First().FirstCell().GetValue());
+ }
+
+ [Test]
+ public void Ranges3()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue(1).AddToNamed("Result");
+ IXLRanges ranges = wb.Ranges("Sheet1!Result, ABC");
+ Assert.IsNotNull(ranges);
+ Assert.AreEqual(1, ranges.Cells().Count());
+ Assert.AreEqual(1, ranges.First().FirstCell().GetValue());
+ }
+
+ [Test]
public void WbNamedCell()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell(1, 1).SetValue("Test").AddToNamed("TestCell");
Assert.AreEqual("Test", wb.Cell("TestCell").GetString());
Assert.AreEqual("Test", ws.Cell("TestCell").GetString());
}
- [TestMethod]
+ [Test]
public void WbNamedCells()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell(1, 1).SetValue("Test").AddToNamed("TestCell");
ws.Cell(2, 1).SetValue("B").AddToNamed("Test2");
- var wbCells = wb.Cells("TestCell, Test2");
+ IXLCells wbCells = wb.Cells("TestCell, Test2");
Assert.AreEqual("Test", wbCells.First().GetString());
Assert.AreEqual("B", wbCells.Last().GetString());
- var wsCells = ws.Cells("TestCell, Test2");
+ IXLCells wsCells = ws.Cells("TestCell, Test2");
Assert.AreEqual("Test", wsCells.First().GetString());
Assert.AreEqual("B", wsCells.Last().GetString());
-
}
- [TestMethod]
+ [Test]
public void WbNamedRange()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell(1, 1).SetValue("A");
ws.Cell(2, 1).SetValue("B");
- var original = ws.Range("A1:A2");
+ IXLRange original = ws.Range("A1:A2");
original.AddToNamed("TestRange");
Assert.AreEqual(original.RangeAddress.ToStringFixed(), wb.Range("TestRange").RangeAddress.ToString());
Assert.AreEqual(original.RangeAddress.ToStringFixed(), ws.Range("TestRange").RangeAddress.ToString());
}
- [TestMethod]
+ [Test]
public void WbNamedRanges()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell(1, 1).SetValue("A");
ws.Cell(2, 1).SetValue("B");
ws.Cell(3, 1).SetValue("C").AddToNamed("Test2");
- var original = ws.Range("A1:A2");
+ IXLRange original = ws.Range("A1:A2");
original.AddToNamed("TestRange");
- var wbRanges = wb.Ranges("TestRange, Test2");
+ IXLRanges wbRanges = wb.Ranges("TestRange, Test2");
Assert.AreEqual(original.RangeAddress.ToStringFixed(), wbRanges.First().RangeAddress.ToString());
Assert.AreEqual("$A$3:$A$3", wbRanges.Last().RangeAddress.ToStringFixed());
- var wsRanges = wb.Ranges("TestRange, Test2");
+ IXLRanges wsRanges = wb.Ranges("TestRange, Test2");
Assert.AreEqual(original.RangeAddress.ToStringFixed(), wsRanges.First().RangeAddress.ToString());
Assert.AreEqual("$A$3:$A$3", wsRanges.Last().RangeAddress.ToStringFixed());
}
- [TestMethod]
+ [Test]
public void WbNamedRangesOneString()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
wb.NamedRanges.Add("TestRange", "Sheet1!$A$1,Sheet1!$A$3");
- var wbRanges = ws.Ranges("TestRange");
+ IXLRanges wbRanges = ws.Ranges("TestRange");
Assert.AreEqual("$A$1:$A$1", wbRanges.First().RangeAddress.ToStringFixed());
Assert.AreEqual("$A$3:$A$3", wbRanges.Last().RangeAddress.ToStringFixed());
- var wsRanges = ws.Ranges("TestRange");
+ IXLRanges wsRanges = ws.Ranges("TestRange");
Assert.AreEqual("$A$1:$A$1", wsRanges.First().RangeAddress.ToStringFixed());
Assert.AreEqual("$A$3:$A$3", wsRanges.Last().RangeAddress.ToStringFixed());
}
-
- [TestMethod]
- public void Cell1()
- {
- var wb = new XLWorkbook();
- var cell = wb.Cell("ABC");
- Assert.IsNull(cell);
- }
-
- [TestMethod]
- public void Cell2()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet);
- var cell = wb.Cell("Sheet1!Result");
- Assert.IsNotNull(cell);
- Assert.AreEqual(1, cell.GetValue());
- }
-
- [TestMethod]
- public void Cell3()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue(1).AddToNamed("Result");
- var cell = wb.Cell("Sheet1!Result");
- Assert.IsNotNull(cell);
- Assert.AreEqual(1, cell.GetValue());
- }
-
- [TestMethod]
- public void NamedRange1()
- {
- var wb = new XLWorkbook();
- var range = wb.NamedRange("ABC");
- Assert.IsNull(range);
- }
-
- [TestMethod]
- public void NamedRange2()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet);
- var range = wb.NamedRange("Sheet1!Result");
- Assert.IsNotNull(range);
- Assert.AreEqual(1, range.Ranges.Count);
- Assert.AreEqual(1, range.Ranges.Cells().Count());
- Assert.AreEqual(1, range.Ranges.First().FirstCell().GetValue());
- }
-
- [TestMethod]
- public void NamedRange3()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- var range = wb.NamedRange("Sheet1!Result");
- Assert.IsNull(range);
- }
-
- [TestMethod]
- public void NamedRange4()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue(1).AddToNamed("Result");
- var range = wb.NamedRange("Sheet1!Result");
- Assert.IsNotNull(range);
- Assert.AreEqual(1, range.Ranges.Count);
- Assert.AreEqual(1, range.Ranges.Cells().Count());
- Assert.AreEqual(1, range.Ranges.First().FirstCell().GetValue());
- }
-
- [TestMethod]
- public void Range1()
- {
- var wb = new XLWorkbook();
- var range = wb.Range("ABC");
- Assert.IsNull(range);
- }
-
- [TestMethod]
- public void Range2()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet);
- var range = wb.Range("Sheet1!Result");
- Assert.IsNotNull(range);
- Assert.AreEqual(1, range.Cells().Count());
- Assert.AreEqual(1, range.FirstCell().GetValue());
- }
-
- [TestMethod]
- public void Range3()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue(1).AddToNamed("Result");
- var range = wb.Range("Sheet1!Result");
- Assert.IsNotNull(range);
- Assert.AreEqual(1, range.Cells().Count());
- Assert.AreEqual(1, range.FirstCell().GetValue());
- }
-
- [TestMethod]
- public void Ranges1()
- {
- var wb = new XLWorkbook();
- var ranges = wb.Ranges("ABC");
- Assert.IsNotNull(ranges);
- Assert.AreEqual(0, ranges.Count());
- }
-
- [TestMethod]
- public void Ranges2()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet);
- var ranges = wb.Ranges("Sheet1!Result, ABC");
- Assert.IsNotNull(ranges);
- Assert.AreEqual(1, ranges.Cells().Count());
- Assert.AreEqual(1, ranges.First().FirstCell().GetValue());
- }
-
- [TestMethod]
- public void Ranges3()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue(1).AddToNamed("Result");
- var ranges = wb.Ranges("Sheet1!Result, ABC");
- Assert.IsNotNull(ranges);
- Assert.AreEqual(1, ranges.Cells().Count());
- Assert.AreEqual(1, ranges.First().FirstCell().GetValue());
- }
-
- [TestMethod]
- public void Cells1()
- {
- var wb = new XLWorkbook();
- var cells = wb.Cells("ABC");
- Assert.IsNotNull(cells);
- Assert.AreEqual(0, cells.Count());
- }
-
- [TestMethod]
- public void Cells2()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue(1).AddToNamed("Result", XLScope.Worksheet);
- var cells = wb.Cells("Sheet1!Result, ABC");
- Assert.IsNotNull(cells);
- Assert.AreEqual(1, cells.Count());
- Assert.AreEqual(1, cells.First().GetValue());
- }
-
- [TestMethod]
- public void Cells3()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue(1).AddToNamed("Result");
- var cells = wb.Cells("Sheet1!Result, ABC");
- Assert.IsNotNull(cells);
- Assert.AreEqual(1, cells.Count());
- Assert.AreEqual(1, cells.First().GetValue());
- }
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/XlHelperTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/XlHelperTests.cs
index 411074a..98e4685 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/XlHelperTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Misc/XlHelperTests.cs
@@ -1,60 +1,20 @@
-using System;
-using System.Text;
-using System.Collections.Generic;
-using System.Linq;
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
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]
+ [Test]
public void InvalidA1Addresses()
{
Assert.IsFalse(XLHelper.IsValidA1Address(""));
@@ -95,5 +55,41 @@
Assert.IsFalse(XLHelper.IsValidA1Address("{AA1{"));
Assert.IsFalse(XLHelper.IsValidA1Address("{AAA1{"));
}
+
+ [Test]
+ public void PlusAA1_Is_Not_an_address()
+ {
+ Assert.IsFalse(XLHelper.IsValidA1Address("+AA1"));
+ }
+
+ [Test]
+ public void TestConvertColumnLetterToNumberAnd()
+ {
+ CheckColumnNumber(1);
+ CheckColumnNumber(27);
+ CheckColumnNumber(28);
+ CheckColumnNumber(52);
+ CheckColumnNumber(53);
+ CheckColumnNumber(1000);
+ }
+
+ [Test]
+ 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));
+ }
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/NamedRanges/NamedRangesTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/NamedRanges/NamedRangesTests.cs
index 88955f6..be482fb 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/NamedRanges/NamedRangesTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/NamedRanges/NamedRangesTests.cs
@@ -1,29 +1,28 @@
using System;
-using ClosedXML.Excel;
using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class NamedRangesTests
{
-
- [TestMethod]
+ [Test]
public void MovingRanges()
{
var wb = new XLWorkbook();
- var sheet1 = wb.Worksheets.Add("Sheet1");
- var sheet2 = wb.Worksheets.Add("Sheet2");
+ IXLWorksheet sheet1 = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet sheet2 = wb.Worksheets.Add("Sheet2");
wb.NamedRanges.Add("wbNamedRange",
- "Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G");
+ "Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G");
sheet1.NamedRanges.Add("sheet1NamedRange",
- "Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G");
+ "Sheet1!$B$2,Sheet1!$B$3:$C$3,Sheet2!$D$3:$D$4,Sheet1!$6:$7,Sheet1!$F:$G");
sheet2.NamedRanges.Add("sheet2NamedRange", "Sheet1!A1,Sheet2!A1");
sheet1.Row(1).InsertRowsAbove(2);
@@ -32,39 +31,42 @@
sheet1.Column(1).Delete();
- Assert.AreEqual("'Sheet1'!$C$3,'Sheet1'!$C$4:$D$4,Sheet2!$D$3:$D$4,'Sheet1'!$7:$8,'Sheet1'!$G:$H", wb.NamedRanges.First().RefersTo);
- Assert.AreEqual("'Sheet1'!$C$3,'Sheet1'!$C$4:$D$4,Sheet2!$D$3:$D$4,'Sheet1'!$7:$8,'Sheet1'!$G:$H", sheet1.NamedRanges.First().RefersTo);
+ Assert.AreEqual("'Sheet1'!$C$3,'Sheet1'!$C$4:$D$4,Sheet2!$D$3:$D$4,'Sheet1'!$7:$8,'Sheet1'!$G:$H",
+ wb.NamedRanges.First().RefersTo);
+ Assert.AreEqual("'Sheet1'!$C$3,'Sheet1'!$C$4:$D$4,Sheet2!$D$3:$D$4,'Sheet1'!$7:$8,'Sheet1'!$G:$H",
+ sheet1.NamedRanges.First().RefersTo);
Assert.AreEqual("'Sheet1'!B2,Sheet2!A1", sheet2.NamedRanges.First().RefersTo);
}
- [TestMethod]
- public void WorksheetContainsNamedRange()
+ [Test]
+ public void WbContainsWsNamedRange()
{
- var ws = new XLWorkbook().AddWorksheet("Sheet1");
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
ws.FirstCell().AddToNamed("Name", XLScope.Worksheet);
- Assert.IsTrue(ws.NamedRanges.Contains("Name"));
- Assert.IsFalse(ws.NamedRanges.Contains("NameX"));
+ Assert.IsTrue(wb.NamedRanges.Contains("Sheet1!Name"));
+ Assert.IsFalse(wb.NamedRanges.Contains("Sheet1!NameX"));
- Assert.IsNotNull(ws.NamedRange("Name"));
- Assert.IsNull(ws.NamedRange("NameX"));
+ Assert.IsNotNull(wb.NamedRange("Sheet1!Name"));
+ Assert.IsNull(wb.NamedRange("Sheet1!NameX"));
IXLNamedRange range1;
- Boolean result1 = ws.NamedRanges.TryGetValue("Name", out range1);
+ Boolean result1 = wb.NamedRanges.TryGetValue("Sheet1!Name", out range1);
Assert.IsTrue(result1);
Assert.IsNotNull(range1);
IXLNamedRange range2;
- Boolean result2 = ws.NamedRanges.TryGetValue("NameX", out range2);
+ Boolean result2 = wb.NamedRanges.TryGetValue("Sheet1!NameX", out range2);
Assert.IsFalse(result2);
Assert.IsNull(range2);
}
- [TestMethod]
+ [Test]
public void WorkbookContainsNamedRange()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
ws.FirstCell().AddToNamed("Name");
Assert.IsTrue(wb.NamedRanges.Contains("Name"));
@@ -84,28 +86,27 @@
Assert.IsNull(range2);
}
- [TestMethod]
- public void WbContainsWsNamedRange()
+ [Test]
+ public void WorksheetContainsNamedRange()
{
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1");
ws.FirstCell().AddToNamed("Name", XLScope.Worksheet);
- Assert.IsTrue(wb.NamedRanges.Contains("Sheet1!Name"));
- Assert.IsFalse(wb.NamedRanges.Contains("Sheet1!NameX"));
+ Assert.IsTrue(ws.NamedRanges.Contains("Name"));
+ Assert.IsFalse(ws.NamedRanges.Contains("NameX"));
- Assert.IsNotNull(wb.NamedRange("Sheet1!Name"));
- Assert.IsNull(wb.NamedRange("Sheet1!NameX"));
+ Assert.IsNotNull(ws.NamedRange("Name"));
+ Assert.IsNull(ws.NamedRange("NameX"));
IXLNamedRange range1;
- Boolean result1 = wb.NamedRanges.TryGetValue("Sheet1!Name", out range1);
+ Boolean result1 = ws.NamedRanges.TryGetValue("Name", out range1);
Assert.IsTrue(result1);
Assert.IsNotNull(range1);
IXLNamedRange range2;
- Boolean result2 = wb.NamedRanges.TryGetValue("Sheet1!NameX", out range2);
+ Boolean result2 = ws.NamedRanges.TryGetValue("NameX", out range2);
Assert.IsFalse(result2);
Assert.IsNull(range2);
}
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/PivotTables/XLPivotTableTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/PivotTables/XLPivotTableTests.cs
index 5c3c76f..dadb7f9 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/PivotTables/XLPivotTableTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/PivotTables/XLPivotTableTests.cs
@@ -1,20 +1,16 @@
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Linq;
-using System;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- [TestClass()]
+ [TestFixture]
public class XLPivotTableTests
{
- //[TestMethod()]
+ //[Test]
//public void CreateTable()
//{
// var ws = new XLWorkbook().Worksheets.Add("Sheet1");
-
-
- //}
+
+ //}
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/CopyingRangesTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/CopyingRangesTests.cs
index a24fcdd..99c9aaf 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/CopyingRangesTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/CopyingRangesTests.cs
@@ -1,59 +1,19 @@
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Linq;
-using System;
-using System.IO;
-using System.Drawing;
+using System.Drawing;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- [TestClass]
+ [TestFixture]
public class CopyingRangesTests
{
- [TestMethod]
- public void CopyingRows()
- {
- var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet");
-
- var row1 = ws.Row(1);
- row1.Cell(1).Style.Fill.SetBackgroundColor(XLColor.Red);
- row1.Cell(2).Style.Fill.SetBackgroundColor(XLColor.FromArgb(1,1,1));
- row1.Cell(3).Style.Fill.SetBackgroundColor(XLColor.FromHtml("#CCCCCC"));
- row1.Cell(4).Style.Fill.SetBackgroundColor(XLColor.FromIndex(26));
- row1.Cell(5).Style.Fill.SetBackgroundColor(XLColor.FromKnownColor(KnownColor.MediumSeaGreen));
- row1.Cell(6).Style.Fill.SetBackgroundColor(XLColor.FromName("Blue"));
- row1.Cell(7).Style.Fill.SetBackgroundColor(XLColor.FromTheme(XLThemeColor.Accent3));
-
- ws.Cell(2, 1).Value = row1;
- ws.Cell(3, 1).Value = row1.Row(1, 7);
-
- var row2 = ws.Row(2);
- Assert.AreEqual(XLColor.Red, row2.Cell(1).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromArgb(1, 1, 1), row2.Cell(2).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromHtml("#CCCCCC"), row2.Cell(3).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromIndex(26), row2.Cell(4).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromKnownColor(KnownColor.MediumSeaGreen), row2.Cell(5).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromName("Blue"), row2.Cell(6).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromTheme(XLThemeColor.Accent3), row2.Cell(7).Style.Fill.BackgroundColor);
-
- var row3 = ws.Row(3);
- Assert.AreEqual(XLColor.Red, row3.Cell(1).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromArgb(1, 1, 1), row3.Cell(2).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromHtml("#CCCCCC"), row3.Cell(3).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromIndex(26), row3.Cell(4).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromKnownColor(KnownColor.MediumSeaGreen), row3.Cell(5).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromName("Blue"), row3.Cell(6).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromTheme(XLThemeColor.Accent3), row3.Cell(7).Style.Fill.BackgroundColor);
- }
-
- [TestMethod]
+ [Test]
public void CopyingColumns()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet");
- var column1 = ws.Column(1);
+ IXLColumn column1 = ws.Column(1);
column1.Cell(1).Style.Fill.SetBackgroundColor(XLColor.Red);
column1.Cell(2).Style.Fill.SetBackgroundColor(XLColor.FromArgb(1, 1, 1));
column1.Cell(3).Style.Fill.SetBackgroundColor(XLColor.FromHtml("#CCCCCC"));
@@ -65,25 +25,62 @@
ws.Cell(1, 2).Value = column1;
ws.Cell(1, 3).Value = column1.Column(1, 7);
- var column2 = ws.Column(2);
+ IXLColumn column2 = ws.Column(2);
Assert.AreEqual(XLColor.Red, column2.Cell(1).Style.Fill.BackgroundColor);
Assert.AreEqual(XLColor.FromArgb(1, 1, 1), column2.Cell(2).Style.Fill.BackgroundColor);
Assert.AreEqual(XLColor.FromHtml("#CCCCCC"), column2.Cell(3).Style.Fill.BackgroundColor);
Assert.AreEqual(XLColor.FromIndex(26), column2.Cell(4).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromKnownColor(KnownColor.MediumSeaGreen), column2.Cell(5).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromKnownColor(KnownColor.MediumSeaGreen),
+ column2.Cell(5).Style.Fill.BackgroundColor);
Assert.AreEqual(XLColor.FromName("Blue"), column2.Cell(6).Style.Fill.BackgroundColor);
Assert.AreEqual(XLColor.FromTheme(XLThemeColor.Accent3), column2.Cell(7).Style.Fill.BackgroundColor);
- var column3 = ws.Column(3);
+ IXLColumn column3 = ws.Column(3);
Assert.AreEqual(XLColor.Red, column3.Cell(1).Style.Fill.BackgroundColor);
Assert.AreEqual(XLColor.FromArgb(1, 1, 1), column3.Cell(2).Style.Fill.BackgroundColor);
Assert.AreEqual(XLColor.FromHtml("#CCCCCC"), column3.Cell(3).Style.Fill.BackgroundColor);
Assert.AreEqual(XLColor.FromIndex(26), column3.Cell(4).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FromKnownColor(KnownColor.MediumSeaGreen), column3.Cell(5).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromKnownColor(KnownColor.MediumSeaGreen),
+ column3.Cell(5).Style.Fill.BackgroundColor);
Assert.AreEqual(XLColor.FromName("Blue"), column3.Cell(6).Style.Fill.BackgroundColor);
Assert.AreEqual(XLColor.FromTheme(XLThemeColor.Accent3), column3.Cell(7).Style.Fill.BackgroundColor);
}
+ [Test]
+ public void CopyingRows()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet");
+ IXLRow row1 = ws.Row(1);
+ row1.Cell(1).Style.Fill.SetBackgroundColor(XLColor.Red);
+ row1.Cell(2).Style.Fill.SetBackgroundColor(XLColor.FromArgb(1, 1, 1));
+ row1.Cell(3).Style.Fill.SetBackgroundColor(XLColor.FromHtml("#CCCCCC"));
+ row1.Cell(4).Style.Fill.SetBackgroundColor(XLColor.FromIndex(26));
+ row1.Cell(5).Style.Fill.SetBackgroundColor(XLColor.FromKnownColor(KnownColor.MediumSeaGreen));
+ row1.Cell(6).Style.Fill.SetBackgroundColor(XLColor.FromName("Blue"));
+ row1.Cell(7).Style.Fill.SetBackgroundColor(XLColor.FromTheme(XLThemeColor.Accent3));
+
+ ws.Cell(2, 1).Value = row1;
+ ws.Cell(3, 1).Value = row1.Row(1, 7);
+
+ IXLRow row2 = ws.Row(2);
+ Assert.AreEqual(XLColor.Red, row2.Cell(1).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromArgb(1, 1, 1), row2.Cell(2).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromHtml("#CCCCCC"), row2.Cell(3).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromIndex(26), row2.Cell(4).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromKnownColor(KnownColor.MediumSeaGreen), row2.Cell(5).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromName("Blue"), row2.Cell(6).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromTheme(XLThemeColor.Accent3), row2.Cell(7).Style.Fill.BackgroundColor);
+
+ IXLRow row3 = ws.Row(3);
+ Assert.AreEqual(XLColor.Red, row3.Cell(1).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromArgb(1, 1, 1), row3.Cell(2).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromHtml("#CCCCCC"), row3.Cell(3).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromIndex(26), row3.Cell(4).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromKnownColor(KnownColor.MediumSeaGreen), row3.Cell(5).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromName("Blue"), row3.Cell(6).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FromTheme(XLThemeColor.Accent3), row3.Cell(7).Style.Fill.BackgroundColor);
+ }
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/InsertingRangesTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/InsertingRangesTests.cs
index 75a0f71..dcda221 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/InsertingRangesTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/InsertingRangesTests.cs
@@ -1,52 +1,21 @@
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Linq;
-using System;
-using System.IO;
+using System.Linq;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- [TestClass()]
+ [TestFixture]
public class InsertingRangesTests
{
- [TestMethod]
- public void InsertingRowsPreservesFormatting()
- {
- var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet");
- var row1 = ws.Row(1);
- row1.Style.Fill.SetBackgroundColor(XLColor.FrenchLilac);
- row1.Cell(2).Style.Fill.SetBackgroundColor(XLColor.Fulvous);
- var row2 = ws.Row(2);
- row2.Style.Fill.SetBackgroundColor(XLColor.Xanadu);
- row2.Cell(2).Style.Fill.SetBackgroundColor(XLColor.MacaroniAndCheese);
-
- row1.InsertRowsBelow(1);
- row1.InsertRowsAbove(1);
- row2.InsertRowsAbove(1);
-
- Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Row(1).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FrenchLilac, ws.Row(2).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FrenchLilac, ws.Row(3).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.FrenchLilac, ws.Row(4).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.Xanadu, ws.Row(5).Style.Fill.BackgroundColor);
-
- Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Cell(1, 2).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.Fulvous, ws.Cell(2, 2).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.Fulvous, ws.Cell(3, 2).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.Fulvous, ws.Cell(4, 2).Style.Fill.BackgroundColor);
- Assert.AreEqual(XLColor.MacaroniAndCheese, ws.Cell(5, 2).Style.Fill.BackgroundColor);
- }
-
- [TestMethod]
+ [Test]
public void InsertingColumnsPreservesFormatting()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet");
- var column1 = ws.Column(1);
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet");
+ IXLColumn column1 = ws.Column(1);
column1.Style.Fill.SetBackgroundColor(XLColor.FrenchLilac);
column1.Cell(2).Style.Fill.SetBackgroundColor(XLColor.Fulvous);
- var column2 = ws.Column(2);
+ IXLColumn column2 = ws.Column(2);
column2.Style.Fill.SetBackgroundColor(XLColor.Xanadu);
column2.Cell(2).Style.Fill.SetBackgroundColor(XLColor.MacaroniAndCheese);
@@ -67,21 +36,50 @@
Assert.AreEqual(XLColor.MacaroniAndCheese, ws.Cell(2, 5).Style.Fill.BackgroundColor);
}
- [TestMethod]
+ [Test]
public void InsertingRowsAbove()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet");
ws.Cell("B3").SetValue("X")
.CellBelow().SetValue("B");
- var r = ws.Range("B4").InsertRowsAbove(1).First();
+ IXLRangeRow r = ws.Range("B4").InsertRowsAbove(1).First();
r.Cell(1).SetValue("A");
Assert.AreEqual("X", ws.Cell("B3").GetString());
Assert.AreEqual("A", ws.Cell("B4").GetString());
Assert.AreEqual("B", ws.Cell("B5").GetString());
}
+
+ [Test]
+ public void InsertingRowsPreservesFormatting()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet");
+ IXLRow row1 = ws.Row(1);
+ row1.Style.Fill.SetBackgroundColor(XLColor.FrenchLilac);
+ row1.Cell(2).Style.Fill.SetBackgroundColor(XLColor.Fulvous);
+ IXLRow row2 = ws.Row(2);
+ row2.Style.Fill.SetBackgroundColor(XLColor.Xanadu);
+ row2.Cell(2).Style.Fill.SetBackgroundColor(XLColor.MacaroniAndCheese);
+
+ row1.InsertRowsBelow(1);
+ row1.InsertRowsAbove(1);
+ row2.InsertRowsAbove(1);
+
+ Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Row(1).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FrenchLilac, ws.Row(2).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FrenchLilac, ws.Row(3).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.FrenchLilac, ws.Row(4).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.Xanadu, ws.Row(5).Style.Fill.BackgroundColor);
+
+ Assert.AreEqual(ws.Style.Fill.BackgroundColor, ws.Cell(1, 2).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.Fulvous, ws.Cell(2, 2).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.Fulvous, ws.Cell(3, 2).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.Fulvous, ws.Cell(4, 2).Style.Fill.BackgroundColor);
+ Assert.AreEqual(XLColor.MacaroniAndCheese, ws.Cell(5, 2).Style.Fill.BackgroundColor);
+ }
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/MergedRangesTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/MergedRangesTests.cs
index efa7a75..fad6c2e 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/MergedRangesTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/MergedRangesTests.cs
@@ -1,29 +1,23 @@
using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Linq;
-using System;
-using System.IO;
-using System.Drawing;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- [TestClass]
+ [TestFixture]
public class MergedRangesTests
{
- [TestMethod]
+ [Test]
public void LastCellFromMerge()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet");
ws.Range("B2:D4").Merge();
- var first = ws.FirstCellUsed(true).Address.ToStringRelative();
- var last = ws.LastCellUsed(true).Address.ToStringRelative();
-
+ string first = ws.FirstCellUsed(true).Address.ToStringRelative();
+ string last = ws.LastCellUsed(true).Address.ToStringRelative();
+
Assert.AreEqual("B2", first);
Assert.AreEqual("D4", last);
}
-
-
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/RangeUsedTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/RangeUsedTests.cs
index f55b0ae..7e6e693 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/RangeUsedTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/RangeUsedTests.cs
@@ -1,23 +1,16 @@
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Linq;
-using System;
-using System.IO;
-using System.Drawing;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- [TestClass]
+ [TestFixture]
public class RangeUsedTests
{
- //[TestMethod]
+ //[Test]
//public void FirstLastRows()
//{
// var wb = new XLWorkbook();
// var ws = wb.Worksheets.Add("Sheet");
-
+
//}
-
-
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeAddressTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeAddressTests.cs
index 60aaf9f..f4e223a 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeAddressTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeAddressTests.cs
@@ -1,19 +1,17 @@
using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Linq;
-using System;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- [TestClass()]
+ [TestFixture]
public class XLRangeAddressTests
{
- [TestMethod()]
+ [Test]
public void ToStringTest()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var address = ws.Cell(1, 1).AsRange().RangeAddress;
-
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRangeAddress address = ws.Cell(1, 1).AsRange().RangeAddress;
+
Assert.AreEqual("A1:A1", address.ToString());
Assert.AreEqual("A1:A1", address.ToStringRelative());
@@ -27,7 +25,5 @@
Assert.AreEqual("'Sheet1'!R1C1:R1C1", address.ToStringFixed(XLReferenceStyle.R1C1, true));
Assert.AreEqual("'Sheet1'!$A$1:$A$1", address.ToStringFixed(XLReferenceStyle.Default, true));
}
-
-
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeBaseTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeBaseTests.cs
index d420d4f..c90f624 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeBaseTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Ranges/XLRangeBaseTests.cs
@@ -1,176 +1,176 @@
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
using System.Linq;
-using System;
-using System.IO;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- [TestClass()]
+ [TestFixture]
public class XLRangeBaseTests
{
- [TestMethod()]
+ [Test]
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;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ IXLRange range = ws.Range("A1:B2");
+ bool actual = range.IsEmpty();
+ bool expected = true;
Assert.AreEqual(expected, actual);
}
- [TestMethod()]
+ [Test]
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;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ IXLRange range = ws.Range("A1:B2");
+ bool actual = range.IsEmpty(true);
+ bool expected = true;
Assert.AreEqual(expected, actual);
}
- [TestMethod()]
+ [Test]
public void IsEmpty3()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var cell = ws.Cell(1, 1);
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
cell.Style.Fill.BackgroundColor = XLColor.Red;
- var range = ws.Range("A1:B2");
- var actual = range.IsEmpty();
- var expected = true;
+ IXLRange range = ws.Range("A1:B2");
+ bool actual = range.IsEmpty();
+ bool expected = true;
Assert.AreEqual(expected, actual);
}
- [TestMethod()]
+ [Test]
public void IsEmpty4()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var cell = ws.Cell(1, 1);
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell 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;
+ IXLRange range = ws.Range("A1:B2");
+ bool actual = range.IsEmpty(false);
+ bool expected = true;
Assert.AreEqual(expected, actual);
}
- [TestMethod()]
+ [Test]
public void IsEmpty5()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var cell = ws.Cell(1, 1);
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell 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;
+ IXLRange range = ws.Range("A1:B2");
+ bool actual = range.IsEmpty(true);
+ bool expected = false;
Assert.AreEqual(expected, actual);
}
- [TestMethod()]
+ [Test]
public void IsEmpty6()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var cell = ws.Cell(1, 1);
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
cell.Value = "X";
- var range = ws.Range("A1:B2");
- var actual = range.IsEmpty();
- var expected = false;
+ IXLRange range = ws.Range("A1:B2");
+ bool actual = range.IsEmpty();
+ bool 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]
+ [Test]
public void SingleCell()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet 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() );
+ IXLRange range = wb.Range("SingleCell");
+ Assert.AreEqual(1, range.CellsUsed().Count());
Assert.AreEqual("Hello World!", range.CellsUsed().Single().GetString());
}
- [TestMethod]
+ [Test]
+ public void TableRange()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
+ IXLRangeColumn 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";
+ IXLTable table = rangeColumn.CreateTable();
+ wb.NamedRanges.Add("FNameColumn", String.Format("{0}[{1}]", table.Name, "FName"));
+
+ IXLRange namedRange = wb.Range("FNameColumn");
+ Assert.AreEqual(3, namedRange.Cells().Count());
+ Assert.IsTrue(
+ namedRange.CellsUsed().Select(cell => cell.GetString()).SequenceEqual(new[] {"John", "Hank", "Dagny"}));
+ }
+
+ [Test]
public void WsNamedCell()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell(1, 1).SetValue("Test").AddToNamed("TestCell", XLScope.Worksheet);
Assert.AreEqual("Test", ws.Cell("TestCell").GetString());
}
- [TestMethod]
+ [Test]
public void WsNamedCells()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet 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");
+ IXLCells cells = ws.Cells("TestCell, A2");
Assert.AreEqual("Test", cells.First().GetString());
Assert.AreEqual("B", cells.Last().GetString());
}
- [TestMethod]
+ [Test]
public void WsNamedRange()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.Cell(1, 1).SetValue("A");
ws.Cell(2, 1).SetValue("B");
- var original = ws.Range("A1:A2");
+ IXLRange original = ws.Range("A1:A2");
original.AddToNamed("TestRange", XLScope.Worksheet);
- var named = ws.Range("TestRange");
+ IXLRange named = ws.Range("TestRange");
Assert.AreEqual(original.RangeAddress.ToStringFixed(), named.RangeAddress.ToString());
}
- [TestMethod]
+ [Test]
public void WsNamedRanges()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet 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");
+ IXLRange original = ws.Range("A1:A2");
original.AddToNamed("TestRange", XLScope.Worksheet);
- var namedRanges = ws.Ranges("TestRange, A3");
+ IXLRanges 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]
+ [Test]
public void WsNamedRangesOneString()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
ws.NamedRanges.Add("TestRange", "Sheet1!$A$1,Sheet1!$A$3");
- var namedRanges = ws.Ranges("TestRange");
+ IXLRanges 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]
+ //[Test]
//public void WsNamedRangeLiteral()
//{
// var wb = new XLWorkbook();
@@ -183,8 +183,8 @@
// var text = wb2.Worksheet("Sheet1").NamedRanges.First()
// memoryStream.Close();
// }
-
-
+
+
//}
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/RichText/XLRichStringTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/RichText/XLRichStringTests.cs
index 602b37f..062285b 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/RichText/XLRichStringTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/RichText/XLRichStringTests.cs
@@ -1,60 +1,53 @@
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
using System.Linq;
-using System;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
-
-
///
- ///This is a test class for XLRichStringTests and is intended
- ///to contain all XLRichStringTests Unit Tests
- ///
- [TestClass()]
+ /// This is a test class for XLRichStringTests and is intended
+ /// to contain all XLRichStringTests Unit Tests
+ ///
+ [TestFixture]
public class XLRichStringTests
{
-
- ///
- ///A test for ToString
- ///
- [TestMethod()]
- public void ToStringTest()
+ [Test]
+ public void AccessRichTextTest1()
{
- 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);
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ cell.RichText.AddText("12");
+ cell.DataType = XLCellValues.Number;
- richString.AddText("!");
- expected = "Hello World!";
- actual = richString.ToString();
- Assert.AreEqual(expected, actual);
+ Assert.AreEqual(12.0, cell.GetDouble());
- richString.ClearText();
- expected = String.Empty;
- actual = richString.ToString();
- Assert.AreEqual(expected, actual);
+ IXLRichText 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 AddText
- ///
- [TestMethod()]
+ /// A test for AddText
+ ///
+ [Test]
public void AddTextTest1()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var cell = ws.Cell(1, 1);
- var richString = cell.RichText;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
+ IXLRichText 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);
@@ -65,17 +58,17 @@
Assert.AreEqual(richString.First().Text, text, "Item in collection is not the same as the one returned");
}
- [TestMethod()]
+ [Test]
public void AddTextTest2()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var cell = ws.Cell(1, 1);
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell 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);
@@ -88,11 +81,11 @@
Assert.AreEqual(cell.RichText.First().Text, text, "Item in collection is not the same as the one returned");
}
- [TestMethod()]
+ [Test]
public void AddTextTest3()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var cell = ws.Cell(1, 1);
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
Int32 number = 123;
cell.Value = number;
cell.Style
@@ -111,11 +104,45 @@
Assert.AreEqual(cell.RichText.First().Text, text, "Item in collection is not the same as the one returned");
}
- [TestMethod()]
+ ///
+ /// A test for Clear
+ ///
+ [Test]
+ public void ClearTest()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText 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);
+ }
+
+ [Test]
+ public void CountTest()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
+
+ richString.AddText("Hello");
+ richString.AddText(" ");
+ richString.AddText("World!");
+
+ Assert.AreEqual(3, richString.Count);
+ }
+
+ [Test]
public void HasRichTextTest1()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var cell = ws.Cell(1, 1);
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLCell cell = ws.Cell(1, 1);
cell.RichText.AddText("123");
Assert.AreEqual(true, cell.HasRichText);
@@ -143,45 +170,20 @@
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()]
+ /// A test for Characters
+ ///
+ [Test]
public void Substring_All_From_OneString()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var richString = ws.Cell(1, 1).RichText;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
richString.AddText("Hello");
- var actual = richString.Substring(0);
+ IXLFormattedText actual = richString.Substring(0);
Assert.AreEqual(richString.First(), actual.First());
@@ -192,54 +194,41 @@
Assert.AreEqual(true, ws.Cell(1, 1).RichText.First().Bold);
}
- [TestMethod()]
- public void Substring_From_OneString_Start()
+ [Test]
+ public void Substring_All_From_ThreeStrings()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var richString = ws.Cell(1, 1).RichText;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
- richString.AddText("Hello");
+ richString.AddText("Good Morning");
+ richString.AddText(" my ");
+ richString.AddText("neighbors!");
- var actual = richString.Substring(0, 2);
+ IXLFormattedText actual = richString.Substring(0);
- Assert.AreEqual(1, actual.Count); // substring was in one piece
+ 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(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);
+ 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);
-
- 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()]
+ [Test]
public void Substring_From_OneString_End()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var richString = ws.Cell(1, 1).RichText;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
richString.AddText("Hello");
- var actual = richString.Substring(2);
+ IXLFormattedText actual = richString.Substring(2);
Assert.AreEqual(1, actual.Count); // substring was in one piece
@@ -270,15 +259,15 @@
Assert.AreEqual(20, actual.First().FontSize);
}
- [TestMethod()]
+ [Test]
public void Substring_From_OneString_Middle()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var richString = ws.Cell(1, 1).RichText;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
richString.AddText("Hello");
- var actual = richString.Substring(2, 2);
+ IXLFormattedText actual = richString.Substring(2, 2);
Assert.AreEqual(1, actual.Count); // substring was in one piece
@@ -313,194 +302,56 @@
Assert.AreEqual(20, actual.First().FontSize);
}
- [TestMethod()]
- [ExpectedException(typeof(IndexOutOfRangeException))]
- public void Substring_IndexOutsideRange1()
+ [Test]
+ public void Substring_From_OneString_Start()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var richString = ws.Cell(1, 1).RichText;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
richString.AddText("Hello");
- var richText = richString.Substring(50);
- }
+ IXLFormattedText actual = richString.Substring(0, 2);
- [TestMethod()]
- [ExpectedException(typeof(IndexOutOfRangeException))]
- public void Substring_IndexOutsideRange2()
- {
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var richString = ws.Cell(1, 1).RichText;
+ Assert.AreEqual(1, actual.Count); // substring was in one piece
- richString.AddText("Hello");
- richString.AddText("World");
+ Assert.AreEqual(2, richString.Count); // The text was split because of the substring
- var richText = richString.Substring(50);
- }
+ Assert.AreEqual("He", actual.First().Text);
- [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);
+ 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.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.Last().SetItalic();
- richString.AddText("Good Morning");
- richString.AddText(" my ");
- richString.AddText("neighbors!");
+ Assert.AreEqual(false, ws.Cell(1, 1).RichText.First().Italic);
+ Assert.AreEqual(true, ws.Cell(1, 1).RichText.Last().Italic);
- 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);
+ Assert.AreEqual(false, 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, 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_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()]
+ [Test]
public void Substring_From_ThreeStrings_End1()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var richString = ws.Cell(1, 1).RichText;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
richString.AddText("Good Morning");
richString.AddText(" my ");
richString.AddText("neighbors!");
- var actual = richString.Substring(21);
+ IXLFormattedText actual = richString.Substring(21);
Assert.AreEqual(1, actual.Count); // substring was in one piece
@@ -539,17 +390,17 @@
Assert.AreEqual(20, actual.First().FontSize);
}
- [TestMethod()]
+ [Test]
public void Substring_From_ThreeStrings_End2()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var richString = ws.Cell(1, 1).RichText;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
richString.AddText("Good Morning");
richString.AddText(" my ");
richString.AddText("neighbors!");
- var actual = richString.Substring(13);
+ IXLFormattedText actual = richString.Substring(13);
Assert.AreEqual(2, actual.Count);
@@ -591,17 +442,17 @@
Assert.AreEqual(20, actual.ElementAt(1).FontSize);
}
- [TestMethod()]
+ [Test]
public void Substring_From_ThreeStrings_Mid1()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var richString = ws.Cell(1, 1).RichText;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
richString.AddText("Good Morning");
richString.AddText(" my ");
richString.AddText("neighbors!");
- var actual = richString.Substring(5, 10);
+ IXLFormattedText actual = richString.Substring(5, 10);
Assert.AreEqual(2, actual.Count);
@@ -617,17 +468,17 @@
Assert.AreEqual("neighbors!", richString.ElementAt(4).Text);
}
- [TestMethod()]
+ [Test]
public void Substring_From_ThreeStrings_Mid2()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var richString = ws.Cell(1, 1).RichText;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
richString.AddText("Good Morning");
richString.AddText(" my ");
richString.AddText("neighbors!");
- var actual = richString.Substring(5, 15);
+ IXLFormattedText actual = richString.Substring(5, 15);
Assert.AreEqual(3, actual.Count);
@@ -644,40 +495,182 @@
Assert.AreEqual("hbors!", richString.ElementAt(4).Text);
}
+ [Test]
+ public void Substring_From_ThreeStrings_Start1()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
+
+ richString.AddText("Good Morning");
+ richString.AddText(" my ");
+ richString.AddText("neighbors!");
+
+ IXLFormattedText 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);
+ }
+
+ [Test]
+ public void Substring_From_ThreeStrings_Start2()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
+
+ richString.AddText("Good Morning");
+ richString.AddText(" my ");
+ richString.AddText("neighbors!");
+
+ IXLFormattedText 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);
+ }
+
+ [Test]
+ [ExpectedException(typeof (IndexOutOfRangeException))]
+ public void Substring_IndexOutsideRange1()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
+
+ richString.AddText("Hello");
+
+ IXLFormattedText richText = richString.Substring(50);
+ }
+
+ [Test]
+ [ExpectedException(typeof (IndexOutOfRangeException))]
+ public void Substring_IndexOutsideRange2()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
+
+ richString.AddText("Hello");
+ richString.AddText("World");
+
+ IXLFormattedText richText = richString.Substring(50);
+ }
+
+ [Test]
+ [ExpectedException(typeof (IndexOutOfRangeException))]
+ public void Substring_IndexOutsideRange3()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
+
+ richString.AddText("Hello");
+
+ IXLFormattedText richText = richString.Substring(1, 10);
+ }
+
+ [Test]
+ [ExpectedException(typeof (IndexOutOfRangeException))]
+ public void Substring_IndexOutsideRange4()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
+
+ richString.AddText("Hello");
+ richString.AddText("World");
+
+ IXLFormattedText richText = richString.Substring(5, 20);
+ }
///
- ///A test for Clear
- ///
- [TestMethod()]
- public void ClearTest()
+ /// A test for ToString
+ ///
+ [Test]
+ public void ToStringTest()
{
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- var richString = ws.Cell(1, 1).RichText;
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ IXLRichText richString = ws.Cell(1, 1).RichText;
richString.AddText("Hello");
richString.AddText(" ");
- richString.AddText("World!");
-
- richString.ClearText();
- String expected = String.Empty;
- String actual = richString.ToString();
+ richString.AddText("World");
+ string expected = "Hello World";
+ string actual = richString.ToString();
Assert.AreEqual(expected, actual);
- Assert.AreEqual(0, richString.Count);
+ richString.AddText("!");
+ expected = "Hello World!";
+ actual = richString.ToString();
+ Assert.AreEqual(expected, actual);
+
+ richString.ClearText();
+ expected = String.Empty;
+ actual = richString.ToString();
+ Assert.AreEqual(expected, actual);
}
-
- [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);
- }
-
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Rows/RowTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Rows/RowTests.cs
index 40b21d1..2afe01f 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Rows/RowTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Rows/RowTests.cs
@@ -1,64 +1,42 @@
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
+using System;
using System.Linq;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class RowTests
{
-
- [TestMethod]
- public void RowUsed()
+ [Test]
+ public void CopyRow()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
- ws.Cell(1, 2).SetValue("Test");
- ws.Cell(1, 3).SetValue("Test");
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue("Test").Style.Font.SetBold();
+ ws.FirstRow().CopyTo(ws.Row(2));
- 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());
+ Assert.IsTrue(ws.Cell("A2").Style.Font.Bold);
}
-
- [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]
+ [Test]
public void InsertingRowsAbove1()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet 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);
+ IXLRow row1 = ws.Row(1);
+ IXLRow row2 = ws.Row(2);
+ IXLRow row3 = ws.Row(3);
- var rowIns = ws.Row(1).InsertRowsAbove(1).First();
+ IXLRow 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);
@@ -69,7 +47,7 @@
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.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);
@@ -79,7 +57,6 @@
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);
@@ -89,7 +66,7 @@
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.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);
@@ -99,21 +76,21 @@
Assert.AreEqual("X", row2.Cell(2).GetString());
}
- [TestMethod]
+ [Test]
public void InsertingRowsAbove2()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet 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);
+ IXLRow row1 = ws.Row(1);
+ IXLRow row2 = ws.Row(2);
+ IXLRow row3 = ws.Row(3);
- var rowIns = ws.Row(2).InsertRowsAbove(1).First();
+ IXLRow 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);
@@ -134,7 +111,6 @@
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);
@@ -154,32 +130,32 @@
Assert.AreEqual("X", row2.Cell(2).GetString());
}
- [TestMethod]
+ [Test]
public void InsertingRowsAbove3()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
+ IXLWorksheet 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);
+ IXLRow row1 = ws.Row(1);
+ IXLRow row2 = ws.Row(2);
+ IXLRow row3 = ws.Row(3);
- var rowIns = ws.Row(3).InsertRowsAbove(1).First();
+ IXLRow 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.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.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);
@@ -208,25 +184,44 @@
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()
+ [Test]
+ public void NoRowsUsed()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue("Test").Style.Font.SetBold();
- ws.FirstRow().CopyTo(ws.Row(2));
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
+ Int32 count = 0;
- Assert.IsTrue(ws.Cell("A2").Style.Font.Bold);
+ foreach (IXLRow row in ws.RowsUsed())
+ count++;
+
+ foreach (IXLRangeRow row in ws.Range("A1:C3").RowsUsed())
+ count++;
+
+ Assert.AreEqual(0, count);
+ }
+
+ [Test]
+ public void RowUsed()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
+ ws.Cell(1, 2).SetValue("Test");
+ ws.Cell(1, 3).SetValue("Test");
+
+ IXLRangeRow fromRow = ws.Row(1).RowUsed();
+ Assert.AreEqual("B1:C1", fromRow.RangeAddress.ToStringRelative());
+
+ IXLRangeRow fromRange = ws.Range("A1:E1").FirstRow().RowUsed();
+ Assert.AreEqual("B1:C1", fromRange.RangeAddress.ToStringRelative());
+ }
+
+
+ [Test]
+ public void UngroupFromAll()
+ {
+ IXLWorksheet ws = new XLWorkbook().AddWorksheet("Sheet1");
+ ws.Rows(1, 2).Group();
+ ws.Rows(1, 2).Ungroup(true);
}
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Styles/ColorTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Styles/ColorTests.cs
index 2d7cb88..793c39e 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Styles/ColorTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Styles/ColorTests.cs
@@ -1,41 +1,36 @@
-using System;
-using System.Drawing;
-using System.Text;
-using System.Collections.Generic;
-using System.Linq;
+using System.Drawing;
using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class ColorTests
{
-
- [TestMethod]
+ [Test]
public void ColorEqualOperatorInPlace()
{
Assert.IsTrue(XLColor.Black == XLColor.Black);
}
- [TestMethod]
+ [Test]
public void ColorNotEqualOperatorInPlace()
{
Assert.IsFalse(XLColor.Black != XLColor.Black);
}
- [TestMethod]
+ [Test]
public void DefaultColorIndex64isTransparentWhite()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- var color = ws.FirstCell().Style.Fill.BackgroundColor;
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ XLColor color = ws.FirstCell().Style.Fill.BackgroundColor;
Assert.AreEqual(XLColorType.Indexed, color.ColorType);
Assert.AreEqual(64, color.Indexed);
- Assert.AreEqual(Color.Transparent , color.Color);
+ Assert.AreEqual(Color.Transparent, color.Color);
}
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Styles/XLFillTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Styles/XLFillTests.cs
index 84994d3..180dac8 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Styles/XLFillTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Styles/XLFillTests.cs
@@ -1,47 +1,42 @@
-using System;
-using System.Text;
-using System.Collections.Generic;
-using System.Linq;
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class XLFillTests
{
-
- [TestMethod]
- public void BackgroundPatternEqualCheck()
- {
- var fill1 = new XLFill { PatternBackgroundColor = XLColor.Blue };
- var fill2 = new XLFill { PatternBackgroundColor = XLColor.Blue };
- Assert.IsTrue(fill1.Equals(fill2));
- }
-
- [TestMethod]
- public void BackgroundPatternNotEqualCheck()
- {
- var fill1 = new XLFill { PatternBackgroundColor = XLColor.Blue };
- var fill2 = new XLFill { PatternBackgroundColor = XLColor.Red };
- Assert.IsFalse(fill1.Equals(fill2));
- }
-
- [TestMethod]
+ [Test]
public void BackgroundColorSetsPattern()
{
- var fill = new XLFill { BackgroundColor = XLColor.Blue };
+ var fill = new XLFill {BackgroundColor = XLColor.Blue};
Assert.AreEqual(XLFillPatternValues.Solid, fill.PatternType);
}
- [TestMethod]
+ [Test]
public void BackgroundNoColorSetsPatternNone()
{
- var fill = new XLFill { BackgroundColor = XLColor.NoColor };
+ var fill = new XLFill {BackgroundColor = XLColor.NoColor};
Assert.AreEqual(XLFillPatternValues.None, fill.PatternType);
}
+
+ [Test]
+ public void BackgroundPatternEqualCheck()
+ {
+ var fill1 = new XLFill {PatternBackgroundColor = XLColor.Blue};
+ var fill2 = new XLFill {PatternBackgroundColor = XLColor.Blue};
+ Assert.IsTrue(fill1.Equals(fill2));
+ }
+
+ [Test]
+ public void BackgroundPatternNotEqualCheck()
+ {
+ var fill1 = new XLFill {PatternBackgroundColor = XLColor.Blue};
+ var fill2 = new XLFill {PatternBackgroundColor = XLColor.Red};
+ Assert.IsFalse(fill1.Equals(fill2));
+ }
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Tables/TablesTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Tables/TablesTests.cs
index c08aedd..62c6900 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Tables/TablesTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Tables/TablesTests.cs
@@ -1,39 +1,272 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
using System.Data;
using System.IO;
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
using System.Linq;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests.Excel
{
///
- /// Summary description for UnitTest1
+ /// Summary description for UnitTest1
///
- [TestClass]
+ [TestFixture]
public class TablesTests
{
- [TestMethod]
+ public class TestObject
+ {
+ public String Column1 { get; set; }
+ public String Column2 { get; set; }
+ }
+
+ [Test]
+ public void CanSaveTableCreatedFromEmptyDataTable()
+ {
+ var dt = new DataTable("sheet1");
+ dt.Columns.Add("col1", typeof (string));
+ dt.Columns.Add("col2", typeof (double));
+
+ var wb = new XLWorkbook();
+ wb.AddWorksheet(dt);
+
+ using (var ms = new MemoryStream())
+ wb.SaveAs(ms);
+ }
+
+ [Test]
+ public void CanSaveTableCreatedFromSingleRow()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue("Title");
+ ws.Range("A1").CreateTable();
+
+ using (var ms = new MemoryStream())
+ wb.SaveAs(ms);
+ }
+
+ [Test]
+ public void CreatingATableFromHeadersPushCellsBelow()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue("Title")
+ .CellBelow().SetValue("X");
+ ws.Range("A1").CreateTable();
+
+ Assert.AreEqual(ws.Cell("A2").GetString(), String.Empty);
+ Assert.AreEqual(ws.Cell("A3").GetString(), "X");
+ }
+
+ [Test]
public void Inserting_Column_Sets_Header()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
ws.FirstCell().SetValue("Categories")
.CellBelow().SetValue("A")
.CellBelow().SetValue("B")
.CellBelow().SetValue("C");
- var table = ws.RangeUsed().CreateTable();
+ IXLTable table = ws.RangeUsed().CreateTable();
table.InsertColumnsAfter(1);
Assert.AreEqual("Column2", table.HeadersRow().LastCell().GetString());
}
- [TestMethod]
+ [Test]
+ public void SavingLoadingTableWithNewLineInHeader()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ string columnName = "Line1" + Environment.NewLine + "Line2";
+ ws.FirstCell().SetValue(columnName)
+ .CellBelow().SetValue("A");
+ ws.RangeUsed().CreateTable();
+ using (var ms = new MemoryStream())
+ {
+ wb.SaveAs(ms);
+ var wb2 = new XLWorkbook(ms);
+ IXLWorksheet ws2 = wb2.Worksheet(1);
+ IXLTable table2 = ws2.Table(0);
+ string fieldName = table2.Field(0).Name;
+ Assert.AreEqual("Line1\nLine2", fieldName);
+ }
+ }
+
+ [Test]
+ public void SavingLoadingTableWithNewLineInHeader2()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.Worksheets.Add("Test");
+
+ var dt = new DataTable();
+ string columnName = "Line1" + Environment.NewLine + "Line2";
+ dt.Columns.Add(columnName);
+
+ DataRow dr = dt.NewRow();
+ dr[columnName] = "some text";
+ dt.Rows.Add(dr);
+ ws.Cell(1, 1).InsertTable(dt.AsEnumerable());
+
+ IXLTable table1 = ws.Table(0);
+ string fieldName1 = table1.Field(0).Name;
+ Assert.AreEqual(columnName, fieldName1);
+
+ using (var ms = new MemoryStream())
+ {
+ wb.SaveAs(ms);
+ var wb2 = new XLWorkbook(ms);
+ IXLWorksheet ws2 = wb2.Worksheet(1);
+ IXLTable table2 = ws2.Table(0);
+ string fieldName2 = table2.Field(0).Name;
+ Assert.AreEqual("Line1\nLine2", fieldName2);
+ }
+ }
+
+ [Test]
+ public void TableCreatedFromEmptyDataTable()
+ {
+ var dt = new DataTable("sheet1");
+ dt.Columns.Add("col1", typeof (string));
+ dt.Columns.Add("col2", typeof (double));
+
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().InsertTable(dt);
+ Assert.AreEqual(2, ws.Tables.First().ColumnCount());
+ }
+
+ [Test]
+ public void TableCreatedFromEmptyListOfInt()
+ {
+ var l = new List();
+
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().InsertTable(l);
+ Assert.AreEqual(1, ws.Tables.First().ColumnCount());
+ }
+
+ [Test]
+ public void TableCreatedFromEmptyListOfObject()
+ {
+ var l = new List();
+
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().InsertTable(l);
+ Assert.AreEqual(2, ws.Tables.First().ColumnCount());
+ }
+
+ [Test]
+ public void TableInsertAboveFromData()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue("Value");
+
+ IXLTable table = ws.Range("A1:A2").CreateTable();
+ table.SetShowTotalsRow()
+ .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum;
+
+ IXLTableRow row = table.DataRange.FirstRow();
+ row.Field("Value").Value = 3;
+ row = table.DataRange.InsertRowsAbove(1).First();
+ row.Field("Value").Value = 2;
+ row = table.DataRange.InsertRowsAbove(1).First();
+ row.Field("Value").Value = 1;
+
+ //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox.xlsx");
+
+ Assert.AreEqual(1, ws.Cell(2, 1).GetDouble());
+ Assert.AreEqual(2, ws.Cell(3, 1).GetDouble());
+ Assert.AreEqual(3, ws.Cell(4, 1).GetDouble());
+
+ //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox.xlsx");
+ }
+
+ [Test]
+ public void TableInsertAboveFromRows()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue("Value");
+
+ IXLTable table = ws.Range("A1:A2").CreateTable();
+ table.SetShowTotalsRow()
+ .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum;
+ //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox1.xlsx");
+ IXLTableRow row = table.DataRange.FirstRow();
+ row.Field("Value").Value = 3;
+ row = row.InsertRowsAbove(1).First();
+ row.Field("Value").Value = 2;
+ row = row.InsertRowsAbove(1).First();
+ row.Field("Value").Value = 1;
+ //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox2.xlsx");
+
+ Assert.AreEqual(1, ws.Cell(2, 1).GetDouble());
+ Assert.AreEqual(2, ws.Cell(3, 1).GetDouble());
+ Assert.AreEqual(3, ws.Cell(4, 1).GetDouble());
+
+ //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox.xlsx");
+ }
+
+ [Test]
+ public void TableInsertBelowFromData()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue("Value");
+
+ IXLTable table = ws.Range("A1:A2").CreateTable();
+ table.SetShowTotalsRow()
+ .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum;
+
+ IXLTableRow row = table.DataRange.FirstRow();
+ row.Field("Value").Value = 1;
+ row = table.DataRange.InsertRowsBelow(1).First();
+ row.Field("Value").Value = 2;
+ row = table.DataRange.InsertRowsBelow(1).First();
+ row.Field("Value").Value = 3;
+
+ //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox.xlsx");
+
+ Assert.AreEqual(1, ws.Cell(2, 1).GetDouble());
+ Assert.AreEqual(2, ws.Cell(3, 1).GetDouble());
+ Assert.AreEqual(3, ws.Cell(4, 1).GetDouble());
+ }
+
+ [Test]
+ public void TableInsertBelowFromRows()
+ {
+ var wb = new XLWorkbook();
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().SetValue("Value");
+
+ IXLTable table = ws.Range("A1:A2").CreateTable();
+ table.SetShowTotalsRow()
+ .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum;
+
+ IXLTableRow row = table.DataRange.FirstRow();
+ row.Field("Value").Value = 1;
+ row = row.InsertRowsBelow(1).First();
+ row.Field("Value").Value = 2;
+ row = row.InsertRowsBelow(1).First();
+ row.Field("Value").Value = 3;
+
+ Assert.AreEqual(1, ws.Cell(2, 1).GetDouble());
+ Assert.AreEqual(2, ws.Cell(3, 1).GetDouble());
+ Assert.AreEqual(3, ws.Cell(4, 1).GetDouble());
+
+ //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox.xlsx");
+ }
+
+ [Test]
public void TableShowHeader()
{
var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
ws.FirstCell().SetValue("Categories")
.CellBelow().SetValue("A")
.CellBelow().SetValue("B")
@@ -41,11 +274,11 @@
ws.RangeUsed().CreateTable().SetShowHeaderRow(false);
- var table = ws.Tables.First();
+ IXLTable table = ws.Tables.First();
//wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox1.xlsx");
- Assert.IsTrue(ws.Cell(1,1).IsEmpty(true));
+ Assert.IsTrue(ws.Cell(1, 1).IsEmpty(true));
Assert.AreEqual(null, table.HeadersRow());
Assert.AreEqual("A", table.DataRange.FirstRow().Field("Categories").GetString());
Assert.AreEqual("C", table.DataRange.LastRow().Field("Categories").GetString());
@@ -53,16 +286,15 @@
Assert.AreEqual("C", table.DataRange.LastCell().GetString());
table.SetShowHeaderRow();
- var headerRow = table.HeadersRow();
+ IXLRangeRow headerRow = table.HeadersRow();
Assert.AreNotEqual(null, headerRow);
Assert.AreEqual("Categories", headerRow.Cell(1).GetString());
-
table.SetShowHeaderRow(false);
-
+
ws.FirstCell().SetValue("x");
-
+
table.SetShowHeaderRow();
//wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox2.xlsx");
@@ -75,252 +307,6 @@
Assert.AreEqual("C", table.DataRange.LastRow().Field("Categories").GetString());
Assert.AreEqual("A", table.DataRange.FirstCell().GetString());
Assert.AreEqual("C", table.DataRange.LastCell().GetString());
-
- }
-
-
- [TestMethod]
- public void TableInsertBelowFromRows()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue("Value");
-
- var table = ws.Range("A1:A2").CreateTable();
- table.SetShowTotalsRow()
- .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum;
-
- var row = table.DataRange.FirstRow();
- row.Field("Value").Value = 1;
- row = row.InsertRowsBelow(1).First();
- row.Field("Value").Value = 2;
- row = row.InsertRowsBelow(1).First();
- row.Field("Value").Value = 3;
-
- Assert.AreEqual(1, ws.Cell(2, 1).GetDouble());
- Assert.AreEqual(2, ws.Cell(3, 1).GetDouble());
- Assert.AreEqual(3, ws.Cell(4, 1).GetDouble());
-
- //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox.xlsx");
-
- }
-
- [TestMethod]
- public void TableInsertBelowFromData()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue("Value");
-
- var table = ws.Range("A1:A2").CreateTable();
- table.SetShowTotalsRow()
- .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum;
-
- var row = table.DataRange.FirstRow();
- row.Field("Value").Value = 1;
- row = table.DataRange.InsertRowsBelow(1).First();
- row.Field("Value").Value = 2;
- row = table.DataRange.InsertRowsBelow(1).First();
- row.Field("Value").Value = 3;
-
- //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox.xlsx");
-
- Assert.AreEqual(1, ws.Cell(2, 1).GetDouble());
- Assert.AreEqual(2, ws.Cell(3, 1).GetDouble());
- Assert.AreEqual(3, ws.Cell(4, 1).GetDouble());
-
-
-
- }
-
- [TestMethod]
- public void TableInsertAboveFromRows()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue("Value");
-
- var table = ws.Range("A1:A2").CreateTable();
- table.SetShowTotalsRow()
- .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum;
- //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox1.xlsx");
- var row = table.DataRange.FirstRow();
- row.Field("Value").Value = 3;
- row = row.InsertRowsAbove(1).First();
- row.Field("Value").Value = 2;
- row = row.InsertRowsAbove(1).First();
- row.Field("Value").Value = 1;
- //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox2.xlsx");
-
- Assert.AreEqual(1, ws.Cell(2, 1).GetDouble());
- Assert.AreEqual(2, ws.Cell(3, 1).GetDouble());
- Assert.AreEqual(3, ws.Cell(4, 1).GetDouble());
-
- //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox.xlsx");
- }
-
- [TestMethod]
- public void TableInsertAboveFromData()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue("Value");
-
- var table = ws.Range("A1:A2").CreateTable();
- table.SetShowTotalsRow()
- .Field(0).TotalsRowFunction = XLTotalsRowFunction.Sum;
-
- var row = table.DataRange.FirstRow();
- row.Field("Value").Value = 3;
- row = table.DataRange.InsertRowsAbove(1).First();
- row.Field("Value").Value = 2;
- row = table.DataRange.InsertRowsAbove(1).First();
- row.Field("Value").Value = 1;
-
- //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox.xlsx");
-
- Assert.AreEqual(1, ws.Cell(2, 1).GetDouble());
- Assert.AreEqual(2, ws.Cell(3, 1).GetDouble());
- Assert.AreEqual(3, ws.Cell(4, 1).GetDouble());
-
- //wb.SaveAs(@"D:\Excel Files\ForTesting\Sandbox.xlsx");
-
- }
-
- [TestMethod]
- public void CreatingATableFromHeadersPushCellsBelow()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue("Title")
- .CellBelow().SetValue("X");
- ws.Range("A1").CreateTable();
-
- Assert.AreEqual(ws.Cell("A2").GetString(), String.Empty);
- Assert.AreEqual(ws.Cell("A3").GetString(), "X");
- }
-
-
- [TestMethod]
- public void CanSaveTableCreatedFromSingleRow()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().SetValue("Title");
- ws.Range("A1").CreateTable();
-
- using (var ms = new MemoryStream())
- wb.SaveAs(ms);
-
- }
-
- [TestMethod]
- public void CanSaveTableCreatedFromEmptyDataTable()
- {
- var dt = new DataTable("sheet1");
- dt.Columns.Add("col1", typeof(string));
- dt.Columns.Add("col2", typeof(double));
-
- var wb = new XLWorkbook();
- wb.AddWorksheet(dt);
-
- using (var ms = new MemoryStream())
- wb.SaveAs(ms);
-
- }
-
- [TestMethod]
- public void TableCreatedFromEmptyDataTable()
- {
- var dt = new DataTable("sheet1");
- dt.Columns.Add("col1", typeof(string));
- dt.Columns.Add("col2", typeof(double));
-
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().InsertTable(dt);
- Assert.AreEqual(2, ws.Tables.First().ColumnCount());
- }
-
- [TestMethod]
- public void TableCreatedFromEmptyListOfInt()
- {
- var l = new List();
-
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().InsertTable(l);
- Assert.AreEqual(1, ws.Tables.First().ColumnCount());
-
- }
-
- public class TestObject
- {
- public String Column1 { get; set; }
- public String Column2 { get; set; }
- }
- [TestMethod]
- public void TableCreatedFromEmptyListOfObject()
- {
- var l = new List();
-
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().InsertTable(l);
- Assert.AreEqual(2, ws.Tables.First().ColumnCount());
-
- }
-
- [TestMethod]
- public void SavingLoadingTableWithNewLineInHeader()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- var columnName = "Line1" + Environment.NewLine + "Line2";
- ws.FirstCell().SetValue(columnName)
- .CellBelow().SetValue("A");
- ws.RangeUsed().CreateTable();
- using (var ms = new MemoryStream())
- {
- wb.SaveAs(ms);
- var wb2 = new XLWorkbook(ms);
- var ws2 = wb2.Worksheet(1);
- var table2 = ws2.Table(0);
- var fieldName = table2.Field(0).Name;
- Assert.AreEqual("Line1\nLine2", fieldName);
- }
-
- }
-
- [TestMethod]
- public void SavingLoadingTableWithNewLineInHeader2()
- {
- XLWorkbook wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Test");
-
- DataTable dt = new DataTable();
- var columnName = "Line1" + Environment.NewLine + "Line2";
- dt.Columns.Add(columnName);
-
- DataRow dr = dt.NewRow();
- dr[columnName] = "some text";
- dt.Rows.Add(dr);
- ws.Cell(1, 1).InsertTable(dt.AsEnumerable());
-
- var table1 = ws.Table(0);
- var fieldName1 = table1.Field(0).Name;
- Assert.AreEqual(columnName, fieldName1);
-
- using (var ms = new MemoryStream())
- {
- wb.SaveAs(ms);
- var wb2 = new XLWorkbook(ms);
- var ws2 = wb2.Worksheet(1);
- var table2 = ws2.Table(0);
- var fieldName2 = table2.Field(0).Name;
- Assert.AreEqual("Line1\nLine2", fieldName2);
- }
-
}
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Worksheets/XLWorksheetTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Worksheets/XLWorksheetTests.cs
index 9b538e6..e5bf666 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Worksheets/XLWorksheetTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Excel/Worksheets/XLWorksheetTests.cs
@@ -1,68 +1,35 @@
-using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
using System.Linq;
-using System;
-using System.IO;
+using ClosedXML.Excel;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- [TestClass()]
+ [TestFixture]
public class XLWorksheetTests
{
- [TestMethod]
- public void MergedRanges()
- {
- var ws = new XLWorkbook().Worksheets.Add("Sheet1");
- ws.Range("A1:B2").Merge();
- ws.Range("C1:D3").Merge();
- ws.Range("D2:E2").Merge();
-
- Assert.AreEqual(2, ws.MergedRanges.Count);
- Assert.AreEqual("A1:B2", ws.MergedRanges.First().RangeAddress.ToStringRelative());
- Assert.AreEqual("D2:E2", ws.MergedRanges.Last().RangeAddress.ToStringRelative());
- }
-
- [TestMethod]
- public void InsertingSheets1()
+ [Test]
+ public void ColumnCountTime()
{
var wb = new XLWorkbook();
- wb.Worksheets.Add("Sheet1");
- wb.Worksheets.Add("Sheet2");
- wb.Worksheets.Add("Sheet3");
-
- Assert.AreEqual("Sheet1", wb.Worksheet(1).Name);
- Assert.AreEqual("Sheet2", wb.Worksheet(2).Name);
- Assert.AreEqual("Sheet3", wb.Worksheet(3).Name);
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
+ DateTime start = DateTime.Now;
+ ws.ColumnCount();
+ DateTime end = DateTime.Now;
+ Assert.IsTrue((end - start).TotalMilliseconds < 500);
}
- [TestMethod]
- public void InsertingSheets2()
+ [Test]
+ public void CopyConditionalFormatsCount()
{
var wb = new XLWorkbook();
- wb.Worksheets.Add("Sheet2");
- wb.Worksheets.Add("Sheet1", 1);
- wb.Worksheets.Add("Sheet3");
-
- Assert.AreEqual("Sheet1", wb.Worksheet(1).Name);
- Assert.AreEqual("Sheet2", wb.Worksheet(2).Name);
- Assert.AreEqual("Sheet3", wb.Worksheet(3).Name);
+ IXLWorksheet ws = wb.AddWorksheet("Sheet1");
+ ws.FirstCell().AddConditionalFormat().WhenContains("1").Fill.SetBackgroundColor(XLColor.Blue);
+ IXLWorksheet ws2 = ws.CopyTo("Sheet2");
+ Assert.AreEqual(1, ws2.ConditionalFormats.Count());
}
- [TestMethod]
- public void InsertingSheets3()
- {
- var wb = new XLWorkbook();
- wb.Worksheets.Add("Sheet3");
- wb.Worksheets.Add("Sheet2", 1);
- wb.Worksheets.Add("Sheet1", 1);
-
-
- Assert.AreEqual("Sheet1", wb.Worksheet(1).Name);
- Assert.AreEqual("Sheet2", wb.Worksheet(2).Name);
- Assert.AreEqual("Sheet3", wb.Worksheet(3).Name);
- }
-
- [TestMethod]
+ [Test]
public void DeletingSheets1()
{
var wb = new XLWorkbook();
@@ -77,36 +44,68 @@
Assert.AreEqual(2, wb.Worksheets.Count);
}
- [TestMethod]
+ [Test]
+ public void InsertingSheets1()
+ {
+ var wb = new XLWorkbook();
+ wb.Worksheets.Add("Sheet1");
+ wb.Worksheets.Add("Sheet2");
+ wb.Worksheets.Add("Sheet3");
+
+ Assert.AreEqual("Sheet1", wb.Worksheet(1).Name);
+ Assert.AreEqual("Sheet2", wb.Worksheet(2).Name);
+ Assert.AreEqual("Sheet3", wb.Worksheet(3).Name);
+ }
+
+ [Test]
+ public void InsertingSheets2()
+ {
+ var wb = new XLWorkbook();
+ wb.Worksheets.Add("Sheet2");
+ wb.Worksheets.Add("Sheet1", 1);
+ wb.Worksheets.Add("Sheet3");
+
+ Assert.AreEqual("Sheet1", wb.Worksheet(1).Name);
+ Assert.AreEqual("Sheet2", wb.Worksheet(2).Name);
+ Assert.AreEqual("Sheet3", wb.Worksheet(3).Name);
+ }
+
+ [Test]
+ public void InsertingSheets3()
+ {
+ var wb = new XLWorkbook();
+ wb.Worksheets.Add("Sheet3");
+ wb.Worksheets.Add("Sheet2", 1);
+ wb.Worksheets.Add("Sheet1", 1);
+
+
+ Assert.AreEqual("Sheet1", wb.Worksheet(1).Name);
+ Assert.AreEqual("Sheet2", wb.Worksheet(2).Name);
+ Assert.AreEqual("Sheet3", wb.Worksheet(3).Name);
+ }
+
+ [Test]
+ public void MergedRanges()
+ {
+ IXLWorksheet ws = new XLWorkbook().Worksheets.Add("Sheet1");
+ ws.Range("A1:B2").Merge();
+ ws.Range("C1:D3").Merge();
+ ws.Range("D2:E2").Merge();
+
+ Assert.AreEqual(2, ws.MergedRanges.Count);
+ Assert.AreEqual("A1:B2", ws.MergedRanges.First().RangeAddress.ToStringRelative());
+ Assert.AreEqual("D2:E2", ws.MergedRanges.Last().RangeAddress.ToStringRelative());
+ }
+
+ [Test]
public void RowCountTime()
{
var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
- var start = DateTime.Now;
+ IXLWorksheet ws = wb.Worksheets.Add("Sheet1");
+ DateTime start = DateTime.Now;
ws.RowCount();
- var end = DateTime.Now;
+ DateTime end = DateTime.Now;
Assert.IsTrue((end - start).TotalMilliseconds < 500);
}
-
- [TestMethod]
- public void ColumnCountTime()
- {
- var wb = new XLWorkbook();
- var ws = wb.Worksheets.Add("Sheet1");
- var start = DateTime.Now;
- ws.ColumnCount();
- var end = DateTime.Now;
- Assert.IsTrue((end - start).TotalMilliseconds < 500);
- }
-
- [TestMethod]
- public void CopyConditionalFormatsCount()
- {
- var wb = new XLWorkbook();
- var ws = wb.AddWorksheet("Sheet1");
- ws.FirstCell().AddConditionalFormat().WhenContains("1").Fill.SetBackgroundColor(XLColor.Blue);
- var ws2 = ws.CopyTo("Sheet2");
- Assert.AreEqual(1, ws2.ConditionalFormats.Count());
- }
}
-}
+}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/ExcelDocsComparerTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/ExcelDocsComparerTests.cs
index b4b9c3d..3397f25 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/ExcelDocsComparerTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/ExcelDocsComparerTests.cs
@@ -1,38 +1,38 @@
using System.IO;
using ClosedXML_Examples;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- [TestClass]
+ [TestFixture]
public class ExcelDocsComparerTests
{
- [TestMethod]
+ [Test]
public void CheckEqual()
{
- string left = ExampleHelper.GetTempFilePath("left.xlsx");
- string right = ExampleHelper.GetTempFilePath("right.xlsx");
- try
- {
- new BasicTable().Create(left);
- new BasicTable().Create(right);
- string message;
- Assert.IsTrue(ExcelDocsComparer.Compare(left, right, out message));
- }
- finally
- {
- if (File.Exists(left))
- {
- File.Delete(left);
- }
- if (File.Exists(right))
- {
- File.Delete(right);
- }
- }
+ string left = ExampleHelper.GetTempFilePath("left.xlsx");
+ string right = ExampleHelper.GetTempFilePath("right.xlsx");
+ try
+ {
+ new BasicTable().Create(left);
+ new BasicTable().Create(right);
+ string message;
+ Assert.IsTrue(ExcelDocsComparer.Compare(left, right, out message));
+ }
+ finally
+ {
+ if (File.Exists(left))
+ {
+ File.Delete(left);
+ }
+ if (File.Exists(right))
+ {
+ File.Delete(right);
+ }
+ }
}
- [TestMethod]
+ [Test]
public void CheckNonEqual()
{
string left = ExampleHelper.GetTempFilePath("left.xlsx");
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Properties/AssemblyInfo.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Properties/AssemblyInfo.cs
index 312c5ba..f11097e 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Properties/AssemblyInfo.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Properties/AssemblyInfo.cs
@@ -4,6 +4,7 @@
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
+
[assembly: AssemblyTitle("ClosedXML_Tests")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
@@ -16,9 +17,11 @@
// Setting ComVisible to false makes the types in this assembly not visible
// to COM components. If you need to access a type in this assembly from
// COM, set the ComVisible attribute to true on that type.
+
[assembly: ComVisible(false)]
// The following GUID is for the ID of the typelib if this project is exposed to COM
+
[assembly: Guid("a16b867e-6b00-4ccc-a368-c9f9b14e0e6a")]
// Version information for an assembly consists of the following four values:
@@ -30,5 +33,6 @@
//
// You can specify all the values or you can default the Build and Revision Numbers
// by using the '*' as shown below:
+
[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/TestHelper.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/TestHelper.cs
index 386ccd7..50fddbf 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/TestHelper.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/TestHelper.cs
@@ -4,7 +4,7 @@
using ClosedXML.Excel;
using ClosedXML_Examples;
using DocumentFormat.OpenXml.Drawing;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
using Path = System.IO.Path;
namespace ClosedXML_Tests
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/ExcelDocsComparer.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/ExcelDocsComparer.cs
index 9def32b..25dc07f 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/ExcelDocsComparer.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/ExcelDocsComparer.cs
@@ -8,9 +8,9 @@
{
public static bool Compare(string left, string right, out string message)
{
- using (var leftStream = File.OpenRead(left))
+ using (FileStream leftStream = File.OpenRead(left))
{
- using (var rightStream = File.OpenRead(right))
+ using (FileStream rightStream = File.OpenRead(right))
{
return Compare(leftStream, rightStream, out message);
}
@@ -27,6 +27,7 @@
}
}
}
+
private static bool ExcludeMethod(Uri uri)
{
//Exclude service data
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/PackageHelper.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/PackageHelper.cs
index 59421c4..ec92716 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/PackageHelper.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/PackageHelper.cs
@@ -18,12 +18,13 @@
{
package.DeletePart(uri);
}
- var part = package.CreatePart(uri, MediaTypeNames.Text.Xml, CompressionOption.Fast);
+ PackagePart part = package.CreatePart(uri, MediaTypeNames.Text.Xml, CompressionOption.Fast);
using (Stream stream = part.GetStream())
{
serializer.Serialize(stream, content);
}
}
+
public static object ReadXmlPart(Package package, Uri uri, XmlSerializer serializer)
{
if (!package.PartExists(uri))
@@ -49,11 +50,12 @@
StreamHelper.StreamToStreamAppend(content, stream);
}
}
+
///
- /// Returns part's stream
+ /// Returns part's stream
///
- ///
- ///
+ ///
+ ///
///
public static Stream ReadBinaryPart(Package package, Uri uri)
{
@@ -69,9 +71,11 @@
{
CopyPart(uri, source, dest, true);
}
+
public static void CopyPart(Uri uri, Package source, Package dest, bool overwrite)
{
#region Check
+
if (ReferenceEquals(uri, null))
{
throw new ArgumentNullException("uri");
@@ -84,7 +88,9 @@
{
throw new ArgumentNullException("dest");
}
+
#endregion
+
if (dest.PartExists(uri))
{
if (!overwrite)
@@ -106,9 +112,11 @@
}
}
- public static void WritePart(Package package, PackagePartDescriptor descriptor, T content, Action serializeAction)
+ public static void WritePart(Package package, PackagePartDescriptor descriptor, T content,
+ Action serializeAction)
{
#region Check
+
if (ReferenceEquals(package, null))
{
throw new ArgumentNullException("package");
@@ -121,7 +129,9 @@
{
throw new ArgumentNullException("serializeAction");
}
+
#endregion
+
if (package.PartExists(descriptor.Uri))
{
package.DeletePart(descriptor.Uri);
@@ -132,9 +142,11 @@
serializeAction(stream, content);
}
}
+
public static void WritePart(Package package, PackagePartDescriptor descriptor, Action serializeAction)
{
#region Check
+
if (ReferenceEquals(package, null))
{
throw new ArgumentNullException("package");
@@ -147,7 +159,9 @@
{
throw new ArgumentNullException("serializeAction");
}
+
#endregion
+
if (package.PartExists(descriptor.Uri))
{
package.DeletePart(descriptor.Uri);
@@ -158,9 +172,11 @@
serializeAction(stream);
}
}
+
public static T ReadPart(Package package, Uri uri, Func deserializeFunc)
{
#region Check
+
if (ReferenceEquals(package, null))
{
throw new ArgumentNullException("package");
@@ -173,7 +189,9 @@
{
throw new ArgumentNullException("deserializeFunc");
}
+
#endregion
+
if (!package.PartExists(uri))
{
throw new ApplicationException(string.Format("Package part '{0}' doesn't exists!", uri.OriginalString));
@@ -184,9 +202,11 @@
return deserializeFunc(stream);
}
}
+
public static void ReadPart(Package package, Uri uri, Action deserializeAction)
{
#region Check
+
if (ReferenceEquals(package, null))
{
throw new ArgumentNullException("package");
@@ -199,7 +219,9 @@
{
throw new ArgumentNullException("deserializeAction");
}
+
#endregion
+
if (!package.PartExists(uri))
{
throw new ApplicationException(string.Format("Package part '{0}' doesn't exists!", uri.OriginalString));
@@ -210,9 +232,11 @@
deserializeAction(stream);
}
}
+
public static bool TryReadPart(Package package, Uri uri, Action deserializeAction)
{
#region Check
+
if (ReferenceEquals(package, null))
{
throw new ArgumentNullException("package");
@@ -225,7 +249,9 @@
{
throw new ArgumentNullException("deserializeAction");
}
+
#endregion
+
if (!package.PartExists(uri))
{
return false;
@@ -239,10 +265,10 @@
}
///
- /// Compare to packages by parts like streams
+ /// Compare to packages by parts like streams
///
- ///
- ///
+ ///
+ ///
///
///
///
@@ -251,18 +277,21 @@
{
return Compare(left, right, compareToFirstDifference, null, out message);
}
+
///
- /// Compare to packages by parts like streams
+ /// Compare to packages by parts like streams
///
- ///
- ///
+ ///
+ ///
///
///
///
///
- public static bool Compare(Package left, Package right, bool compareToFirstDifference,Func excludeMethod, out string message)
+ public static bool Compare(Package left, Package right, bool compareToFirstDifference,
+ Func excludeMethod, out string message)
{
#region Check
+
if (left == null)
{
throw new ArgumentNullException("left");
@@ -271,13 +300,15 @@
{
throw new ArgumentNullException("right");
}
+
#endregion
+
excludeMethod = excludeMethod ?? (uri => false);
- var leftParts = left.GetParts();
- var rightParts = right.GetParts();
+ PackagePartCollection leftParts = left.GetParts();
+ PackagePartCollection rightParts = right.GetParts();
var pairs = new Dictionary();
- foreach (var part in leftParts)
+ foreach (PackagePart part in leftParts)
{
if (excludeMethod(part.Uri))
{
@@ -285,7 +316,7 @@
}
pairs.Add(part.Uri, new PartPair(part.Uri, CompareStatus.OnlyOnLeft));
}
- foreach (var part in rightParts)
+ foreach (PackagePart part in rightParts)
{
if (excludeMethod(part.Uri))
{
@@ -307,31 +338,31 @@
goto EXIT;
}
- foreach (var pair in pairs.Values)
+ foreach (PartPair pair in pairs.Values)
{
if (pair.Status != CompareStatus.Equal)
{
continue;
}
- using (var oneStream = left.GetPart(pair.Uri).GetStream(FileMode.Open, FileAccess.Read))
- using (var otherStream = right.GetPart(pair.Uri).GetStream(FileMode.Open, FileAccess.Read))
+ using (Stream oneStream = left.GetPart(pair.Uri).GetStream(FileMode.Open, FileAccess.Read))
+ using (Stream otherStream = right.GetPart(pair.Uri).GetStream(FileMode.Open, FileAccess.Read))
+ {
+ if (!StreamHelper.Compare(oneStream, otherStream))
{
- if (!StreamHelper.Compare(oneStream, otherStream))
+ pair.Status = CompareStatus.NonEqual;
+ if (compareToFirstDifference)
{
- pair.Status = CompareStatus.NonEqual;
- if (compareToFirstDifference)
- {
- goto EXIT;
- }
+ goto EXIT;
}
}
+ }
}
EXIT:
- var sortedPairs = pairs.Values.ToList();
+ List sortedPairs = pairs.Values.ToList();
sortedPairs.Sort((one, other) => one.Uri.OriginalString.CompareTo(other.Uri.OriginalString));
var sbuilder = new StringBuilder();
- foreach (var pair in sortedPairs)
+ foreach (PartPair pair in sortedPairs)
{
if (pair.Status == CompareStatus.Equal)
{
@@ -343,28 +374,31 @@
message = sbuilder.ToString();
return message.Length == 0;
}
- //--
+
#region Nested type: PackagePartDescriptor
+
public sealed class PackagePartDescriptor
{
#region Private fields
- [DebuggerBrowsable(DebuggerBrowsableState.Never)]
- private readonly Uri _uri;
- [DebuggerBrowsable(DebuggerBrowsableState.Never)]
- private readonly string _contentType;
- [DebuggerBrowsable(DebuggerBrowsableState.Never)]
- private readonly CompressionOption _compressOption;
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly CompressionOption _compressOption;
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly string _contentType;
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly Uri _uri;
+
#endregion
+
#region Constructor
+
///
- /// Instance constructor
+ /// Instance constructor
///
- /// Part uri
- /// Content type from
- ///
+ /// Part uri
+ /// Content type from
+ ///
public PackagePartDescriptor(Uri uri, string contentType, CompressionOption compressOption)
{
#region Check
+
if (ReferenceEquals(uri, null))
{
throw new ArgumentNullException("uri");
@@ -373,38 +407,49 @@
{
throw new ArgumentNullException("contentType");
}
+
#endregion
+
_uri = uri;
_contentType = contentType;
_compressOption = compressOption;
}
+
#endregion
+
#region Public properties
+
public Uri Uri
{
- [DebuggerStepThrough]
- get { return _uri; }
+ [DebuggerStepThrough] get { return _uri; }
}
+
public string ContentType
{
- [DebuggerStepThrough]
- get { return _contentType; }
+ [DebuggerStepThrough] get { return _contentType; }
}
+
public CompressionOption CompressOption
{
- [DebuggerStepThrough]
- get { return _compressOption; }
+ [DebuggerStepThrough] get { return _compressOption; }
}
+
#endregion
+
#region Public methods
+
public override string ToString()
{
return string.Format("Uri:{0} ContentType: {1}, Compression: {2}", _uri, _contentType, _compressOption);
}
+
#endregion
}
+
#endregion
+
#region Nested type: CompareStatus
+
private enum CompareStatus
{
OnlyOnLeft,
@@ -412,38 +457,48 @@
Equal,
NonEqual
}
+
#endregion
+
#region Nested type: PartPair
+
private sealed class PartPair
{
#region Private fields
- [DebuggerBrowsable(DebuggerBrowsableState.Never)]
- private readonly Uri _uri;
- [DebuggerBrowsable(DebuggerBrowsableState.Never)]
- private CompareStatus _status;
+
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)] private readonly Uri _uri;
+ [DebuggerBrowsable(DebuggerBrowsableState.Never)] private CompareStatus _status;
+
#endregion
+
#region Constructor
+
public PartPair(Uri uri, CompareStatus status)
{
_uri = uri;
_status = status;
}
+
#endregion
+
#region Public properties
+
public Uri Uri
{
- [DebuggerStepThrough]
- get { return _uri; }
+ [DebuggerStepThrough] get { return _uri; }
}
+
public CompareStatus Status
{
- [DebuggerStepThrough]
- get { return _status; }
- [DebuggerStepThrough]
- set { _status = value; }
+ [DebuggerStepThrough] get { return _status; }
+ [DebuggerStepThrough] set { _status = value; }
}
+
#endregion
}
+
#endregion
+
+ //--
}
}
\ No newline at end of file
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/StreamHelper.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/StreamHelper.cs
index 81c842a..b5d4062 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/StreamHelper.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/Utils/StreamHelper.cs
@@ -4,19 +4,19 @@
namespace ClosedXML_Tests
{
///
- /// Help methods for work with streams
+ /// Help methods for work with streams
///
public static class StreamHelper
{
///
- /// Convert stream to byte array
+ /// Convert stream to byte array
///
- /// Stream
+ /// Stream
/// Byte array
public static byte[] StreamToArray(Stream pStream)
{
long iLength = pStream.Length;
- byte[] bytes = new byte[iLength];
+ var bytes = new byte[iLength];
for (int i = 0; i < iLength; i++)
{
bytes[i] = (byte) pStream.ReadByte();
@@ -24,15 +24,17 @@
pStream.Close();
return bytes;
}
+
///
- /// Convert byte array to stream
+ /// Convert byte array to stream
///
- /// Byte array
- /// Open stream
+ /// Byte array
+ /// Open stream
///
public static Stream ArrayToStreamAppend(byte[] pBynaryArray, Stream pStream)
{
#region Check params
+
if (ReferenceEquals(pBynaryArray, null))
{
throw new ArgumentNullException("pBynaryArray");
@@ -45,7 +47,9 @@
{
throw new ArgumentException("Can't write to stream", "pStream");
}
+
#endregion
+
foreach (byte b in pBynaryArray)
{
pStream.WriteByte(b);
@@ -57,9 +61,11 @@
{
StreamToStreamAppend(streamIn, streamToWrite, 0);
}
+
public static void StreamToStreamAppend(Stream streamIn, Stream streamToWrite, long dataLength)
{
#region Check params
+
if (ReferenceEquals(streamIn, null))
{
throw new ArgumentNullException("streamIn");
@@ -76,8 +82,10 @@
{
throw new ArgumentException("Can't write to stream", "streamToWrite");
}
+
#endregion
- byte[] buf = new byte[512];
+
+ var buf = new byte[512];
long length;
if (dataLength == 0)
{
@@ -97,14 +105,15 @@
}
///
- /// Compare two streams by looping
+ /// Compare two streams by looping
///
- ///
- ///
+ ///
+ ///
///
public static bool Compare(Stream one, Stream other)
{
#region Check
+
if (one == null)
{
throw new ArgumentNullException("one");
@@ -121,7 +130,9 @@
{
throw new ArgumentException("Must be in position 0", "other");
}
+
#endregion
+
if (one.Length != other.Length)
{
return false;
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/XLHelperTests.cs b/ClosedXML/ClosedXML/ClosedXML_Tests/XLHelperTests.cs
index a4c9658..a73cc75 100644
--- a/ClosedXML/ClosedXML/ClosedXML_Tests/XLHelperTests.cs
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/XLHelperTests.cs
@@ -1,24 +1,21 @@
using ClosedXML.Excel;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System;
+using NUnit.Framework;
namespace ClosedXML_Tests
{
- ///
- /// This is a test class for XLHelperTests and is intended
- /// to contain all XLHelperTests Unit Tests
- ///
- [TestClass]
+ ///
+ /// This is a test class for XLHelperTests and is intended
+ /// to contain all XLHelperTests Unit Tests
+ ///
+ [TestFixture]
public class XLHelperTests
{
- ///
- /// Gets or sets the test context which provides
- /// information about and functionality for the current test run.
- ///
+ ///
+ /// 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:
//
@@ -47,12 +44,10 @@
//}
//
- #endregion
-
- ///
- /// A test for IsValidColumn
- ///
- [TestMethod]
+ ///
+ /// A test for IsValidColumn
+ ///
+ [Test]
public void IsValidColumnTest()
{
Assert.AreEqual(false, XLHelper.IsValidColumn(""));
@@ -70,87 +65,87 @@
Assert.AreEqual(false, XLHelper.IsValidColumn("XFZ"));
}
- [TestMethod]
+ [Test]
public void ReplaceRelative1()
{
- var result = XLHelper.ReplaceRelative("A1", 2, "B");
+ string result = XLHelper.ReplaceRelative("A1", 2, "B");
Assert.AreEqual("B2", result);
}
- [TestMethod]
+ [Test]
public void ReplaceRelative2()
{
- var result = XLHelper.ReplaceRelative("$A1", 2, "B");
+ string result = XLHelper.ReplaceRelative("$A1", 2, "B");
Assert.AreEqual("$A2", result);
}
- [TestMethod]
+ [Test]
public void ReplaceRelative3()
{
- var result = XLHelper.ReplaceRelative("A$1", 2, "B");
+ string result = XLHelper.ReplaceRelative("A$1", 2, "B");
Assert.AreEqual("B$1", result);
}
- [TestMethod]
+ [Test]
public void ReplaceRelative4()
{
- var result = XLHelper.ReplaceRelative("$A$1", 2, "B");
+ string result = XLHelper.ReplaceRelative("$A$1", 2, "B");
Assert.AreEqual("$A$1", result);
}
- [TestMethod]
+ [Test]
public void ReplaceRelative5()
{
- var result = XLHelper.ReplaceRelative("1:1", 2, "B");
+ string result = XLHelper.ReplaceRelative("1:1", 2, "B");
Assert.AreEqual("2:2", result);
}
- [TestMethod]
+ [Test]
public void ReplaceRelative6()
{
- var result = XLHelper.ReplaceRelative("$1:1", 2, "B");
+ string result = XLHelper.ReplaceRelative("$1:1", 2, "B");
Assert.AreEqual("$1:2", result);
}
- [TestMethod]
+ [Test]
public void ReplaceRelative7()
{
- var result = XLHelper.ReplaceRelative("1:$1", 2, "B");
+ string result = XLHelper.ReplaceRelative("1:$1", 2, "B");
Assert.AreEqual("2:$1", result);
}
- [TestMethod]
+ [Test]
public void ReplaceRelative8()
{
- var result = XLHelper.ReplaceRelative("$1:$1", 2, "B");
+ string result = XLHelper.ReplaceRelative("$1:$1", 2, "B");
Assert.AreEqual("$1:$1", result);
}
- [TestMethod]
+ [Test]
public void ReplaceRelative9()
{
- var result = XLHelper.ReplaceRelative("A:A", 2, "B");
+ string result = XLHelper.ReplaceRelative("A:A", 2, "B");
Assert.AreEqual("B:B", result);
}
- [TestMethod]
+ [Test]
public void ReplaceRelativeA()
{
- var result = XLHelper.ReplaceRelative("$A:A", 2, "B");
+ string result = XLHelper.ReplaceRelative("$A:A", 2, "B");
Assert.AreEqual("$A:B", result);
}
- [TestMethod]
+ [Test]
public void ReplaceRelativeB()
{
- var result = XLHelper.ReplaceRelative("A:$A", 2, "B");
+ string result = XLHelper.ReplaceRelative("A:$A", 2, "B");
Assert.AreEqual("B:$A", result);
}
- [TestMethod]
+ [Test]
public void ReplaceRelativeC()
{
- var result = XLHelper.ReplaceRelative("$A:$A", 2, "B");
+ string result = XLHelper.ReplaceRelative("$A:$A", 2, "B");
Assert.AreEqual("$A:$A", result);
}
}
diff --git a/ClosedXML/ClosedXML/ClosedXML_Tests/packages.config b/ClosedXML/ClosedXML/ClosedXML_Tests/packages.config
new file mode 100644
index 0000000..7790181
--- /dev/null
+++ b/ClosedXML/ClosedXML/ClosedXML_Tests/packages.config
@@ -0,0 +1,5 @@
+
+
+
+
+
\ No newline at end of file