diff --git a/tests/test_providers.py b/tests/test_providers.py
index e31599f..2926918 100644
--- a/tests/test_providers.py
+++ b/tests/test_providers.py
@@ -2,7 +2,6 @@
 
 import pytest
 from faker import Faker
-
 from testdatagen.providers.testdata_provider import TestDataProvider
 
 
@@ -30,11 +29,24 @@ class TestTestDataProvider:
         faker = Faker()
         provider = TestDataProvider(faker)
         
-        result = provider.json_schema_type({"type": "integer", "minimum": 10, "maximum": 20}, faker)
+        result = provider.json_schema_type({
+            "type": "integer",
+            "minimum": 10,
+            "maximum": 20
+        }, faker)
+        
         assert isinstance(result, int)
         assert 10 <= result <= 20
 
-    def test_json_schema_type_string_plain(self):
+    def test_json_schema_type_number(self):
+        """Test number type generation."""
+        faker = Faker()
+        provider = TestDataProvider(faker)
+        
+        result = provider.json_schema_type({"type": "number"}, faker)
+        assert isinstance(result, float)
+
+    def test_json_schema_type_string(self):
         """Test string type generation."""
         faker = Faker()
         provider = TestDataProvider(faker)
@@ -42,45 +54,133 @@ class TestTestDataProvider:
         result = provider.json_schema_type({"type": "string"}, faker)
         assert isinstance(result, str)
 
-    def test_json_schema_type_string_with_format_email(self):
-        """Test string with email format."""
+    def test_json_schema_type_string_email(self):
+        """Test email format generation."""
         faker = Faker()
         provider = TestDataProvider(faker)
         
-        result = provider.json_schema_type({"type": "string", "format": "email"}, faker)
-        assert isinstance(result, str)
+        result = provider.json_schema_type({
+            "type": "string",
+            "format": "email"
+        }, faker)
+        
         assert "@" in result
+        assert "." in result
 
-    def test_json_schema_type_string_with_format_uuid(self):
-        """Test string with uuid format."""
+    def test_json_schema_type_string_uuid(self):
+        """Test UUID format generation."""
         faker = Faker()
         provider = TestDataProvider(faker)
         
-        result = provider.json_schema_type({"type": "string", "format": "uuid"}, faker)
-        assert isinstance(result, str)
-        assert "-" in result
+        result = provider.json_schema_type({
+            "type": "string",
+            "format": "uuid"
+        }, faker)
+        
+        assert len(result) == 36
 
-    def test_json_schema_type_string_with_format_date(self):
-        """Test string with date format."""
+    def test_json_schema_type_string_uri(self):
+        """Test URI format generation."""
         faker = Faker()
         provider = TestDataProvider(faker)
         
-        result = provider.json_schema_type({"type": "string", "format": "date-time"}, faker)
-        assert isinstance(result, str)
+        result = provider.json_schema_type({
+            "type": "string",
+            "format": "uri"
+        }, faker)
+        
+        assert "://" in result
 
-    def test_json_schema_type_string(self):
-        """Test string type generation returns a string."""
+    def test_json_schema_type_enum(self):
+        """Test enum generation."""
         faker = Faker()
         provider = TestDataProvider(faker)
         
-        result = provider.json_schema_type({"type": "string"}, faker)
+        result = provider.json_schema_type({
+            "enum": ["red", "green", "blue"]
+        }, faker)
+        
+        assert result in ["red", "green", "blue"]
+
+    def test_json_schema_type_null(self):
+        """Test null type generation."""
+        faker = Faker()
+        provider = TestDataProvider(faker)
+        
+        result = provider.json_schema_type({"type": "null"}, faker)
+        assert result is None
+
+    def test_json_schema_type_const(self):
+        """Test const generation."""
+        faker = Faker()
+        provider = TestDataProvider(faker)
+        
+        result = provider.json_schema_type({"const": "fixed_value"}, faker)
+        assert result == "fixed_value"
+
+    def test_json_schema_type_array(self):
+        """Test array generation."""
+        faker = Faker()
+        provider = TestDataProvider(faker)
+        
+        result = provider.json_schema_type({
+            "type": "array",
+            "items": {"type": "string"}
+        }, faker)
+        
+        assert isinstance(result, list)
+
+    def test_json_schema_type_object(self):
+        """Test object generation."""
+        faker = Faker()
+        provider = TestDataProvider(faker)
+        
+        result = provider.json_schema_type({
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"}
+            }
+        }, faker)
+        
+        assert isinstance(result, dict)
+        assert "name" in result
+
+    def test_generate_from_pattern_simple(self):
+        """Test pattern-based generation."""
+        faker = Faker()
+        provider = TestDataProvider(faker)
+        
+        result = provider._generate_from_pattern(r"\d{3}")
+        assert len(result) == 3
+        assert result.isdigit()
+
+    def test_generate_from_pattern_alphanumeric(self):
+        """Test alphanumeric pattern generation."""
+        faker = Faker()
+        provider = TestDataProvider(faker)
+        
+        result = provider._generate_from_pattern(r"\w+")
         assert isinstance(result, str)
 
-    def test_provider_can_be_added_to_faker(self):
-        """Test that provider can be added to Faker instance."""
+    def test_generate_from_pattern_complex(self):
+        """Test complex pattern generation."""
         faker = Faker()
-        original_count = len(faker.providers)
+        provider = TestDataProvider(faker)
         
-        faker.add_provider(TestDataProvider)
+        result = provider._generate_from_pattern(r"[abc]{3}")
+        assert len(result) == 3
+        assert all(c in "abc" for c in result)
+
+    def test_any_of_schema(self):
+        """Test anyOf schema handling."""
+        faker = Faker()
+        provider = TestDataProvider(faker)
         
-        assert len(faker.providers) == original_count + 1
+        result = provider.json_schema_type({
+            "anyOf": [
+                {"type": "string", "format": "email"},
+                {"type": "string", "format": "uri"}
+            ]
+        }, faker)
+        
+        assert isinstance(result, str)