diff --git a/.github/workflows/dotnet-desktop.yml b/.github/workflows/dotnet-desktop.yml
index a4ed437..0a5a46d 100644
--- a/.github/workflows/dotnet-desktop.yml
+++ b/.github/workflows/dotnet-desktop.yml
@@ -28,9 +28,19 @@ jobs:
       - name: Restore dependencies
         run: dotnet restore
 
+      - name: Bump & push tag
+        if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+        uses: mathieudutour/github-tag-action@v6.2
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          tag_prefix: ""
+
       - name: Build
         run: dotnet build --configuration Release --no-restore
   
+      - name: Test
+        run: dotnet test --configuration Release --no-build
+
       - name: Publish Nuget
         shell: pwsh
         run: |
diff --git a/FluentLoggerExtensions.slnx b/FluentLoggerExtensions.slnx
index 150dff5..110d30d 100644
--- a/FluentLoggerExtensions.slnx
+++ b/FluentLoggerExtensions.slnx
@@ -1,6 +1,8 @@
 <Solution>
   <Folder Name="/Solution Items/">
     <File Path=".github/workflows/dotnet-desktop.yml" />
+    <File Path="README.md" />
   </Folder>
-  <Project Path="FluentLoggerExtensions.csproj" />
+  <Project Path="src/FluentLoggerExtensions.csproj" />
+  <Project Path="tests/FluentLoggerExtensions.Tests/FluentLoggerExtensions.Tests.csproj" Id="2c496e42-1236-4580-a854-98ce3e6cce11" />
 </Solution>
diff --git a/CallerLogContext.cs b/src/CallerLogContext.cs
similarity index 100%
rename from CallerLogContext.cs
rename to src/CallerLogContext.cs
diff --git a/CallerLogContextExtensions.cs b/src/CallerLogContextExtensions.cs
similarity index 53%
rename from CallerLogContextExtensions.cs
rename to src/CallerLogContextExtensions.cs
index 35547ca..3fd42c7 100644
--- a/CallerLogContextExtensions.cs
+++ b/src/CallerLogContextExtensions.cs
@@ -15,8 +15,22 @@ public static class CallerLogContextExtensions
     /// <param name="args">The arguments for the message.</param>
     public static void LogInformation(this CallerLogContext context, string message, params object?[] args)
     {
-        string? fileName = Path.GetFileName(context.File);
-        context.Logger.LogInformation("[{File}:{Member}:{Line}] " + message, PrependCallerArgs(fileName, context.Member, context.Line, args));
+        string fileName = Path.GetFileName(context.File);
+
+        try
+        {
+            context.Logger.LogInformation(
+                "[{File}:{Member}:{Line}] " + message,
+                PrependCallerArgs(fileName, context.Member, context.Line, args));
+        }
+        catch (Exception ex)
+        {
+            // Fall back to a safe message; don't rethrow
+            context.Logger.LogError(
+                ex,
+                "[{File}:{Member}:{Line}] Logging failed for template. Template={Template}",
+                fileName, context.Member, context.Line, message);
+        }
     }
 
     /// <summary>
@@ -27,8 +41,22 @@ public static void LogInformation(this CallerLogContext context, string message,
     /// <param name="args">The arguments for the message.</param>
     public static void LogError(this CallerLogContext context, string message, params object?[] args)
     {
-        string? fileName = Path.GetFileName(context.File);
-        context.Logger.LogError("[{File}:{Member}:{Line}] " + message, PrependCallerArgs(fileName, context.Member, context.Line, args));
+        string fileName = Path.GetFileName(context.File);
+
+        try
+        {
+            context.Logger.LogError(
+                "[{File}:{Member}:{Line}] " + message,
+                PrependCallerArgs(fileName, context.Member, context.Line, args));
+        }
+        catch (Exception ex)
+        {
+            // Fall back to a safe message; don't rethrow
+            context.Logger.LogError(
+                ex,
+                "[{File}:{Member}:{Line}] Logging failed for template. Template={Template}",
+                fileName, context.Member, context.Line, message);
+        }
     }
 
     /// <summary>
@@ -39,8 +67,22 @@ public static void LogError(this CallerLogContext context, string message, param
     /// <param name="args">The arguments for the message.</param>
     public static void LogDebug(this CallerLogContext context, string message, params object?[] args)
     {
-        string? fileName = Path.GetFileName(context.File);
-        context.Logger.LogDebug("[{File}:{Member}:{Line}] " + message, PrependCallerArgs(fileName, context.Member, context.Line, args));
+        string fileName = Path.GetFileName(context.File);
+
+        try
+        {
+            context.Logger.LogDebug(
+                "[{File}:{Member}:{Line}] " + message,
+                PrependCallerArgs(fileName, context.Member, context.Line, args));
+        }
+        catch (Exception ex)
+        {
+            // Fall back to a safe message; don't rethrow
+            context.Logger.LogDebug(
+                ex,
+                "[{File}:{Member}:{Line}] Logging failed for template. Template={Template}",
+                fileName, context.Member, context.Line, message);
+        }
     }
 
     /// <summary>
@@ -51,8 +93,22 @@ public static void LogDebug(this CallerLogContext context, string message, param
     /// <param name="args">The arguments for the message.</param>
     public static void LogWarning(this CallerLogContext context, string message, params object?[] args)
     {
-        string? fileName = Path.GetFileName(context.File);
-        context.Logger.LogWarning("[{File}:{Member}:{Line}] " + message, PrependCallerArgs(fileName, context.Member, context.Line, args));
+        string fileName = Path.GetFileName(context.File);
+
+        try
+        {
+            context.Logger.LogWarning(
+                "[{File}:{Member}:{Line}] " + message,
+                PrependCallerArgs(fileName, context.Member, context.Line, args));
+        }
+        catch (Exception ex)
+        {
+            // Fall back to a safe message; don't rethrow
+            context.Logger.LogWarning(
+                ex,
+                "[{File}:{Member}:{Line}] Logging failed for template. Template={Template}",
+                fileName, context.Member, context.Line, message);
+        }
     }
 
     /// <summary>
diff --git a/FluentLoggerExtensions.cs b/src/FluentLoggerExtensions.cs
similarity index 100%
rename from FluentLoggerExtensions.cs
rename to src/FluentLoggerExtensions.cs
diff --git a/FluentLoggerExtensions.csproj b/src/FluentLoggerExtensions.csproj
similarity index 88%
rename from FluentLoggerExtensions.csproj
rename to src/FluentLoggerExtensions.csproj
index c8f6846..97813f0 100644
--- a/FluentLoggerExtensions.csproj
+++ b/src/FluentLoggerExtensions.csproj
@@ -13,6 +13,7 @@
 		<PackageLicenseExpression>MIT</PackageLicenseExpression>
 		<IncludeSymbols>true</IncludeSymbols>
 		<SymbolPackageFormat>snupkg</SymbolPackageFormat>
+		<PackageReadmeFile>README.md</PackageReadmeFile>
 	</PropertyGroup>
 
 	<ItemGroup>
@@ -23,4 +24,8 @@
 		</PackageReference>
 	</ItemGroup>
 
+	<ItemGroup>
+		<None Include="..\README.md" Pack="true" PackagePath="\" />
+	</ItemGroup>
+
 </Project>
diff --git a/tests/FluentLoggerExtensions.Tests/CallerLogContextLogDebugTests.cs b/tests/FluentLoggerExtensions.Tests/CallerLogContextLogDebugTests.cs
new file mode 100644
index 0000000..7f0cfcf
--- /dev/null
+++ b/tests/FluentLoggerExtensions.Tests/CallerLogContextLogDebugTests.cs
@@ -0,0 +1,73 @@
+using FluentLogger;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace FluentLoggerExtensions.Tests;
+
+public class CallerLogContextLogDebugTests
+{
+    [Theory]
+    [InlineData("This is a test log message")]
+    [InlineData("This is another test log message")]
+    [InlineData("This is a really log test message")]
+    public void LogDebug_WithPlainMessage_DoesNotThrow(string message)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogDebug(message);
+        logger.VerifyLogContains(message, LogLevel.Debug);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogDebug_WithInterpolatedString_DoesNotThrow(string id)
+    {
+        Mock<ILogger> logger = new();
+
+        logger.Object.WithCaller().LogDebug($"{id}");
+    }
+
+    [Theory]
+    [InlineData("hello", "there")]
+    public void LogDebug_WithMatchingPlaceholdersAndArguments_DoesNotThrow(string id, string id2)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogDebug("{FirstWord} {SecondWord}", id, id2);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogDebug_WithMissingArguments_DoesNotThrowUntilStateIsEnumerated(string id)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogDebug("{FirstWord} {SecondWord}", id);
+    }
+
+    [Fact]
+    public void Mismatched_placeholders_throw_when_state_is_enumerated()
+    {
+        var logger = new Mock<ILogger>();
+
+        logger
+            .Setup(l => l.Log(
+                It.IsAny<LogLevel>(),
+                It.IsAny<EventId>(),
+                It.IsAny<It.IsAnyType>(),
+                It.IsAny<Exception?>(),
+                (Func<It.IsAnyType, Exception?, string>)It.IsAny<object>()))
+            .Callback(new InvocationAction(invocation =>
+            {
+                // state is argument #2
+                var state = invocation.Arguments[2];
+
+                // This is what Serilog does internally: enumerate structured values
+                foreach (var _ in (IEnumerable<KeyValuePair<string, object?>>)state)
+                {
+                    // enumeration triggers LogValuesFormatter.GetValue(...)
+                }
+            }));
+
+        // 2 placeholders, 1 arg -> will throw once enumerated
+        logger.Object.WithCaller().LogDebug("{FirstWord} {SecondWord}", "hello");
+    }
+
+}
diff --git a/tests/FluentLoggerExtensions.Tests/CallerLogContextLogErrorTests.cs b/tests/FluentLoggerExtensions.Tests/CallerLogContextLogErrorTests.cs
new file mode 100644
index 0000000..e6c8252
--- /dev/null
+++ b/tests/FluentLoggerExtensions.Tests/CallerLogContextLogErrorTests.cs
@@ -0,0 +1,73 @@
+using FluentLogger;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace FluentLoggerExtensions.Tests;
+
+public class CallerLogContextLogErrorTests
+{
+    [Theory]
+    [InlineData("This is a test log message")]
+    [InlineData("This is another test log message")]
+    [InlineData("This is a really log test message")]
+    public void LogError_WithPlainMessage_DoesNotThrow(string message)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogError(message);
+        logger.VerifyLogContains(message, LogLevel.Error);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogError_WithInterpolatedString_DoesNotThrow(string id)
+    {
+        Mock<ILogger> logger = new();
+
+        logger.Object.WithCaller().LogError($"{id}");
+    }
+
+    [Theory]
+    [InlineData("hello", "there")]
+    public void LogError_WithMatchingPlaceholdersAndArguments_DoesNotThrow(string id, string id2)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogError("{FirstWord} {SecondWord}", id, id2);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogError_WithMissingArguments_DoesNotThrowUntilStateIsEnumerated(string id)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogError("{FirstWord} {SecondWord}", id);
+    }
+
+    [Fact]
+    public void Mismatched_placeholders_throw_when_state_is_enumerated()
+    {
+        var logger = new Mock<ILogger>();
+
+        logger
+            .Setup(l => l.Log(
+                It.IsAny<LogLevel>(),
+                It.IsAny<EventId>(),
+                It.IsAny<It.IsAnyType>(),
+                It.IsAny<Exception?>(),
+                (Func<It.IsAnyType, Exception?, string>)It.IsAny<object>()))
+            .Callback(new InvocationAction(invocation =>
+            {
+                // state is argument #2
+                var state = invocation.Arguments[2];
+
+                // This is what Serilog does internally: enumerate structured values
+                foreach (var _ in (IEnumerable<KeyValuePair<string, object?>>)state)
+                {
+                    // enumeration triggers LogValuesFormatter.GetValue(...)
+                }
+            }));
+
+        // 2 placeholders, 1 arg -> will throw once enumerated
+        logger.Object.WithCaller().LogError("{FirstWord} {SecondWord}", "hello");
+    }
+
+}
diff --git a/tests/FluentLoggerExtensions.Tests/CallerLogContextLogInformationTests.cs b/tests/FluentLoggerExtensions.Tests/CallerLogContextLogInformationTests.cs
new file mode 100644
index 0000000..190d8b5
--- /dev/null
+++ b/tests/FluentLoggerExtensions.Tests/CallerLogContextLogInformationTests.cs
@@ -0,0 +1,73 @@
+using FluentLogger;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace FluentLoggerExtensions.Tests;
+
+public class CallerLogContextLogInformationTests
+{
+    [Theory]
+    [InlineData("This is a test log message")]
+    [InlineData("This is another test log message")]
+    [InlineData("This is a really log test message")]
+    public void LogInformation_WithPlainMessage_DoesNotThrow(string message)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogInformation(message);
+        logger.VerifyLogContains(message);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogInformation_WithInterpolatedString_DoesNotThrow(string id)
+    {
+        Mock<ILogger> logger = new();
+
+        logger.Object.WithCaller().LogInformation($"{id}");
+    }
+
+    [Theory]
+    [InlineData("hello", "there")]
+    public void LogInformation_WithMatchingPlaceholdersAndArguments_DoesNotThrow(string id, string id2)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogInformation("{FirstWord} {SecondWord}", id, id2);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogInformation_WithMissingArguments_DoesNotThrowUntilStateIsEnumerated(string id)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogInformation("{FirstWord} {SecondWord}", id);
+    }
+
+    [Fact]
+    public void Mismatched_placeholders_throw_when_state_is_enumerated()
+    {
+        var logger = new Mock<ILogger>();
+
+        logger
+            .Setup(l => l.Log(
+                It.IsAny<LogLevel>(),
+                It.IsAny<EventId>(),
+                It.IsAny<It.IsAnyType>(),
+                It.IsAny<Exception?>(),
+                (Func<It.IsAnyType, Exception?, string>)It.IsAny<object>()))
+            .Callback(new InvocationAction(invocation =>
+            {
+                // state is argument #2
+                var state = invocation.Arguments[2];
+
+                // This is what Serilog does internally: enumerate structured values
+                foreach (var _ in (IEnumerable<KeyValuePair<string, object?>>)state)
+                {
+                    // enumeration triggers LogValuesFormatter.GetValue(...)
+                }
+            }));
+
+        // 2 placeholders, 1 arg -> will throw once enumerated
+        logger.Object.WithCaller().LogInformation("{FirstWord} {SecondWord}", "hello");
+    }
+
+}
diff --git a/tests/FluentLoggerExtensions.Tests/CallerLogContextLogWarningTests.cs b/tests/FluentLoggerExtensions.Tests/CallerLogContextLogWarningTests.cs
new file mode 100644
index 0000000..abaa4cc
--- /dev/null
+++ b/tests/FluentLoggerExtensions.Tests/CallerLogContextLogWarningTests.cs
@@ -0,0 +1,73 @@
+using FluentLogger;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace FluentLoggerExtensions.Tests;
+
+public class CallerLogContextLogWarningTests
+{
+    [Theory]
+    [InlineData("This is a test log message")]
+    [InlineData("This is another test log message")]
+    [InlineData("This is a really log test message")]
+    public void LogWarning_WithPlainMessage_DoesNotThrow(string message)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogWarning(message);
+        logger.VerifyLogContains(message, LogLevel.Warning);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogWarning_WithInterpolatedString_DoesNotThrow(string id)
+    {
+        Mock<ILogger> logger = new();
+
+        logger.Object.WithCaller().LogWarning($"{id}");
+    }
+
+    [Theory]
+    [InlineData("hello", "there")]
+    public void LogWarning_WithMatchingPlaceholdersAndArguments_DoesNotThrow(string id, string id2)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogWarning("{FirstWord} {SecondWord}", id, id2);
+    }
+
+    [Theory]
+    [InlineData("hello")]
+    public void LogWarning_WithMissingArguments_DoesNotThrowUntilStateIsEnumerated(string id)
+    {
+        Mock<ILogger> logger = new();
+        logger.Object.WithCaller().LogWarning("{FirstWord} {SecondWord}", id);
+    }
+
+    [Fact]
+    public void Mismatched_placeholders_throw_when_state_is_enumerated()
+    {
+        var logger = new Mock<ILogger>();
+
+        logger
+            .Setup(l => l.Log(
+                It.IsAny<LogLevel>(),
+                It.IsAny<EventId>(),
+                It.IsAny<It.IsAnyType>(),
+                It.IsAny<Exception?>(),
+                (Func<It.IsAnyType, Exception?, string>)It.IsAny<object>()))
+            .Callback(new InvocationAction(invocation =>
+            {
+                // state is argument #2
+                var state = invocation.Arguments[2];
+
+                // This is what Serilog does internally: enumerate structured values
+                foreach (var _ in (IEnumerable<KeyValuePair<string, object?>>)state)
+                {
+                    // enumeration triggers LogValuesFormatter.GetValue(...)
+                }
+            }));
+
+        // 2 placeholders, 1 arg -> will throw once enumerated
+        logger.Object.WithCaller().LogWarning("{FirstWord} {SecondWord}", "hello");
+    }
+
+}
diff --git a/tests/FluentLoggerExtensions.Tests/FluentLoggerExtensions.Tests.csproj b/tests/FluentLoggerExtensions.Tests/FluentLoggerExtensions.Tests.csproj
new file mode 100644
index 0000000..c7753e3
--- /dev/null
+++ b/tests/FluentLoggerExtensions.Tests/FluentLoggerExtensions.Tests.csproj
@@ -0,0 +1,34 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\FluentLoggerExtensions.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>
diff --git a/tests/FluentLoggerExtensions.Tests/LoggerMoqExtensions.cs b/tests/FluentLoggerExtensions.Tests/LoggerMoqExtensions.cs
new file mode 100644
index 0000000..bb31bd8
--- /dev/null
+++ b/tests/FluentLoggerExtensions.Tests/LoggerMoqExtensions.cs
@@ -0,0 +1,21 @@
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace FluentLoggerExtensions.Tests;
+
+public static class LoggerMoqExtensions
+{
+    public static void VerifyLogContains(this Mock<ILogger> logger, string message, LogLevel level = LogLevel.Information, Times? times = null)
+    {
+        logger.Verify(x =>
+                x.Log(
+                    level,
+                    It.IsAny<EventId>(),
+                    It.Is<It.IsAnyType>((v, t) =>
+                        v.ToString()!.Contains(message)
+                    ),
+                    It.IsAny<Exception>(),
+                    It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
+            Times.Once);
+    }
+}