Add tests for cancelations

iter.go

@@ -15,11 +15,18 @@ func (iterCh *IterChCloser) Close() error {
 	case iterCh.canceled <- struct{}{}:
 	default:
 	}
+
 	return nil
 }
 
 func (iterCh *IterChCloser) Records() <-chan Record {
-	return iterCh.ch
+	select {
+	case <-iterCh.canceled:
+		iterCh.canceled <- struct{}{}
+		return nil
+	default:
+		return iterCh.ch
+	}
 }
 
 // IterChParams contains configurable settings for CustomIterCh.
@@ -59,16 +66,19 @@ func (sm *SortedMap) recordFromIdx(i int) Record {
 }
 
 func (sm *SortedMap) sendRecord(iterCh IterChCloser, sendTimeout time.Duration, i int) bool {
+	select {
+	case <-iterCh.canceled:
+		iterCh.canceled <- struct{}{}
+		return false
+	default:
+	}
 
 	if sendTimeout <= time.Duration(0) {
 		iterCh.ch <- sm.recordFromIdx(i)
 		return true
 	}
 
 	select {
-	case <-iterCh.canceled:
-		return false
-
 	case iterCh.ch <- sm.recordFromIdx(i):
 		return true
 

iter_test.go

@@ -281,6 +281,39 @@ func TestCustomIterCh(t *testing.T) {
 	}()
 }
 
+func TestCancelCustomIterCh(t *testing.T) {
+	sm, _, err := newSortedMapFromRandRecords(1000)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	earlierDate := time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC)
+	laterDate := time.Now()
+
+	func() {
+		params := IterChParams{
+			LowerBound: earlierDate,
+			UpperBound: laterDate,
+		}
+
+		ch, err := sm.CustomIterCh(params)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer ch.Close()
+
+		ch.Close()
+
+		if err := verifyRecords(ch.Records(), params.Reversed); err != nil {
+			if err.Error() != "Channel was nil." {
+				t.Fatal(err)
+			}
+		} else {
+			t.Fatal("Channel was not closed.")
+		}
+	}()
+}
+
 func TestIterFunc(t *testing.T) {
 	sm, _, err := newSortedMapFromRandRecords(1000)
 	if err != nil {
@@ -362,6 +395,17 @@ func TestBoundedIterFunc(t *testing.T) {
 	}
 }
 
+func TestTestBoundedIterFuncWithNoBoundsReturned(t *testing.T) {
+	sm, _, err := newSortedMapFromRandRecords(1000)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := sm.BoundedKeys(time.Now().Add(-1*time.Microsecond), time.Now()); err == nil {
+		t.Fatal("Values fall between or are equal to the given bounds when it should not have returned bounds.")
+	}
+}
+
 func TestReversedBoundedIterFunc(t *testing.T) {
 	sm, _, err := newSortedMapFromRandRecords(1000)
 	if err != nil {

keys_test.go

@@ -43,3 +43,13 @@ func TestBoundedKeys(t *testing.T) {
 		t.Fatal("The returned slice was empty.")
 	}
 }
+
+func TestBoundedKeysWithNoBoundsReturned(t *testing.T) {
+	sm, _, err := newSortedMapFromRandRecords(300)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if val, err := sm.BoundedKeys(time.Now().Add(-1*time.Microsecond), time.Now()); err == nil {
+		t.Fatalf("Values fall between or are equal to the given bounds when it should not have returned bounds: %+v", sm.idx[val[0]])
+	}
+}

testing_utils_test.go

@@ -53,26 +53,30 @@ func randRecords(n int) []Record {
 func verifyRecords(ch <-chan Record, reverse bool) error {
 	previousRec := Record{}
 
-	for rec := range ch {
-		if previousRec.Key != nil {
-			switch reverse {
-			case false:
-				if previousRec.Val.(time.Time).After(rec.Val.(time.Time)) {
-					return fmt.Errorf("%v %v",
-						unsortedErr,
-						fmt.Sprintf("prev: %+v, current: %+v.", previousRec, rec),
-					)
-				}
-			case true:
-				if previousRec.Val.(time.Time).Before(rec.Val.(time.Time)) {
-					return fmt.Errorf("%v %v",
-						unsortedErr,
-						fmt.Sprintf("prev: %+v, current: %+v.", previousRec, rec),
-					)
+	if ch != nil {
+		for rec := range ch {
+			if previousRec.Key != nil {
+				switch reverse {
+				case false:
+					if previousRec.Val.(time.Time).After(rec.Val.(time.Time)) {
+						return fmt.Errorf("%v %v",
+							unsortedErr,
+							fmt.Sprintf("prev: %+v, current: %+v.", previousRec, rec),
+						)
+					}
+				case true:
+					if previousRec.Val.(time.Time).Before(rec.Val.(time.Time)) {
+						return fmt.Errorf("%v %v",
+							unsortedErr,
+							fmt.Sprintf("prev: %+v, current: %+v.", previousRec, rec),
+						)
+					}
 				}
 			}
+			previousRec = rec
 		}
-		previousRec = rec
+	} else {
+		return fmt.Errorf("Channel was nil.")
 	}
 
 	return nil