Added / adapted test cases

Author: rabanti-github

MigrationGuide.md

@@ -279,15 +279,22 @@ fill3.ForegroundColor = Color.CreateTheme(Theme.ColorSchemeElement.Accent1, 0.5f
 Fill fill4 = "FF00FF00"; // Implicit conversion to SrgbColor as foreground
 
 // Implicit creation of fill from a int (indexed color):
-Fill fill5 = 64; // Implicit conversion to IndexedColor as foreground
+Fill fill5 = IndexedColor.Value.Red2; // Implicit conversion to IndexedColor as foreground
+
+// Implicit creation of fill from a int (indexed color):
+Fill fill6 = 64; // Implicit conversion to IndexedColor as foreground, ising the index number
 
 // Implicit creation of specific color from a string (ARGB):
-Fill fill6 = new Fill();
-fill6.ForegroundColor = "FF00FF00"; // Implicit conversion to SrgbColor
+Fill fill7 = new Fill();
+fill7.ForegroundColor = "FF00FF00"; // Implicit conversion to SrgbColor
+
+// Implicit creation of fill from a int (indexed color):
+Fill fill8 = new Fill();
+Fill fill8.BackgroundColor = IndexedColor.Value.Black; // Implicit conversion to IndexedColor as background
 
 // Implicit creation of specific color from a int (color index):
-Fill fill7 = new Fill();
-fill7.BackgroundColor = 63; // Implicit conversion to IndexedColor
+Fill fill9 = new Fill();
+fill9.BackgroundColor = 63; // Implicit conversion to IndexedColor
 ```
 
 

NanoXLSX.Core/Colors/Color.cs

@@ -323,13 +323,23 @@ public static implicit operator Color(string rgbValue)
         /// <summary>
         /// Implicit conversion from index number to Color.
         /// </summary>
-        /// <param name="colorIndex">Index (<see cref="IndexedColor.ColorValue"/>)</param>
+        /// <param name="colorIndex">Numeric value of the color index (<see cref="IndexedColor.ColorValue"/>)</param>
         /// \remark <remarks>The resulting color value will be of the type <see cref="IndexedColor"/>, if valid</remarks>
         public static implicit operator Color(int colorIndex)
         {
             return CreateIndexed(colorIndex);
         }
 
+        /// <summary>
+        /// Implicit conversion from index number to Color.
+        /// </summary>
+        /// <param name="colorIndex">Index (<see cref="IndexedColor.ColorValue"/>)</param>
+        /// \remark <remarks>The resulting color value will be of the type <see cref="IndexedColor"/>, if valid</remarks>
+        public static implicit operator Color(IndexedColor.Value colorIndex)
+        {
+            return CreateIndexed(colorIndex);
+        }
+
 
         /// <summary>
         /// Determines whether the specified object is equal to the current object

NanoXLSX.Core/Styles/Fill.cs

@@ -137,7 +137,6 @@ public Fill(string foreground, string background)
         {
             BackgroundColor = Color.CreateRgb(background);
             ForegroundColor = Color.CreateRgb(foreground);
-           // IndexedColor = DefaultIndexedColor;
             PatternFill = PatternValue.Solid;
         }
 
@@ -267,7 +266,19 @@ public static implicit operator Fill(string value)
         }
 
         /// <summary>
-        /// Implicit operator to create a Fill object from an indexed color value as foreground color with <see cref="FillType.FillColor"/> 
+        /// Implicit operator to create a Fill object from an indexed color value (<see cref="IndexedColor.Value"/>) as foreground color with <see cref="FillType.FillColor"/> 
+        /// </summary>
+        /// <param name="index">Color index (0 to 65)</param>
+        public static implicit operator Fill(IndexedColor.Value index)
+        {
+            Fill fill = new Fill();
+            fill.PatternFill = PatternValue.Solid;
+            fill.ForegroundColor = Color.CreateIndexed(index);
+            return fill;
+        }
+
+        /// <summary>
+        /// Implicit operator to create a Fill object from an indexed color index (numeric) as foreground color with <see cref="FillType.FillColor"/> 
         /// </summary>
         /// <param name="index">Color index (0 to 65)</param>
         public static implicit operator Fill(int index)

NanoXLSX.Writer-Reader.Test/Workbooks/WorkbookTest.cs

@@ -583,7 +583,7 @@ public void AddMruColorTest()
             Assert.Equal("FFAABBCC", workbook.GetMruColors()[0]);
         }
 
-        [Fact(DisplayName = "Test of the AddMruColor function for color objects")]
+        [Fact(DisplayName = "Test of the AddMruColor function for ARGB values")]
         public void AddMruColorTest2()
         {
             Workbook workbook = new Workbook();
@@ -594,6 +594,16 @@ public void AddMruColorTest2()
             Assert.Equal("FFAABBCC", workbook.GetMruColors()[0]);
         }
 
+        [Fact(DisplayName = "Test of the AddMruColor function for indexed values")]
+        public void AddMruColorTest3()
+        {
+            Workbook workbook = new Workbook();
+            Assert.Empty(workbook.GetMruColors());
+            Color color = "AABBCC"; // implicit conversion
+            workbook.AddMruColor(color);
+            Assert.Equal(1, workbook.GetMruColors().Count);
+            Assert.Equal("FFAABBCC", workbook.GetMruColors()[0]);
+        }
 
         [Theory(DisplayName = "Test of the failing AddMruColor function when adding an invalid color value")]
         [InlineData(null)]

NanoXLSX.Writer-Reader.Test/Workbooks/WorkbookWriteReadTest.cs

@@ -30,7 +30,7 @@ public void StringProcessingTest()
             Assert.Equal("Text1", givenWorkbook.CurrentWorksheet.Cells["A5"].Value.ToString());
         }
 
-        [Fact(DisplayName = "Test of the (virtual) 'MruColors' property when writing and reading a workbook")]
+        [Fact(DisplayName = "Test of the (virtual) 'MruColors' property on a ARGB value, when writing and reading a workbook")]
         public void ReadMruColorsTest()
         {
             Workbook workbook = new Workbook();
@@ -46,8 +46,24 @@ public void ReadMruColorsTest()
             Assert.Equal("FF" + color2, mruColors[1].GetArgbValue());
         }
 
-        [Fact(DisplayName = "Test of the (virtual) 'MruColors' property when writing and reading a workbook, neglecting the default color")]
+
+        [Fact(DisplayName = "Test of the (virtual) 'MruColors' property on a indexed color, when writing and reading a workbook")]
         public void ReadMruColorsTest2()
+        {
+            Workbook workbook = new Workbook();
+            workbook.AddMruColor(IndexedColor.Value.Blue4);
+            workbook.AddMruColor(IndexedColor.Value.StrongYellow);
+            Workbook givenWorkbook = TestUtils.WriteAndReadWorkbook(workbook);
+            List<Color> mruColors = ((List<Color>)givenWorkbook.GetMruColors());
+            mruColors.Sort();
+            Assert.Equal(2, mruColors.Count);
+            Assert.Equal(IndexedColor.GetArgbValue(IndexedColor.Value.Blue4), mruColors[0].GetArgbValue());
+            Assert.Equal(IndexedColor.GetArgbValue(IndexedColor.Value.StrongYellow), mruColors[1].GetArgbValue());
+        }
+
+
+        [Fact(DisplayName = "Test of the (virtual) 'MruColors' property when writing and reading a workbook, neglecting the default color")]
+        public void ReadMruColorsTest3()
         {
             Workbook workbook = new Workbook();
             string color1 = "AACC00";
@@ -61,6 +77,17 @@ public void ReadMruColorsTest2()
             Assert.Equal("FF" + color1, mruColors[0].GetArgbValue());
         }
 
+        [Fact(DisplayName = "Test of the (virtual) 'MruColors' property when writing and reading a workbook, neglecting an undefined color")]
+        public void ReadMruColorsTest4()
+        {
+            Workbook workbook = new Workbook();
+            Color color = Color.CreateNone();
+            workbook.AddMruColor(color);
+            Workbook givenWorkbook = TestUtils.WriteAndReadWorkbook(workbook);
+            List<Color> mruColors = ((List<Color>)givenWorkbook.GetMruColors());
+            Assert.Empty(mruColors);
+        }
+
         [Theory(DisplayName = "Test of the 'Hidden' property when writing and reading a workbook")]
         [InlineData(true)]
         [InlineData(false)]

NanoXLSX.Writer/Internal/Writers/ColorWriter.cs

@@ -26,13 +26,10 @@ internal class ColorWriter : IColorWriter
         /// </summary>
         /// <param name="color">Color instance</param>
         /// <returns>Enumeration of the attributes, describing the color instance</returns>
+        /// \remark <remarks>The passed color instance may never be null. Such cases have to be handled earlier</remarks>
         public IEnumerable<XmlAttribute> GetAttributes(Color color)
         {
             List<XmlAttribute> attributes = new List<XmlAttribute>();
-            if (color == null)
-            {
-                return attributes;
-            }
             string name = GetAttributeName(color);
             if (name != null)
             {
@@ -51,12 +48,9 @@ public IEnumerable<XmlAttribute> GetAttributes(Color color)
         /// </summary>
         /// <param name="color">Color instance</param>
         /// <returns>Attribute name</returns>
+        /// \remark <remarks>The passed color instance may never be null. Such cases have to be handled earlier</remarks>
         public string GetAttributeName(Color color)
         {
-            if (color == null)
-            {
-                return null;
-            }
             switch (color.Type)
             {
                 case Color.ColorType.Auto:
@@ -79,27 +73,29 @@ public string GetAttributeName(Color color)
         /// </summary>
         /// <param name="color">Color instance</param>
         /// <returns>Attribute value</returns>
+        /// \remark <remarks>The passed color instance may never be null. Such cases have to be handled earlier</remarks>
         public string GetAttributeValue(Color color)
         {
-            if (color == null)
-            {
-                return null;
-            }
+            string value = null;
             switch (color.Type)
             {
                 case Color.ColorType.Auto:
-                    return "1";
+                    value = "1";
+                    break;
                 case Color.ColorType.Rgb:
-                    return color.RgbColor.StringValue;
+                    value = color.RgbColor.StringValue;
+                    break;
                 case Color.ColorType.Indexed:
-                    return color.IndexedColor.StringValue;
+                    value = color.IndexedColor.StringValue;
+                    break;
                 case Color.ColorType.Theme:
-                    return color.ThemeColor.StringValue;
+                    value = color.ThemeColor.StringValue;
+                    break;
                 case Color.ColorType.System:
-                    return color.SystemColor.StringValue;
-                default:
-                    return null;
+                    value = color.SystemColor.StringValue;
+                    break;
             }
+            return value;
         }
 
         /// <summary>

NanoXlsx.Core.Test/Colors/ColorTest.cs

@@ -206,12 +206,27 @@ public void ImplicitRgbConversionTest(string givrnRgb, string expectedRgb)
             Assert.Equal(expectedRgb, color.GetArgbValue(), ignoreCase: true);
         }
 
+        [Theory(DisplayName = "Test of the implicit operator function, when using a value of IndexedColor.Value")]
+        [InlineData(IndexedColor.Value.Black)]
+        [InlineData(IndexedColor.Value.Black0)]
+        [InlineData(IndexedColor.Value.Cyan)]
+        [InlineData(IndexedColor.Value.SystemBackground)]
+        [InlineData(IndexedColor.Value.SystemForeground)]
+        public void ImplicitIndexedConversionTest(IndexedColor.Value index)
+        {
+            Color color = index;
+            Assert.Equal(Color.ColorType.Indexed, color.Type);
+            Assert.NotNull(color.GetArgbValue());
+            Assert.Equal(index, color.IndexedColor.ColorValue);
+        }
+
+
         [Theory(DisplayName = "Test of the implicit operator function, when using an int")]
         [InlineData(5)]
         [InlineData(0)]
         [InlineData(22)]
         [InlineData(65)]
-        public void ImplicitIndexedConversionTest(int index)
+        public void ImplicitIndexedConversionTest2(int index)
         {
             Color color = index;
             Assert.Equal(Color.ColorType.Indexed, color.Type);

NanoXlsx.Core.Test/Styles/FillTest.cs

@@ -333,13 +333,30 @@ public void ImplicitOperatorTest(string value)
             Assert.Equal(fill.BackgroundColor, expectedFill.BackgroundColor);
         }
 
+
+        [Theory(DisplayName = "Test of the implicit operator (create indexed color by enum value)")]
+        [InlineData(IndexedColor.Value.Red)]
+        [InlineData(IndexedColor.Value.Black0)]
+        [InlineData(IndexedColor.Value.Black)]
+        [InlineData(IndexedColor.Value.SystemForeground)]
+        [InlineData(IndexedColor.Value.SystemBackground)]
+        public void ImplicitOperatorTest3(IndexedColor.Value value)
+        {
+            Fill fill = value;
+            Fill expectedFill = new Fill();
+            expectedFill.ForegroundColor = Color.CreateIndexed(value);
+            expectedFill.PatternFill = PatternValue.Solid;
+            Assert.Equal(fill.ForegroundColor, expectedFill.ForegroundColor);
+            Assert.Equal(fill.BackgroundColor, expectedFill.BackgroundColor);
+        }
+
         [Theory(DisplayName = "Test of the implicit operator (create indexed color by int)")]
         [InlineData(10, IndexedColor.Value.Red)]
         [InlineData(0, IndexedColor.Value.Black0)]
         [InlineData(8, IndexedColor.Value.Black)]
         [InlineData(64, IndexedColor.Value.SystemForeground)]
         [InlineData(65, IndexedColor.Value.SystemBackground)]
-        public void ImplicitOperatorTest3(int givenValue, IndexedColor.Value expectedValue)
+        public void ImplicitOperatorTest4(int givenValue, IndexedColor.Value expectedValue)
         {
             Fill fill = givenValue;
             Fill expectedFill = new Fill();