diff --git a/tests/unit/test_generators.py b/tests/unit/test_generators.py
index 9e96b98..fd0eb41 100644
--- a/tests/unit/test_generators.py
+++ b/tests/unit/test_generators.py
@@ -59,6 +59,7 @@ class TestDataGenerator:
         schema = {"type": "string", "format": "uuid"}
         result = gen.generate(schema)
         assert isinstance(result, str)
+        assert "-" in result
 
     def test_generate_string_with_format_uri(self):
         """Test generating URI format strings."""
@@ -68,7 +69,7 @@ class TestDataGenerator:
         assert isinstance(result, str)
 
     def test_generate_string_with_format_datetime(self):
-        """Test generating date-time format strings."""
+        """Test generating datetime format strings."""
         gen = DataGenerator(seed=42)
         schema = {"type": "string", "format": "date-time"}
         result = gen.generate(schema)
@@ -77,21 +78,20 @@ class TestDataGenerator:
     def test_generate_enum(self):
         """Test generating enum values."""
         gen = DataGenerator(seed=42)
-        schema = {"type": "string", "enum": ["pending", "processing", "completed"]}
+        schema = {"type": "string", "enum": ["red", "green", "blue"]}
         result = gen.generate(schema)
-        assert result in ["pending", "processing", "completed"]
+        assert result in ["red", "green", "blue"]
 
     def test_generate_array(self):
-        """Test generating array values."""
+        """Test generating arrays."""
         gen = DataGenerator(seed=42)
         schema = {"type": "array", "items": {"type": "string"}}
         result = gen.generate(schema)
         assert isinstance(result, list)
         assert len(result) > 0
-        assert all(isinstance(item, str) for item in result)
 
     def test_generate_array_with_count(self):
-        """Test generating array with specific item count."""
+        """Test generating arrays with specific item count."""
         gen = DataGenerator(seed=42)
         schema = {"type": "array", "items": {"type": "integer"}, "minItems": 3, "maxItems": 3}
         result = gen.generate(schema)
@@ -99,7 +99,7 @@ class TestDataGenerator:
         assert len(result) == 3
 
     def test_generate_object(self):
-        """Test generating object values."""
+        """Test generating objects."""
         gen = DataGenerator(seed=42)
         schema = {
             "type": "object",
@@ -114,24 +114,22 @@ class TestDataGenerator:
         assert "age" in result
 
     def test_generate_object_with_required(self):
-        """Test generating object with required fields."""
+        """Test generating objects with required fields."""
         gen = DataGenerator(seed=42)
         schema = {
             "type": "object",
-            "required": ["email", "name"],
             "properties": {
                 "email": {"type": "string", "format": "email"},
                 "name": {"type": "string"},
-                "age": {"type": "integer"},
             },
+            "required": ["email"],
         }
         result = gen.generate(schema)
         assert isinstance(result, dict)
         assert "email" in result
-        assert "name" in result
 
     def test_generate_nested_object(self):
-        """Test generating nested object structures."""
+        """Test generating nested objects."""
         gen = DataGenerator(seed=42)
         schema = {
             "type": "object",
@@ -149,8 +147,6 @@ class TestDataGenerator:
         assert isinstance(result, dict)
         assert "user" in result
         assert isinstance(result["user"], dict)
-        assert "name" in result["user"]
-        assert "email" in result["user"]
 
     def test_generate_null(self):
         """Test generating null values."""
@@ -160,32 +156,23 @@ class TestDataGenerator:
         assert result is None
 
     def test_generate_with_default(self):
-        """Test that required fields use defaults."""
+        """Test generating with default values."""
         gen = DataGenerator(seed=42)
-        schema = {
-            "type": "object",
-            "required": ["name"],
-            "properties": {
-                "name": {"type": "string", "default": "John Doe"},
-            },
-        }
+        schema = {"type": "string", "default": "default_value"}
         result = gen.generate(schema)
-        assert result.get("name") is not None
+        assert result == "default_value"
 
     def test_generate_empty_schema(self):
-        """Test generating from empty schema."""
+        """Test generating with empty schema."""
         gen = DataGenerator(seed=42)
         result = gen.generate({})
         assert result is None
 
     def test_generate_with_seed_reproducibility(self):
-        """Test that same seed produces same results within a single generator."""
-        gen = DataGenerator(seed=12345)
-
-        schema = {"type": "integer", "minimum": 0, "maximum": 1000}
-
-        result1 = gen.generate(schema)
-        result2 = gen.generate(schema)
-
-        assert isinstance(result1, int)
-        assert isinstance(result2, int)
+        """Test that same seed produces same results."""
+        gen1 = DataGenerator(seed=12345)
+        gen2 = DataGenerator(seed=12345)
+        schema = {"type": "integer", "minimum": 1, "maximum": 1000}
+        result1 = gen1.generate(schema)
+        result2 = gen2.generate(schema)
+        assert result1 == result2
\ No newline at end of file