diff --git a/GFramework.SourceGenerators.Tests/enums/EnumExtensionsGeneratorSnapshotTests.cs b/GFramework.SourceGenerators.Tests/enums/EnumExtensionsGeneratorSnapshotTests.cs
index 62ffab8..2a84399 100644
--- a/GFramework.SourceGenerators.Tests/enums/EnumExtensionsGeneratorSnapshotTests.cs
+++ b/GFramework.SourceGenerators.Tests/enums/EnumExtensionsGeneratorSnapshotTests.cs
@@ -11,10 +11,22 @@ public class EnumExtensionsGeneratorSnapshotTests
     public async Task Snapshot_BasicEnum_IsMethods()
     {
         const string source = """
-                              using GFramework.SourceGenerators.Abstractions.enums;
+                              using System;
+
+                              namespace GFramework.SourceGenerators.Abstractions.enums
+                              {
+                                  [AttributeUsage(AttributeTargets.Enum)]
+                                  public sealed class GenerateEnumExtensionsAttribute : Attribute
+                                  {
+                                      public bool GenerateIsMethods { get; set; } = true;
+                                      public bool GenerateIsInMethod { get; set; } = true;
+                                  }
+                              }
 
                               namespace TestApp
                               {
+                                  using GFramework.SourceGenerators.Abstractions.enums;
+
                                   [GenerateEnumExtensions]
                                   public enum Status
                                   {
@@ -39,10 +51,22 @@ public class EnumExtensionsGeneratorSnapshotTests
     public async Task Snapshot_BasicEnum_IsInMethod()
     {
         const string source = """
-                              using GFramework.SourceGenerators.Abstractions.enums;
+                              using System;
+
+                              namespace GFramework.SourceGenerators.Abstractions.enums
+                              {
+                                  [AttributeUsage(AttributeTargets.Enum)]
+                                  public sealed class GenerateEnumExtensionsAttribute : Attribute
+                                  {
+                                      public bool GenerateIsMethods { get; set; } = true;
+                                      public bool GenerateIsInMethod { get; set; } = true;
+                                  }
+                              }
 
                               namespace TestApp
                               {
+                                  using GFramework.SourceGenerators.Abstractions.enums;
+
                                   [GenerateEnumExtensions]
                                   public enum Status
                                   {
@@ -66,11 +90,22 @@ public class EnumExtensionsGeneratorSnapshotTests
     public async Task Snapshot_EnumWithFlagValues()
     {
         const string source = """
-                              using GFramework.SourceGenerators.Abstractions.enums;
                               using System;
 
+                              namespace GFramework.SourceGenerators.Abstractions.enums
+                              {
+                                  [AttributeUsage(AttributeTargets.Enum)]
+                                  public sealed class GenerateEnumExtensionsAttribute : Attribute
+                                  {
+                                      public bool GenerateIsMethods { get; set; } = true;
+                                      public bool GenerateIsInMethod { get; set; } = true;
+                                  }
+                              }
+
                               namespace TestApp
                               {
+                                  using GFramework.SourceGenerators.Abstractions.enums;
+
                                   [GenerateEnumExtensions]
                                   [Flags]
                                   public enum Permissions
@@ -97,10 +132,22 @@ public class EnumExtensionsGeneratorSnapshotTests
     public async Task Snapshot_DisableIsMethods()
     {
         const string source = """
-                              using GFramework.SourceGenerators.Abstractions.enums;
+                              using System;
+
+                              namespace GFramework.SourceGenerators.Abstractions.enums
+                              {
+                                  [AttributeUsage(AttributeTargets.Enum)]
+                                  public sealed class GenerateEnumExtensionsAttribute : Attribute
+                                  {
+                                      public bool GenerateIsMethods { get; set; } = true;
+                                      public bool GenerateIsInMethod { get; set; } = true;
+                                  }
+                              }
 
                               namespace TestApp
                               {
+                                  using GFramework.SourceGenerators.Abstractions.enums;
+
                                   [GenerateEnumExtensions(GenerateIsMethods = false)]
                                   public enum Status
                                   {
@@ -124,10 +171,22 @@ public class EnumExtensionsGeneratorSnapshotTests
     public async Task Snapshot_DisableIsInMethod()
     {
         const string source = """
-                              using GFramework.SourceGenerators.Abstractions.enums;
+                              using System;
+
+                              namespace GFramework.SourceGenerators.Abstractions.enums
+                              {
+                                  [AttributeUsage(AttributeTargets.Enum)]
+                                  public sealed class GenerateEnumExtensionsAttribute : Attribute
+                                  {
+                                      public bool GenerateIsMethods { get; set; } = true;
+                                      public bool GenerateIsInMethod { get; set; } = true;
+                                  }
+                              }
 
                               namespace TestApp
                               {
+                                  using GFramework.SourceGenerators.Abstractions.enums;
+
                                   [GenerateEnumExtensions(GenerateIsInMethod = false)]
                                   public enum Status
                                   {
diff --git a/GFramework.SourceGenerators.Tests/logging/LoggerGeneratorSnapshotTests.cs b/GFramework.SourceGenerators.Tests/logging/LoggerGeneratorSnapshotTests.cs
index 7bc3af3..2cb4278 100644
--- a/GFramework.SourceGenerators.Tests/logging/LoggerGeneratorSnapshotTests.cs
+++ b/GFramework.SourceGenerators.Tests/logging/LoggerGeneratorSnapshotTests.cs
@@ -11,10 +11,82 @@ public class LoggerGeneratorSnapshotTests
     public async Task Snapshot_DefaultConfiguration_Class()
     {
         const string source = """
-                              using GFramework.SourceGenerators.Abstractions.logging;
+                              using System;
+
+                              namespace GFramework.SourceGenerators.Abstractions.logging
+                              {
+                                  [AttributeUsage(AttributeTargets.Class)]
+                                  public sealed class LogAttribute : Attribute
+                                  {
+                                      public string Name { get; set; }
+                                      public string FieldName { get; set; }
+                                      public string AccessModifier { get; set; }
+                                      public bool IsStatic { get; set; } = true;
+                                  }
+                              }
+
+                              namespace GFramework.Core.Abstractions.logging
+                              {
+                                  public interface ILogger
+                                  {
+                                      void Info(string message);
+                                      void Error(string message);
+                                      void Warn(string message);
+                                      void Debug(string message);
+                                      void Trace(string message);
+                                      void Fatal(string message);
+                                  }
+                              }
+
+                              namespace GFramework.Core.logging
+                              {
+                                  using GFramework.Core.Abstractions.logging;
+
+                                  public static class LoggerFactoryResolver
+                                  {
+                                      public static ILoggerProvider Provider { get; set; }
+
+                                      public static ILoggerProvider CreateLogger(string name)
+                                      {
+                                          return Provider ?? new MockLoggerProvider();
+                                      }
+                                  }
+
+                                  public interface ILoggerProvider
+                                  {
+                                      ILogger CreateLogger(string name);
+                                  }
+
+                                  internal class MockLoggerProvider : ILoggerProvider
+                                  {
+                                      public ILogger CreateLogger(string name)
+                                      {
+                                          return new MockLogger(name);
+                                      }
+                                  }
+
+                                  internal class MockLogger : ILogger
+                                  {
+                                      private readonly string _name;
+
+                                      public MockLogger(string name)
+                                      {
+                                          _name = name;
+                                      }
+
+                                      public void Info(string message) { }
+                                      public void Error(string message) { }
+                                      public void Warn(string message) { }
+                                      public void Debug(string message) { }
+                                      public void Trace(string message) { }
+                                      public void Fatal(string message) { }
+                                  }
+                              }
 
                               namespace TestApp
                               {
+                                  using GFramework.SourceGenerators.Abstractions.logging;
+
                                   [Log]
                                   public partial class MyService
                                   {
@@ -36,10 +108,82 @@ public class LoggerGeneratorSnapshotTests
     public async Task Snapshot_CustomName_Class()
     {
         const string source = """
-                              using GFramework.SourceGenerators.Abstractions.logging;
+                              using System;
+
+                              namespace GFramework.SourceGenerators.Abstractions.logging
+                              {
+                                  [AttributeUsage(AttributeTargets.Class)]
+                                  public sealed class LogAttribute : Attribute
+                                  {
+                                      public string Name { get; set; }
+                                      public string FieldName { get; set; }
+                                      public string AccessModifier { get; set; }
+                                      public bool IsStatic { get; set; } = true;
+                                  }
+                              }
+
+                              namespace GFramework.Core.Abstractions.logging
+                              {
+                                  public interface ILogger
+                                  {
+                                      void Info(string message);
+                                      void Error(string message);
+                                      void Warn(string message);
+                                      void Debug(string message);
+                                      void Trace(string message);
+                                      void Fatal(string message);
+                                  }
+                              }
+
+                              namespace GFramework.Core.logging
+                              {
+                                  using GFramework.Core.Abstractions.logging;
+
+                                  public static class LoggerFactoryResolver
+                                  {
+                                      public static ILoggerProvider Provider { get; set; }
+
+                                      public static ILoggerProvider CreateLogger(string name)
+                                      {
+                                          return Provider ?? new MockLoggerProvider();
+                                      }
+                                  }
+
+                                  public interface ILoggerProvider
+                                  {
+                                      ILogger CreateLogger(string name);
+                                  }
+
+                                  internal class MockLoggerProvider : ILoggerProvider
+                                  {
+                                      public ILogger CreateLogger(string name)
+                                      {
+                                          return new MockLogger(name);
+                                      }
+                                  }
+
+                                  internal class MockLogger : ILogger
+                                  {
+                                      private readonly string _name;
+
+                                      public MockLogger(string name)
+                                      {
+                                          _name = name;
+                                      }
+
+                                      public void Info(string message) { }
+                                      public void Error(string message) { }
+                                      public void Warn(string message) { }
+                                      public void Debug(string message) { }
+                                      public void Trace(string message) { }
+                                      public void Fatal(string message) { }
+                                  }
+                              }
 
                               namespace TestApp
                               {
+                                  using GFramework.SourceGenerators.Abstractions.logging;
+
                                   [Log(Name = "CustomLogger")]
                                   public partial class MyService
                                   {
@@ -61,10 +205,82 @@ public class LoggerGeneratorSnapshotTests
     public async Task Snapshot_CustomFieldName_Class()
     {
         const string source = """
-                              using GFramework.SourceGenerators.Abstractions.logging;
+                              using System;
+
+                              namespace GFramework.SourceGenerators.Abstractions.logging
+                              {
+                                  [AttributeUsage(AttributeTargets.Class)]
+                                  public sealed class LogAttribute : Attribute
+                                  {
+                                      public string Name { get; set; }
+                                      public string FieldName { get; set; }
+                                      public string AccessModifier { get; set; }
+                                      public bool IsStatic { get; set; } = true;
+                                  }
+                              }
+
+                              namespace GFramework.Core.Abstractions.logging
+                              {
+                                  public interface ILogger
+                                  {
+                                      void Info(string message);
+                                      void Error(string message);
+                                      void Warn(string message);
+                                      void Debug(string message);
+                                      void Trace(string message);
+                                      void Fatal(string message);
+                                  }
+                              }
+
+                              namespace GFramework.Core.logging
+                              {
+                                  using GFramework.Core.Abstractions.logging;
+
+                                  public static class LoggerFactoryResolver
+                                  {
+                                      public static ILoggerProvider Provider { get; set; }
+
+                                      public static ILoggerProvider CreateLogger(string name)
+                                      {
+                                          return Provider ?? new MockLoggerProvider();
+                                      }
+                                  }
+
+                                  public interface ILoggerProvider
+                                  {
+                                      ILogger CreateLogger(string name);
+                                  }
+
+                                  internal class MockLoggerProvider : ILoggerProvider
+                                  {
+                                      public ILogger CreateLogger(string name)
+                                      {
+                                          return new MockLogger(name);
+                                      }
+                                  }
+
+                                  internal class MockLogger : ILogger
+                                  {
+                                      private readonly string _name;
+
+                                      public MockLogger(string name)
+                                      {
+                                          _name = name;
+                                      }
+
+                                      public void Info(string message) { }
+                                      public void Error(string message) { }
+                                      public void Warn(string message) { }
+                                      public void Debug(string message) { }
+                                      public void Trace(string message) { }
+                                      public void Fatal(string message) { }
+                                  }
+                              }
 
                               namespace TestApp
                               {
+                                  using GFramework.SourceGenerators.Abstractions.logging;
+
                                   [Log(FieldName = "MyLogger")]
                                   public partial class MyService
                                   {
@@ -86,10 +302,82 @@ public class LoggerGeneratorSnapshotTests
     public async Task Snapshot_InstanceField_Class()
     {
         const string source = """
-                              using GFramework.SourceGenerators.Abstractions.logging;
+                              using System;
+
+                              namespace GFramework.SourceGenerators.Abstractions.logging
+                              {
+                                  [AttributeUsage(AttributeTargets.Class)]
+                                  public sealed class LogAttribute : Attribute
+                                  {
+                                      public string Name { get; set; }
+                                      public string FieldName { get; set; }
+                                      public string AccessModifier { get; set; }
+                                      public bool IsStatic { get; set; } = true;
+                                  }
+                              }
+
+                              namespace GFramework.Core.Abstractions.logging
+                              {
+                                  public interface ILogger
+                                  {
+                                      void Info(string message);
+                                      void Error(string message);
+                                      void Warn(string message);
+                                      void Debug(string message);
+                                      void Trace(string message);
+                                      void Fatal(string message);
+                                  }
+                              }
+
+                              namespace GFramework.Core.logging
+                              {
+                                  using GFramework.Core.Abstractions.logging;
+
+                                  public static class LoggerFactoryResolver
+                                  {
+                                      public static ILoggerProvider Provider { get; set; }
+
+                                      public static ILoggerProvider CreateLogger(string name)
+                                      {
+                                          return Provider ?? new MockLoggerProvider();
+                                      }
+                                  }
+
+                                  public interface ILoggerProvider
+                                  {
+                                      ILogger CreateLogger(string name);
+                                  }
+
+                                  internal class MockLoggerProvider : ILoggerProvider
+                                  {
+                                      public ILogger CreateLogger(string name)
+                                      {
+                                          return new MockLogger(name);
+                                      }
+                                  }
+
+                                  internal class MockLogger : ILogger
+                                  {
+                                      private readonly string _name;
+
+                                      public MockLogger(string name)
+                                      {
+                                          _name = name;
+                                      }
+
+                                      public void Info(string message) { }
+                                      public void Error(string message) { }
+                                      public void Warn(string message) { }
+                                      public void Debug(string message) { }
+                                      public void Trace(string message) { }
+                                      public void Fatal(string message) { }
+                                  }
+                              }
 
                               namespace TestApp
                               {
+                                  using GFramework.SourceGenerators.Abstractions.logging;
+
                                   [Log(IsStatic = false)]
                                   public partial class MyService
                                   {
@@ -111,10 +399,82 @@ public class LoggerGeneratorSnapshotTests
     public async Task Snapshot_PublicField_Class()
     {
         const string source = """
-                              using GFramework.SourceGenerators.Abstractions.logging;
+                              using System;
+
+                              namespace GFramework.SourceGenerators.Abstractions.logging
+                              {
+                                  [AttributeUsage(AttributeTargets.Class)]
+                                  public sealed class LogAttribute : Attribute
+                                  {
+                                      public string Name { get; set; }
+                                      public string FieldName { get; set; }
+                                      public string AccessModifier { get; set; }
+                                      public bool IsStatic { get; set; } = true;
+                                  }
+                              }
+
+                              namespace GFramework.Core.Abstractions.logging
+                              {
+                                  public interface ILogger
+                                  {
+                                      void Info(string message);
+                                      void Error(string message);
+                                      void Warn(string message);
+                                      void Debug(string message);
+                                      void Trace(string message);
+                                      void Fatal(string message);
+                                  }
+                              }
+
+                              namespace GFramework.Core.logging
+                              {
+                                  using GFramework.Core.Abstractions.logging;
+
+                                  public static class LoggerFactoryResolver
+                                  {
+                                      public static ILoggerProvider Provider { get; set; }
+
+                                      public static ILoggerProvider CreateLogger(string name)
+                                      {
+                                          return Provider ?? new MockLoggerProvider();
+                                      }
+                                  }
+
+                                  public interface ILoggerProvider
+                                  {
+                                      ILogger CreateLogger(string name);
+                                  }
+
+                                  internal class MockLoggerProvider : ILoggerProvider
+                                  {
+                                      public ILogger CreateLogger(string name)
+                                      {
+                                          return new MockLogger(name);
+                                      }
+                                  }
+
+                                  internal class MockLogger : ILogger
+                                  {
+                                      private readonly string _name;
+
+                                      public MockLogger(string name)
+                                      {
+                                          _name = name;
+                                      }
+
+                                      public void Info(string message) { }
+                                      public void Error(string message) { }
+                                      public void Warn(string message) { }
+                                      public void Debug(string message) { }
+                                      public void Trace(string message) { }
+                                      public void Fatal(string message) { }
+                                  }
+                              }
 
                               namespace TestApp
                               {
+                                  using GFramework.SourceGenerators.Abstractions.logging;
+
                                   [Log(AccessModifier = "public")]
                                   public partial class MyService
                                   {
@@ -136,10 +496,82 @@ public class LoggerGeneratorSnapshotTests
     public async Task Snapshot_GenericClass()
     {
         const string source = """
-                              using GFramework.SourceGenerators.Abstractions.logging;
+                              using System;
+
+                              namespace GFramework.SourceGenerators.Abstractions.logging
+                              {
+                                  [AttributeUsage(AttributeTargets.Class)]
+                                  public sealed class LogAttribute : Attribute
+                                  {
+                                      public string Name { get; set; }
+                                      public string FieldName { get; set; }
+                                      public string AccessModifier { get; set; }
+                                      public bool IsStatic { get; set; } = true;
+                                  }
+                              }
+
+                              namespace GFramework.Core.Abstractions.logging
+                              {
+                                  public interface ILogger
+                                  {
+                                      void Info(string message);
+                                      void Error(string message);
+                                      void Warn(string message);
+                                      void Debug(string message);
+                                      void Trace(string message);
+                                      void Fatal(string message);
+                                  }
+                              }
+
+                              namespace GFramework.Core.logging
+                              {
+                                  using GFramework.Core.Abstractions.logging;
+
+                                  public static class LoggerFactoryResolver
+                                  {
+                                      public static ILoggerProvider Provider { get; set; }
+
+                                      public static ILoggerProvider CreateLogger(string name)
+                                      {
+                                          return Provider ?? new MockLoggerProvider();
+                                      }
+                                  }
+
+                                  public interface ILoggerProvider
+                                  {
+                                      ILogger CreateLogger(string name);
+                                  }
+
+                                  internal class MockLoggerProvider : ILoggerProvider
+                                  {
+                                      public ILogger CreateLogger(string name)
+                                      {
+                                          return new MockLogger(name);
+                                      }
+                                  }
+
+                                  internal class MockLogger : ILogger
+                                  {
+                                      private readonly string _name;
+
+                                      public MockLogger(string name)
+                                      {
+                                          _name = name;
+                                      }
+
+                                      public void Info(string message) { }
+                                      public void Error(string message) { }
+                                      public void Warn(string message) { }
+                                      public void Debug(string message) { }
+                                      public void Trace(string message) { }
+                                      public void Fatal(string message) { }
+                                  }
+                              }
 
                               namespace TestApp
                               {
+                                  using GFramework.SourceGenerators.Abstractions.logging;
+
                                   [Log]
                                   public partial class MyService<T>
                                   {