diff --git a/README.md b/README.md
index 62fde28..cfe4a83 100644
--- a/README.md
+++ b/README.md
@@ -55,6 +55,72 @@ func main() {
 
 ---
 
+## **Best Practices & Important Notes**
+
+### **⚠️ Always Close Iterators When Using Next/Current**
+
+When using imperative-style iteration with `Next()` and `Current()`, **always call `Close()`** or use `defer iter.Close()` to prevent goroutine leaks:
+
+```go
+// ✅ CORRECT: Use defer to ensure cleanup
+iter := itertools.Range(0, 1000000)
+defer iter.Close()  // Always clean up!
+
+for iter.Next() {
+    if someCondition {
+        break  // Close() will be called via defer
+    }
+    process(iter.Current())
+}
+```
+
+```go
+// ❌ WRONG: Goroutine leak if you break early
+iter := itertools.Range(0, 1000000)
+for iter.Next() {
+    if someCondition {
+        break  // LEAK! Goroutine continues running
+    }
+}
+```
+
+**Note**: Functional-style operations (`Collect()`, `Filter()`, `Map()`, etc.) handle cleanup automatically.
+
+### **⚠️ Avoid Unbounded Operations on Infinite Iterators**
+
+Some operations consume the entire sequence and will cause out-of-memory errors with infinite iterators:
+
+**Unbounded operations**:
+- `Collect()` - Loads all elements into a slice
+- `Unique()` - Builds an unbounded map
+- `GroupBy()` - Builds unbounded maps and slices
+- `Union()`, `Intersection()`, `Difference()` - Build unbounded maps
+- `Partition()`, `Reverse()`, `Sort()`, `Shuffle()` - Collect all elements
+- `Cycle()` - Creates infinite repetition
+
+```go
+// ❌ WRONG: Out of memory!
+infiniteIter := itertools.FromFunc(func() (int, bool) {
+    return rand.Int(), true
+})
+infiniteIter.Collect()  // OOM!
+
+// ✅ CORRECT: Use Take to limit elements
+infiniteIter := itertools.FromFunc(func() (int, bool) {
+    return rand.Int(), true
+})
+result := infiniteIter.Take(1000).Collect()  // OK
+```
+
+### **Input Validation**
+
+Methods validate inputs and panic on invalid arguments:
+- `StepBy(n)` - Panics if `n <= 0`
+- `ChunkSlice(size)`, `Chunks(size)`, `ChunkList(size)` - Panic if `size <= 0`
+- `Take(n)`, `Drop(n)`, `Nth(n)` - Negative values are treated as 0
+
+---
+
 ## **Features**
 - **Chainable API**: Combine transformations like `Filter`, `Map`, `Take`, and `Drop` into one functional-style chain.
 - **Laziness**: Iterators are lazy; they only compute elements as needed.
diff --git a/iterator.go b/iterator.go
index 1b91a3e..e1858d6 100644
--- a/iterator.go
+++ b/iterator.go
@@ -119,6 +119,36 @@ func (it *Iterator[V]) Current() V {
 	return *it.curr
 }
 
+// Close releases any resources held by the iterator, particularly cleaning up
+// the goroutine spawned by iter.Pull() when using Next/Current iteration.
+//
+// IMPORTANT: Always call Close() when using Next/Current iteration and not
+// fully exhausting the iterator. Failing to do so will leak a goroutine.
+//
+// Close is idempotent - it can be called multiple times safely.
+// Close is automatically called when the iterator is fully exhausted.
+//
+// Best Practice - Use defer for guaranteed cleanup:
+//
+//	iter := itertools.Range(0, 1000000)
+//	defer iter.Close()
+//	for iter.Next() {
+//	    if someCondition {
+//	        break // Close() will be called via defer
+//	    }
+//	    process(iter.Current())
+//	}
+//
+// Note: Close only affects Next/Current iteration. Functional-style operations
+// (Collect, Each, Filter, Map, etc.) handle cleanup automatically.
+func (it *Iterator[V]) Close() {
+	if it.stop != nil {
+		it.stop()
+		it.stop = nil // Make Close idempotent
+	}
+	it.done = true
+}
+
 // Collect consumes the iterator and returns all elements as a slice.
 // After calling Collect, the iterator is exhausted.
 //
@@ -251,6 +281,8 @@ func (it *Iterator[V]) Chain(other *Iterator[V]) *Iterator[V] {
 // Take returns a new iterator that yields at most the first n elements.
 // If the iterator has fewer than n elements, all elements are yielded.
 //
+// If n is negative, it is treated as 0 (returns an empty iterator).
+//
 // Take is lazy and supports early termination.
 //
 // Example:
@@ -259,6 +291,9 @@ func (it *Iterator[V]) Chain(other *Iterator[V]) *Iterator[V] {
 //	first3 := iter.Take(3).Collect()
 //	// first3 is []int{1, 2, 3}
 func (it *Iterator[V]) Take(n int) *Iterator[V] {
+	if n < 0 {
+		n = 0
+	}
 	return &Iterator[V]{
 		seq: func(yield func(V) bool) {
 			i := 0
@@ -276,12 +311,17 @@ func (it *Iterator[V]) Take(n int) *Iterator[V] {
 // Drop returns a new iterator that skips the first n elements and yields the rest.
 // If the iterator has n or fewer elements, the resulting iterator is empty.
 //
+// If n is negative, it is treated as 0 (yields all elements).
+//
 // Example:
 //
 //	iter := itertools.ToIter([]int{1, 2, 3, 4, 5})
 //	rest := iter.Drop(2).Collect()
 //	// rest is []int{3, 4, 5}
 func (it *Iterator[V]) Drop(n int) *Iterator[V] {
+	if n < 0 {
+		n = 0
+	}
 	return &Iterator[V]{
 		seq: func(yield func(V) bool) {
 			i := 0
@@ -375,6 +415,8 @@ func (it *Iterator[V]) Last() V {
 // Nth returns the nth element (0-indexed) of the iterator.
 // It panics if the iterator has fewer than n+1 elements.
 //
+// If n is negative, it is treated as 0 (returns the first element).
+//
 // For a safe alternative that doesn't panic, use NthOr.
 //
 // Example:
@@ -382,6 +424,9 @@ func (it *Iterator[V]) Last() V {
 //	iter := itertools.ToIter([]int{10, 20, 30, 40})
 //	third := iter.Nth(2) // Returns 30
 func (it *Iterator[V]) Nth(n int) V {
+	if n < 0 {
+		n = 0
+	}
 	return it.Drop(n).First()
 }
 
@@ -438,12 +483,17 @@ func (it *Iterator[V]) LastOr(defaultValue V) V {
 // NthOr returns the nth element (0-indexed) of the iterator, or defaultValue if there aren't enough elements.
 // This is a safe alternative to Nth that doesn't panic.
 //
+// If n is negative, it is treated as 0 (returns the first element, or defaultValue if empty).
+//
 // Example:
 //
 //	iter := itertools.ToIter([]int{10, 20, 30})
 //	third := iter.NthOr(2, 999)  // Returns 30
 //	fifth := iter.NthOr(4, 999)  // Returns 999 (not enough elements)
 func (it *Iterator[V]) NthOr(n int, defaultValue V) V {
+	if n < 0 {
+		n = 0
+	}
 	var result V
 	found := false
 	i := 0
@@ -802,12 +852,17 @@ func (it *Iterator[V]) Difference(other *Iterator[V], keyFunc func(V) any) *Iter
 
 // StepBy returns an iterator that yields every nth element (0-indexed).
 //
+// Panics if n <= 0.
+//
 // Example:
 //
 //	iter := itertools.ToIter([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
 //	everyThird := iter.StepBy(3).Collect()
 //	// everyThird is []int{0, 3, 6, 9}
 func (it *Iterator[V]) StepBy(n int) *Iterator[V] {
+	if n <= 0 {
+		panic(fmt.Sprintf("StepBy: step must be positive, got %d", n))
+	}
 	return &Iterator[V]{
 		seq: func(yield func(V) bool) {
 			i := 0
diff --git a/itertools.go b/itertools.go
index e7065ff..1ec8340 100644
--- a/itertools.go
+++ b/itertools.go
@@ -2,6 +2,7 @@ package itertools
 
 import (
 	"cmp"
+	"fmt"
 	"iter"
 
 	"golang.org/x/exp/constraints"
@@ -199,12 +200,17 @@ func Product[V any, T Productable](it *Iterator[V], transform func(V) T, one T)
 //
 // Each chunk is a separate slice - modifications won't affect the original data.
 //
+// Panics if size <= 0.
+//
 // Example:
 //
 //	iter := itertools.ToIter([]int{1, 2, 3, 4, 5, 6, 7})
 //	chunks := itertools.ChunkSlice(iter, 3).Collect()
 //	// chunks is [][]int{{1, 2, 3}, {4, 5, 6}, {7}}
 func ChunkSlice[V any](it *Iterator[V], size int) *Iterator[[]V] {
+	if size <= 0 {
+		panic(fmt.Sprintf("ChunkSlice: size must be positive, got %d", size))
+	}
 	return &Iterator[[]V]{
 		seq: func(yield func([]V) bool) {
 			chunk := make([]V, 0, size)
@@ -236,6 +242,8 @@ func ChunkSlice[V any](it *Iterator[V], size int) *Iterator[[]V] {
 //
 // Unlike ChunkSlice, this returns iterators instead of slices.
 //
+// Panics if size <= 0.
+//
 // Example:
 //
 //	iter := itertools.ToIter([]int{1, 2, 3, 4, 5})
@@ -248,6 +256,9 @@ func ChunkSlice[V any](it *Iterator[V], size int) *Iterator[[]V] {
 //	//         [3 4]
 //	//         [5]
 func Chunks[V any](it *Iterator[V], size int) *Iterator[*Iterator[V]] {
+	if size <= 0 {
+		panic(fmt.Sprintf("Chunks: size must be positive, got %d", size))
+	}
 	return &Iterator[*Iterator[V]]{
 		seq: func(yield func(*Iterator[V]) bool) {
 			chunk := make([]V, 0, size)
@@ -277,12 +288,17 @@ func Chunks[V any](it *Iterator[V], size int) *Iterator[*Iterator[V]] {
 // ChunkList returns a slice of iterators, each containing up to `size` elements.
 // This is a convenience function that collects Chunks into a slice.
 //
+// Panics if size <= 0.
+//
 // Example:
 //
 //	iter := itertools.ToIter([]int{1, 2, 3, 4, 5, 6})
 //	chunks := itertools.ChunkList(iter, 2)
 //	// chunks is []*Iterator with 3 iterators containing [1,2], [3,4], [5,6]
 func ChunkList[V any](it *Iterator[V], size int) []*Iterator[V] {
+	if size <= 0 {
+		panic(fmt.Sprintf("ChunkList: size must be positive, got %d", size))
+	}
 	return Chunks(it, size).Collect()
 }
 
diff --git a/itertools_test.go b/itertools_test.go
index 72bb4d0..4adbafb 100644
--- a/itertools_test.go
+++ b/itertools_test.go
@@ -363,3 +363,98 @@ func TestChunkList_Functional(t *testing.T) {
 	assert.Equal(t, []int{6, 7, 8}, chunks[2].Collect())
 	assert.Equal(t, []int{9}, chunks[3].Collect())
 }
+
+// =============================================================================
+// PANIC AND EDGE CASE TESTS
+// =============================================================================
+
+// TestChunkSlice_PanicOnNegativeSize verifies ChunkSlice panics with negative size
+func TestChunkSlice_PanicOnNegativeSize(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	assert.Panics(t, func() {
+		itertools.ChunkSlice(iter, -5).Collect()
+	}, "ChunkSlice should panic with negative size")
+}
+
+// TestChunks_PanicOnNegativeSize verifies Chunks panics with negative size
+func TestChunks_PanicOnNegativeSize(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	assert.Panics(t, func() {
+		itertools.Chunks(iter, -3).Collect()
+	}, "Chunks should panic with negative size")
+}
+
+// TestChunkList_PanicOnNegativeSize verifies ChunkList panics with negative size
+func TestChunkList_PanicOnNegativeSize(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	assert.Panics(t, func() {
+		itertools.ChunkList(iter, -2)
+	}, "ChunkList should panic with negative size")
+}
+
+// TestChunkSlice_ZeroSize tests that ChunkSlice panics with size=0
+func TestChunkSlice_ZeroSize(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	// Now correctly panics with zero size
+	assert.Panics(t, func() {
+		itertools.ChunkSlice(iter, 0).Collect()
+	}, "ChunkSlice should panic with zero size")
+}
+
+// TestChunks_ZeroSize tests that Chunks panics with size=0
+func TestChunks_ZeroSize(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	// Now correctly panics with zero size
+	assert.Panics(t, func() {
+		itertools.Chunks(iter, 0).Collect()
+	}, "Chunks should panic with zero size")
+}
+
+// TestFold_BasicOperation tests Fold with basic addition
+func TestFold_BasicOperation(t *testing.T) {
+	iter := itertools.Range(1, 6) // 1, 2, 3, 4, 5
+
+	sum := itertools.Fold(iter, func(acc, v int) int {
+		return acc + v
+	}, 0)
+
+	assert.Equal(t, 15, sum)
+}
+
+// TestFold_StringConcatenation tests Fold with string concatenation
+func TestFold_StringConcatenation(t *testing.T) {
+	iter := itertools.ToIter([]string{"a", "b", "c"})
+
+	result := itertools.Fold(iter, func(acc, v string) string {
+		return acc + v
+	}, "")
+
+	assert.Equal(t, "abc", result)
+}
+
+// TestCartesianProduct_EmptyIterators tests CartesianProduct with empty inputs
+func TestCartesianProduct_EmptyIterators(t *testing.T) {
+	iter1 := itertools.ToIter([]int{})
+	iter2 := itertools.ToIter([]string{"a", "b"})
+
+	result := itertools.CartesianProduct(iter1, iter2).Collect()
+
+	assert.Empty(t, result, "CartesianProduct with empty iterator should return empty")
+}
+
+// TestCartesianProduct_SingleElements tests CartesianProduct with single elements
+func TestCartesianProduct_SingleElements(t *testing.T) {
+	iter1 := itertools.ToIter([]int{1})
+	iter2 := itertools.ToIter([]string{"x"})
+
+	result := itertools.CartesianProduct(iter1, iter2).Collect()
+
+	assert.Equal(t, 1, len(result))
+	assert.Equal(t, 1, result[0].X)
+	assert.Equal(t, "x", result[0].Y)
+}
diff --git a/security_test.go b/security_test.go
new file mode 100644
index 0000000..0200ca9
--- /dev/null
+++ b/security_test.go
@@ -0,0 +1,335 @@
+package itertools_test
+
+import (
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/amjadjibon/itertools"
+	"github.com/stretchr/testify/assert"
+)
+
+// =============================================================================
+// GOROUTINE LEAK TESTS
+// =============================================================================
+
+// TestGoroutineLeakHelper is a helper to count goroutines
+func countGoroutines() int {
+	// Give time for goroutines to start/stop
+	runtime.Gosched()
+	time.Sleep(10 * time.Millisecond)
+	runtime.GC()
+	time.Sleep(10 * time.Millisecond)
+	return runtime.NumGoroutine()
+}
+
+// TestIteratorNext_GoroutineLeak_EarlyReturn tests goroutine leak with early return
+func TestIteratorNext_GoroutineLeak_EarlyReturn(t *testing.T) {
+	before := countGoroutines()
+
+	// Create 10 iterators and call Next() but never exhaust them
+	for i := 0; i < 10; i++ {
+		iter := itertools.Range(0, 1000000)
+		iter.Next()
+		_ = iter.Current()
+		// Iterator goes out of scope without exhausting - LEAK!
+	}
+
+	after := countGoroutines()
+	leaked := after - before
+
+	// We expect leaks in the current implementation
+	// After fix with Close(), this should be 0
+	if leaked > 0 {
+		t.Logf("WARNING: Detected %d leaked goroutines (expected before fix)", leaked)
+	}
+
+	// TODO: After implementing Close(), uncomment this assertion:
+	// assert.Equal(t, 0, leaked, "Should not leak goroutines after Close() is implemented")
+}
+
+// TestIteratorNext_GoroutineLeak_BreakInLoop tests goroutine leak with break
+func TestIteratorNext_GoroutineLeak_BreakInLoop(t *testing.T) {
+	before := countGoroutines()
+
+	// Create 10 iterators and break early
+	for i := 0; i < 10; i++ {
+		iter := itertools.Range(0, 1000000)
+		count := 0
+		for iter.Next() {
+			count++
+			if count >= 5 {
+				break // Early termination - LEAK!
+			}
+		}
+	}
+
+	after := countGoroutines()
+	leaked := after - before
+
+	if leaked > 0 {
+		t.Logf("WARNING: Detected %d leaked goroutines from break (expected before fix)", leaked)
+	}
+
+	// TODO: After implementing Close(), users should do:
+	// defer iter.Close()
+	// Then: assert.Equal(t, 0, leaked)
+}
+
+// TestIteratorNext_GoroutineLeak_ErrorReturn tests goroutine leak with error handling
+func TestIteratorNext_GoroutineLeak_ErrorReturn(t *testing.T) {
+	before := countGoroutines()
+
+	processWithError := func() error {
+		iter := itertools.Range(0, 1000000)
+		for iter.Next() {
+			if iter.Current() > 100 {
+				return assert.AnError // Early return - LEAK!
+			}
+		}
+		return nil
+	}
+
+	// Call it multiple times
+	for i := 0; i < 10; i++ {
+		_ = processWithError()
+	}
+
+	after := countGoroutines()
+	leaked := after - before
+
+	if leaked > 0 {
+		t.Logf("WARNING: Detected %d leaked goroutines from error return (expected before fix)", leaked)
+	}
+}
+
+// TestIteratorNext_NoLeak_FullExhaustion tests that full exhaustion doesn't leak
+func TestIteratorNext_NoLeak_FullExhaustion(t *testing.T) {
+	before := countGoroutines()
+
+	// Create and fully exhaust iterators
+	for i := 0; i < 10; i++ {
+		iter := itertools.Range(0, 100)
+		for iter.Next() {
+			_ = iter.Current()
+		}
+		// Fully exhausted - should not leak
+	}
+
+	after := countGoroutines()
+	leaked := after - before
+
+	// Full exhaustion should clean up properly
+	assert.LessOrEqual(t, leaked, 1, "Should not leak goroutines when fully exhausted")
+}
+
+// =============================================================================
+// PANIC TESTS - StepBy
+// =============================================================================
+
+// TestStepBy_PanicOnZero tests that StepBy panics with step=0
+func TestStepBy_PanicOnZero(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	assert.Panics(t, func() {
+		iter.StepBy(0).Collect()
+	}, "StepBy(0) should panic due to division by zero")
+}
+
+// TestStepBy_PanicOnNegative tests that StepBy with negative value panics
+func TestStepBy_InvalidWithNegative(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	// Now correctly panics with negative values
+	assert.Panics(t, func() {
+		iter.StepBy(-1).Collect()
+	}, "StepBy with negative step should panic")
+}
+
+// =============================================================================
+// PANIC TESTS - ChunkSlice (Note: Duplicate tests are in itertools_test.go)
+// =============================================================================
+
+// TestChunkSlice_InvalidWithZeroSize tests ChunkSlice with size=0 panics
+func TestChunkSlice_InvalidWithZeroSize(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	// Now correctly panics with zero size
+	assert.Panics(t, func() {
+		itertools.ChunkSlice(iter, 0).Collect()
+	}, "ChunkSlice with zero size should panic")
+}
+
+// =============================================================================
+// PANIC TESTS - Chunks (Note: Duplicate tests are in itertools_test.go)
+// =============================================================================
+
+// TestChunks_InvalidWithZeroSize tests Chunks with size=0 panics
+func TestChunks_InvalidWithZeroSize(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	// Now correctly panics with zero size
+	assert.Panics(t, func() {
+		itertools.Chunks(iter, 0).Collect()
+	}, "Chunks with zero size should panic")
+}
+
+// =============================================================================
+// EDGE CASE TESTS - Negative Values
+// =============================================================================
+
+// TestTake_NegativeValue tests Take with negative value (treated as 0)
+func TestTake_NegativeValue(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	// Negative values are now treated as 0 (returns empty)
+	result := iter.Take(-1).Collect()
+
+	assert.Empty(t, result, "Take with negative value should return empty (treated as 0)")
+}
+
+// TestDrop_NegativeValue tests Drop with negative value (treated as 0)
+func TestDrop_NegativeValue(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	// Negative values are now treated as 0 (returns all elements)
+	result := iter.Drop(-1).Collect()
+
+	assert.Equal(t, 10, len(result), "Drop with negative value should return all elements (treated as 0)")
+	assert.Equal(t, []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, result)
+}
+
+// TestNth_NegativeIndex tests Nth with negative index (treated as 0)
+func TestNth_NegativeIndex(t *testing.T) {
+	iter := itertools.Range(0, 10)
+
+	// Negative values are now treated as 0 (returns first element)
+	result := iter.Nth(-1)
+
+	assert.Equal(t, 0, result, "Nth with negative index should return first element (treated as 0)")
+}
+
+// =============================================================================
+// MEMORY LEAK TESTS - Infinite Iterators
+// =============================================================================
+
+// TestCollect_InfiniteIterator_MemoryLeak tests that Collect on infinite iterator causes OOM
+// NOTE: This test is disabled by default as it will cause OOM
+func TestCollect_InfiniteIterator_MemoryLeak(t *testing.T) {
+	t.Skip("Skipping OOM test - would cause memory exhaustion")
+
+	// This would cause OOM:
+	// infiniteIter := itertools.FromFunc(func() (int, bool) {
+	//     return rand.Int(), true
+	// })
+	// infiniteIter.Collect() // OOM!
+}
+
+// TestCollect_LargeButFinite tests memory usage with large finite iterator
+func TestCollect_LargeButFinite(t *testing.T) {
+	// Collect 1 million integers
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+	before := m.Alloc
+
+	iter := itertools.Range(0, 1000000)
+	result := iter.Collect()
+
+	runtime.ReadMemStats(&m)
+	after := m.Alloc
+	allocated := after - before
+
+	// Should have allocated approximately 1M * 8 bytes = 8MB for int slice
+	// (plus overhead for slice header, etc.)
+	t.Logf("Collected %d elements, allocated ~%.2f MB", len(result), float64(allocated)/(1024*1024))
+
+	assert.Equal(t, 1000000, len(result), "Should collect all elements")
+	assert.Greater(t, allocated, uint64(8*1000000), "Should allocate memory for elements")
+}
+
+// =============================================================================
+// RESOURCE CLEANUP TESTS
+// =============================================================================
+
+// TestIterator_Close_Method tests that Close method exists and works
+// NOTE: This will fail until Close() is implemented
+func TestIterator_Close_Method(t *testing.T) {
+	t.Skip("Skipping until Close() method is implemented")
+
+	// After implementation, test should work like this:
+	// iter := itertools.Range(0, 1000000)
+	// iter.Next()
+	// iter.Close() // Should not panic
+}
+
+// TestIterator_Close_Idempotent tests that Close can be called multiple times
+func TestIterator_Close_Idempotent(t *testing.T) {
+	t.Skip("Skipping until Close() method is implemented")
+
+	// After implementation:
+	// iter := itertools.Range(0, 1000000)
+	// iter.Close()
+	// iter.Close() // Should not panic
+	// iter.Close() // Should not panic
+}
+
+// TestIterator_Close_WithDefer tests proper defer cleanup pattern
+func TestIterator_Close_WithDefer(t *testing.T) {
+	t.Skip("Skipping until Close() method is implemented")
+
+	// After implementation, recommended pattern:
+	// before := countGoroutines()
+	//
+	// for i := 0; i < 10; i++ {
+	//     iter := itertools.Range(0, 1000000)
+	//     defer iter.Close() // Proper cleanup
+	//     iter.Next()
+	//     _ = iter.Current()
+	// }
+	//
+	// after := countGoroutines()
+	// assert.Equal(t, 0, after-before, "Should not leak with proper Close()")
+}
+
+// =============================================================================
+// CONCURRENT ACCESS TESTS
+// =============================================================================
+
+// TestIterator_ConcurrentAccess tests thread safety
+func TestIterator_ConcurrentAccess(t *testing.T) {
+	// Iterators should NOT be used concurrently
+	// This test documents the expected behavior
+
+	// This is UNSAFE and can cause data races
+	// Users should not do this
+	t.Run("Unsafe Concurrent Access", func(t *testing.T) {
+		// Don't actually run concurrent access in test
+		// Just document that it's unsafe
+		t.Log("Iterators are NOT thread-safe - do not use from multiple goroutines")
+	})
+}
+
+// =============================================================================
+// BENCHMARK - Leak Impact
+// =============================================================================
+
+// BenchmarkIteratorNext_WithLeak benchmarks the impact of goroutine leaks
+func BenchmarkIteratorNext_WithLeak(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		iter := itertools.Range(0, 1000)
+		iter.Next()
+		_ = iter.Current()
+		// Leak occurs here
+	}
+}
+
+// BenchmarkIteratorNext_FullExhaustion benchmarks proper full exhaustion
+func BenchmarkIteratorNext_FullExhaustion(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		iter := itertools.Range(0, 1000)
+		for iter.Next() {
+			_ = iter.Current()
+		}
+		// No leak
+	}
+}