refactor: SOLID/Clean Architecture reorganization, fix all tests, bump to v2.0.0

QRCoder.Core.Tests/Exceptions/DataTooLongExceptionTests.cs

@@ -0,0 +1,48 @@
+using QRCoder.Core.Exceptions;
+using QRCoder.Core.Generators;
+using Shouldly;
+using Xunit;
+
+namespace QRCoder.Core.Tests.Exceptions
+{
+    public class DataTooLongExceptionTests
+    {
+        [Fact]
+        public void constructor_without_version_formats_message()
+        {
+            var ex = new DataTooLongException("H", "Byte", 100);
+            ex.Message.ShouldContain("ECC level=H");
+            ex.Message.ShouldContain("EncodingMode=Byte");
+            ex.Message.ShouldContain("100 byte");
+        }
+
+        [Fact]
+        public void constructor_with_version_formats_message()
+        {
+            var ex = new DataTooLongException("Q", "Alphanumeric", 5, 200);
+            ex.Message.ShouldContain("ECC level=Q");
+            ex.Message.ShouldContain("EncodingMode=Alphanumeric");
+            ex.Message.ShouldContain("FixedVersion=5");
+            ex.Message.ShouldContain("200 byte");
+        }
+
+        [Fact]
+        public void data_too_long_is_thrown_for_oversized_payload()
+        {
+            var longText = new string('A', 10000);
+            using (var gen = new QRCodeGenerator())
+            {
+                Should.Throw<DataTooLongException>(() =>
+                    gen.CreateQrCode(longText, QRCodeGenerator.ECCLevel.H));
+            }
+        }
+
+        [Fact]
+        public void data_too_long_with_fixed_version()
+        {
+            var text = new string('A', 500);
+            Should.Throw<DataTooLongException>(() =>
+                QRCodeGenerator.GenerateQrCode(text, QRCodeGenerator.ECCLevel.H, requestedVersion: 1));
+        }
+    }
+}

QRCoder.Core.Tests/Extensions/SKColorExtensionsTests.cs

@@ -0,0 +1,88 @@
+using QRCoder.Core.Extensions;
+using Shouldly;
+using SkiaSharp;
+using Xunit;
+
+namespace QRCoder.Core.Tests.Extensions
+{
+    public class SKColorExtensionsTests
+    {
+        [Fact]
+        public void to_hex_returns_argb_format()
+        {
+            var color = new SKColor(255, 0, 0, 255); // Red, fully opaque
+            var hex = color.ToHex();
+            hex.ShouldBe("#FFFF0000");
+        }
+
+        [Fact]
+        public void to_hex_with_transparency()
+        {
+            var color = new SKColor(0, 128, 255, 128);
+            var hex = color.ToHex();
+            hex.ShouldBe("#800080FF");
+        }
+
+        [Fact]
+        public void to_hex_black()
+        {
+            var hex = SKColors.Black.ToHex();
+            hex.ShouldBe("#FF000000");
+        }
+
+        [Fact]
+        public void to_hex_white()
+        {
+            var hex = SKColors.White.ToHex();
+            hex.ShouldBe("#FFFFFFFF");
+        }
+
+        [Fact]
+        public void from_hex_6_digit_rgb()
+        {
+            var color = SKColorExtensions.FromHex("#FF0000");
+            color.Red.ShouldBe((byte)255);
+            color.Green.ShouldBe((byte)0);
+            color.Blue.ShouldBe((byte)0);
+        }
+
+        [Fact]
+        public void from_hex_8_digit_argb()
+        {
+            var color = SKColorExtensions.FromHex("#80FF0000");
+            color.Red.ShouldBe((byte)255);
+            color.Green.ShouldBe((byte)0);
+            color.Blue.ShouldBe((byte)0);
+        }
+
+        [Fact]
+        public void from_hex_without_hash()
+        {
+            var color = SKColorExtensions.FromHex("00FF00");
+            color.Red.ShouldBe((byte)0);
+            color.Green.ShouldBe((byte)255);
+            color.Blue.ShouldBe((byte)0);
+        }
+
+        [Fact]
+        public void from_hex_null_returns_transparent()
+        {
+            var color = SKColorExtensions.FromHex(null);
+            color.ShouldBe(SKColors.Transparent);
+        }
+
+        [Fact]
+        public void from_hex_empty_returns_transparent()
+        {
+            var color = SKColorExtensions.FromHex("");
+            color.ShouldBe(SKColors.Transparent);
+        }
+
+        [Fact]
+        public void from_hex_invalid_length_returns_transparent()
+        {
+            var color = SKColorExtensions.FromHex("#FFF");
+            color.ShouldBe(SKColors.Transparent);
+        }
+    }
+}

QRCoder.Core.Tests/Extensions/StringValueAttributeTests.cs

@@ -0,0 +1,38 @@
+using QRCoder.Core.Extensions;
+using Shouldly;
+using Xunit;
+
+namespace QRCoder.Core.Tests.Extensions
+{
+    public class StringValueAttributeTests
+    {
+        private enum TestEnum
+        {
+            [StringValue("value_one")]
+            One,
+            [StringValue("value_two")]
+            Two,
+            NoAttribute
+        }
+
+        [Fact]
+        public void string_value_attribute_stores_value()
+        {
+            var attr = new StringValueAttribute("test");
+            attr.StringValue.ShouldBe("test");
+        }
+
+        [Fact]
+        public void get_string_value_returns_attribute_value()
+        {
+            TestEnum.One.GetStringValue().ShouldBe("value_one");
+            TestEnum.Two.GetStringValue().ShouldBe("value_two");
+        }
+
+        [Fact]
+        public void get_string_value_returns_null_when_no_attribute()
+        {
+            TestEnum.NoAttribute.GetStringValue().ShouldBeNull();
+        }
+    }
+}

QRCoder.Core.Tests/BestPracticesTests.cs → QRCoder.Core.Tests/Generators/BestPracticesTests.cs

@@ -3,6 +3,10 @@
 using System.IO;
 using System.Text;
 using QRCoder.Core;
+using QRCoder.Core.Abstractions;
+using QRCoder.Core.Generators;
+using QRCoder.Core.Models;
+using QRCoder.Core.Renderers;
 using QRCoder.Core.Exceptions;
 using QRCoder.Core.Extensions;
 using QRCoder.Core.Tests.Helpers;

QRCoder.Core.Tests/LowCoverageTests.cs → QRCoder.Core.Tests/Generators/LowCoverageTests.cs

@@ -2,6 +2,10 @@
 using System.IO;
 using System.Linq;
 using QRCoder.Core;
+using QRCoder.Core.Abstractions;
+using QRCoder.Core.Generators;
+using QRCoder.Core.Models;
+using QRCoder.Core.Renderers;
 using QRCoder.Core.Exceptions;
 using QRCoder.Core.Extensions;
 using QRCoder.Core.Tests.Helpers.XUnitExtenstions;

QRCoder.Core.Tests/PayloadGeneratorTests.cs → QRCoder.Core.Tests/Generators/PayloadGeneratorTests.cs

@@ -1,13 +1,14 @@
-using QRCoder.Core.Tests.Helpers.XUnitExtenstions;
+using QRCoder.Core.Generators;
+using QRCoder.Core.Tests.Helpers.XUnitExtenstions;
 using Shouldly;
 using System;
 using System.Globalization;
 using System.Reflection;
 using System.Threading;
 using Xunit;
-using static QRCoder.Core.PayloadGenerator.BezahlCode;
-using static QRCoder.Core.PayloadGenerator.SwissQrCode.AdditionalInformation;
-using static QRCoder.Core.PayloadGenerator.SwissQrCode.Reference;
+using static QRCoder.Core.Generators.PayloadGenerator.BezahlCode;
+using static QRCoder.Core.Generators.PayloadGenerator.SwissQrCode.AdditionalInformation;
+using static QRCoder.Core.Generators.PayloadGenerator.SwissQrCode.Reference;
 
 namespace QRCoder.Core.Tests
 {

QRCoder.Core.Tests/Generators/QRCodeGeneratorEdgeCaseTests.cs

@@ -0,0 +1,175 @@
+using System;
+using QRCoder.Core.Generators;
+using QRCoder.Core.Models;
+using Shouldly;
+using Xunit;
+
+namespace QRCoder.Core.Tests.Generators
+{
+    public class QRCodeGeneratorEdgeCaseTests
+    {
+        [Theory]
+        [InlineData(QRCodeGenerator.ECCLevel.L)]
+        [InlineData(QRCodeGenerator.ECCLevel.M)]
+        [InlineData(QRCodeGenerator.ECCLevel.Q)]
+        [InlineData(QRCodeGenerator.ECCLevel.H)]
+        public void all_ecc_levels_generate_valid_data(QRCodeGenerator.ECCLevel level)
+        {
+            using (var gen = new QRCodeGenerator())
+            using (var data = gen.CreateQrCode("Test", level))
+            {
+                data.ShouldNotBeNull();
+                data.ModuleMatrix.Count.ShouldBeGreaterThan(0);
+            }
+        }
+
+        [Fact]
+        public void empty_string_generates_valid_qrcode()
+        {
+            using (var gen = new QRCodeGenerator())
+            using (var data = gen.CreateQrCode("", QRCodeGenerator.ECCLevel.L))
+            {
+                data.ShouldNotBeNull();
+                data.ModuleMatrix.Count.ShouldBeGreaterThan(0);
+            }
+        }
+
+        [Fact]
+        public void unicode_text_generates_valid_qrcode()
+        {
+            using (var gen = new QRCodeGenerator())
+            using (var data = gen.CreateQrCode("こんにちは世界 🌍", QRCodeGenerator.ECCLevel.M, forceUtf8: true))
+            {
+                data.ShouldNotBeNull();
+                data.ModuleMatrix.Count.ShouldBeGreaterThan(0);
+            }
+        }
+
+        [Fact]
+        public void numeric_only_input()
+        {
+            using (var gen = new QRCodeGenerator())
+            using (var data = gen.CreateQrCode("1234567890", QRCodeGenerator.ECCLevel.L))
+            {
+                data.ShouldNotBeNull();
+                data.Version.ShouldBe(1);
+            }
+        }
+
+        [Fact]
+        public void alphanumeric_input()
+        {
+            using (var gen = new QRCodeGenerator())
+            using (var data = gen.CreateQrCode("HELLO WORLD", QRCodeGenerator.ECCLevel.L))
+            {
+                data.ShouldNotBeNull();
+            }
+        }
+
+        [Fact]
+        public void binary_data_generates_valid_qrcode()
+        {
+            var binaryData = new byte[] { 0x00, 0x01, 0x02, 0xFF, 0xFE };
+            using (var data = QRCodeGenerator.GenerateQrCode(binaryData, QRCodeGenerator.ECCLevel.M))
+            {
+                data.ShouldNotBeNull();
+                data.ModuleMatrix.Count.ShouldBeGreaterThan(0);
+            }
+        }
+
+        [Fact]
+        public void force_utf8_with_bom()
+        {
+            using (var gen = new QRCodeGenerator())
+            using (var data = gen.CreateQrCode("Test UTF8 BOM", QRCodeGenerator.ECCLevel.L, forceUtf8: true, utf8BOM: true))
+            {
+                data.ShouldNotBeNull();
+            }
+        }
+
+        [Theory]
+        [InlineData(1)]
+        [InlineData(10)]
+        [InlineData(20)]
+        public void requested_version_is_respected(int version)
+        {
+            using (var data = QRCodeGenerator.GenerateQrCode("Test", QRCodeGenerator.ECCLevel.L, requestedVersion: version))
+            {
+                data.ShouldNotBeNull();
+                data.Version.ShouldBe(version);
+            }
+        }
+
+        [Fact]
+        public void static_generate_matches_instance_create()
+        {
+            using (var gen = new QRCodeGenerator())
+            using (var data1 = gen.CreateQrCode("Test", QRCodeGenerator.ECCLevel.M))
+            using (var data2 = QRCodeGenerator.GenerateQrCode("Test", QRCodeGenerator.ECCLevel.M))
+            {
+                data1.Version.ShouldBe(data2.Version);
+                data1.ModuleMatrix.Count.ShouldBe(data2.ModuleMatrix.Count);
+            }
+        }
+
+        [Fact]
+        public void payload_based_generation()
+        {
+            var payload = new PayloadGenerator.Url("https://github.com");
+            using (var gen = new QRCodeGenerator())
+            using (var data = gen.CreateQrCode(payload))
+            {
+                data.ShouldNotBeNull();
+                data.ModuleMatrix.Count.ShouldBeGreaterThan(0);
+            }
+        }
+
+        [Fact]
+        public void payload_based_generation_with_ecc()
+        {
+            var payload = new PayloadGenerator.Url("https://github.com");
+            using (var data = QRCodeGenerator.GenerateQrCode(payload, QRCodeGenerator.ECCLevel.H))
+            {
+                data.ShouldNotBeNull();
+            }
+        }
+
+        [Fact]
+        public void dispose_works_without_exception()
+        {
+            var gen = new QRCodeGenerator();
+            gen.Dispose();
+        }
+
+        [Fact]
+        public void special_characters_in_input()
+        {
+            using (var gen = new QRCodeGenerator())
+            using (var data = gen.CreateQrCode("!@#$%^&*()_+-=[]{}|;':\",./<>?", QRCodeGenerator.ECCLevel.M))
+            {
+                data.ShouldNotBeNull();
+            }
+        }
+
+        [Fact]
+        public void url_with_query_params()
+        {
+            using (var gen = new QRCodeGenerator())
+            using (var data = gen.CreateQrCode("https://example.com/path?key=value&foo=bar#section", QRCodeGenerator.ECCLevel.Q))
+            {
+                data.ShouldNotBeNull();
+            }
+        }
+
+        [Fact]
+        public void higher_ecc_produces_larger_matrix()
+        {
+            using (var gen = new QRCodeGenerator())
+            using (var dataL = gen.CreateQrCode("Same text for comparison", QRCodeGenerator.ECCLevel.L))
+            using (var dataH = gen.CreateQrCode("Same text for comparison", QRCodeGenerator.ECCLevel.H))
+            {
+                dataH.ModuleMatrix.Count.ShouldBeGreaterThanOrEqualTo(dataL.ModuleMatrix.Count);
+            }
+        }
+    }
+}

QRCoder.Core.Tests/QRGeneratorTests.cs → QRCoder.Core.Tests/Generators/QRGeneratorTests.cs

@@ -1,3 +1,5 @@
+using QRCoder.Core.Generators;
+using QRCoder.Core.Models;
 using QRCoder.Core.Tests.Helpers.XUnitExtenstions;
 using Shouldly;
 using System.Collections;