diff --git a/add.go b/add.go index 701a496..57f3eee 100644 --- a/add.go +++ b/add.go @@ -1,8 +1,17 @@ package interval -func (intvls *intervals) Add(itvl *Interval) { +func (intvls *intervals) Add(itvl *Interval) error { + low := intvls.getInclusiveLow(itvl.Low) + high := intvls.getInclusiveHigh(itvl.High) + + err := intvls.checkValidInterval(low, high) + if err != nil { + return err + } + intvls.Intervals = append(intvls.Intervals, itvl) intvls.reset() + return nil } func (intvls *intervals) reset() { diff --git a/demo_test.go b/demo_test.go index c176999..b2c4281 100644 --- a/demo_test.go +++ b/demo_test.go @@ -1,10 +1,15 @@ package interval_test -import "bitbucket.org/differenttravel/interval" +import ( + "fmt" + + "bitbucket.org/differenttravel/interval" +) type demo struct { - Intervals interval.Intervals - ExpectedGaps []interval.Interval + Intervals interval.Intervals + ExpectedGaps []interval.Interval + ExpectedOverlaps []interval.Interval } /////////////////////////////////////////////////////////// @@ -23,7 +28,10 @@ func buildIntervalsDemo001() demo { // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval at the beginning (low/high inclusive) @@ -36,12 +44,17 @@ func buildIntervalsDemo002() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: minLow, High: 4}) + if err := itvls.Add(&interval.Interval{Low: minLow, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: 5, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval at the end (low/high inclusive) @@ -54,12 +67,17 @@ func buildIntervalsDemo003() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 8, High: maxHigh}) + if err := itvls.Add(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 7}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval in the middle (low/high inclusive) @@ -72,13 +90,18 @@ func buildIntervalsDemo004() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 5, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 5, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 4}) gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // two intervals in the middle, one inside the other (low/high inclusive) @@ -91,14 +114,22 @@ func buildIntervalsDemo005() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 8}) - itvls.Add(&interval.Interval{Low: 4, High: 6}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 4, High: 6}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // two intervals in the middle, not overlapping (low/high inclusive) @@ -111,15 +142,22 @@ func buildIntervalsDemo006() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 6, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 6, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 5, High: 5}) gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // two intervals in the middle, consecutives (not overlapping) (low/high inclusive) @@ -132,14 +170,21 @@ func buildIntervalsDemo007() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 4, High: 6}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 3}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 7, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // two intervals in the middle, overlapping by 1 position (low/high inclusive) @@ -152,14 +197,22 @@ func buildIntervalsDemo008() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 6}) - itvls.Add(&interval.Interval{Low: 6, High: 7}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 6, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 6, High: 6}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // two intervals in the middle, overlapping by 3 positions (low/high inclusive) @@ -172,14 +225,22 @@ func buildIntervalsDemo009() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 6}) - itvls.Add(&interval.Interval{Low: 4, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 4, High: 6}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // three intervals (leading, middle and trailing), not overlapping (low/high inclusive) @@ -192,15 +253,24 @@ func buildIntervalsDemo010() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: minLow, High: 2}) - itvls.Add(&interval.Interval{Low: 4, High: 4}) - itvls.Add(&interval.Interval{Low: 8, High: maxHigh}) + if err := itvls.Add(&interval.Interval{Low: minLow, High: 2}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: 3, High: 3}) gaps = append(gaps, interval.Interval{Low: 5, High: 7}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // three intervals (in the middle), overlapping (low/high inclusive) @@ -213,15 +283,26 @@ func buildIntervalsDemo011() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 3, High: 6}) - itvls.Add(&interval.Interval{Low: 5, High: 7}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 3, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 5, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 3, High: 4}) + overlaps = append(overlaps, interval.Interval{Low: 5, High: 6}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // complex case with a lot of intervals and overlapping (low/high inclusive) @@ -234,16 +315,36 @@ func buildIntervalsDemo012() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 5, High: 7}) - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 35, High: 35}) - itvls.Add(&interval.Interval{Low: 3, High: 6}) - itvls.Add(&interval.Interval{Low: 18, High: 20}) - itvls.Add(&interval.Interval{Low: 20, High: 30}) - itvls.Add(&interval.Interval{Low: 25, High: 28}) - itvls.Add(&interval.Interval{Low: minLow, High: 1}) - itvls.Add(&interval.Interval{Low: 30, High: 32}) - itvls.Add(&interval.Interval{Low: 10, High: 12}) + if err := itvls.Add(&interval.Interval{Low: 5, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 35, High: 35}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 3, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 18, High: 20}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 20, High: 30}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 25, High: 28}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: minLow, High: 1}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 30, High: 32}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 10, High: 12}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} @@ -251,7 +352,15 @@ func buildIntervalsDemo012() demo { gaps = append(gaps, interval.Interval{Low: 13, High: 17}) gaps = append(gaps, interval.Interval{Low: 33, High: 34}) gaps = append(gaps, interval.Interval{Low: 36, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 3, High: 4}) + overlaps = append(overlaps, interval.Interval{Low: 5, High: 6}) + overlaps = append(overlaps, interval.Interval{Low: 20, High: 20}) + overlaps = append(overlaps, interval.Interval{Low: 25, High: 28}) + overlaps = append(overlaps, interval.Interval{Low: 30, High: 30}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } /////////////////////////////////////////////////////////// @@ -270,7 +379,10 @@ func buildIntervalsDemo101() demo { // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval at the beginning (low/high exclusive) @@ -283,13 +395,18 @@ func buildIntervalsDemo102() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: minLow, High: 4}) + if err := itvls.Add(&interval.Interval{Low: minLow, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: minLow}) gaps = append(gaps, interval.Interval{Low: 4, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval at the end (low/high exclusive) @@ -302,13 +419,18 @@ func buildIntervalsDemo103() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 8, High: maxHigh}) + if err := itvls.Add(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 8}) gaps = append(gaps, interval.Interval{Low: maxHigh, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval in the middle (low/high exclusive) @@ -321,13 +443,18 @@ func buildIntervalsDemo104() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 5, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 5, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 5}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // two intervals in the middle, one inside the other (low/high exclusive) @@ -340,17 +467,25 @@ func buildIntervalsDemo105() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 8}) - itvls.Add(&interval.Interval{Low: 4, High: 6}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 5, High: 5}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, not overlapping (low/high exclusive) +// two intervals in the middle (low/high exclusive) func buildIntervalsDemo106() demo { // initialize Intervals minLow := 0 @@ -360,18 +495,25 @@ func buildIntervalsDemo106() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 6, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 6, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 4, High: 6}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, consecutives (not overlapping) (low/high exclusive) +// two intervals in the middle, consecutives (low/high exclusive) func buildIntervalsDemo107() demo { // initialize Intervals minLow := 0 @@ -381,18 +523,25 @@ func buildIntervalsDemo107() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 4, High: 6}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 4, High: 4}) gaps = append(gaps, interval.Interval{Low: 6, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, overlapping by 1 position (low/high exclusive) +// two intervals in the middle (low/high exclusive) func buildIntervalsDemo108() demo { // initialize Intervals minLow := 0 @@ -402,17 +551,24 @@ func buildIntervalsDemo108() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 6}) - itvls.Add(&interval.Interval{Low: 6, High: 7}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 6, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 6, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, overlapping by 3 positions (low/high exclusive) +// two intervals in the middle (low/high exclusive) func buildIntervalsDemo109() demo { // initialize Intervals minLow := 0 @@ -422,17 +578,25 @@ func buildIntervalsDemo109() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 6}) - itvls.Add(&interval.Interval{Low: 4, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 5, High: 5}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// three intervals (leading, middle and trailing), not overlapping (low/high exclusive) +// three intervals (leading, middle and trailing) (low/high exclusive) func buildIntervalsDemo110() demo { // initialize Intervals minLow := 0 @@ -442,19 +606,28 @@ func buildIntervalsDemo110() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: minLow, High: 2}) - itvls.Add(&interval.Interval{Low: 4, High: 4}) - itvls.Add(&interval.Interval{Low: 8, High: maxHigh}) + if err := itvls.Add(&interval.Interval{Low: minLow, High: 2}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: minLow}) gaps = append(gaps, interval.Interval{Low: 2, High: 8}) gaps = append(gaps, interval.Interval{Low: maxHigh, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// three intervals (in the middle), overlapping (low/high exclusive) +// three intervals (in the middle) (low/high exclusive) func buildIntervalsDemo111() demo { // initialize Intervals minLow := 0 @@ -464,18 +637,27 @@ func buildIntervalsDemo111() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 3, High: 6}) - itvls.Add(&interval.Interval{Low: 5, High: 7}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 3, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 5, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 7, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// complex case with a lot of intervals and overlapping (low/high exclusive) +// complex case with a lot of intervals (low/high exclusive) func buildIntervalsDemo112() demo { // initialize Intervals minLow := 0 @@ -485,16 +667,36 @@ func buildIntervalsDemo112() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 5, High: 7}) - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 35, High: 35}) - itvls.Add(&interval.Interval{Low: 3, High: 6}) - itvls.Add(&interval.Interval{Low: 18, High: 20}) - itvls.Add(&interval.Interval{Low: 20, High: 30}) - itvls.Add(&interval.Interval{Low: 25, High: 28}) - itvls.Add(&interval.Interval{Low: minLow, High: 1}) - itvls.Add(&interval.Interval{Low: 30, High: 32}) - itvls.Add(&interval.Interval{Low: 10, High: 12}) + if err := itvls.Add(&interval.Interval{Low: 5, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 35, High: 35}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 3, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 18, High: 20}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 20, High: 30}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 25, High: 28}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: minLow, High: 1}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 30, High: 32}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 10, High: 12}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} @@ -504,7 +706,11 @@ func buildIntervalsDemo112() demo { gaps = append(gaps, interval.Interval{Low: 20, High: 20}) gaps = append(gaps, interval.Interval{Low: 30, High: 30}) gaps = append(gaps, interval.Interval{Low: 32, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 26, High: 27}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } ///////////////////////////////////////////////////////////////// @@ -523,7 +729,10 @@ func buildIntervalsDemo201() demo { // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval at the beginning (low inclusive and high exclusive) @@ -536,12 +745,17 @@ func buildIntervalsDemo202() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: minLow, High: 4}) + if err := itvls.Add(&interval.Interval{Low: minLow, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: 4, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval at the end (low inclusive and high exclusive) @@ -554,13 +768,18 @@ func buildIntervalsDemo203() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 8, High: maxHigh}) + if err := itvls.Add(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 7}) gaps = append(gaps, interval.Interval{Low: maxHigh, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval in the middle (low inclusive and high exclusive) @@ -573,13 +792,18 @@ func buildIntervalsDemo204() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 5, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 5, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 4}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // two intervals in the middle, one inside the other (low inclusive and high exclusive) @@ -592,17 +816,25 @@ func buildIntervalsDemo205() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 8}) - itvls.Add(&interval.Interval{Low: 4, High: 6}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 4, High: 5}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, not overlapping (low inclusive and high exclusive) +// two intervals in the middle (low inclusive and high exclusive) func buildIntervalsDemo206() demo { // initialize Intervals minLow := 0 @@ -612,18 +844,25 @@ func buildIntervalsDemo206() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 6, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 6, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 4, High: 5}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, consecutives (not overlapping) (low inclusive and high exclusive) +// two intervals in the middle, consecutives (low inclusive and high exclusive) func buildIntervalsDemo207() demo { // initialize Intervals minLow := 0 @@ -633,17 +872,24 @@ func buildIntervalsDemo207() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 4, High: 6}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 6, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, overlapping by 1 position (low inclusive and high exclusive) +// two intervals in the middle (low inclusive and high exclusive) func buildIntervalsDemo208() demo { // initialize Intervals minLow := 0 @@ -653,17 +899,24 @@ func buildIntervalsDemo208() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 6}) - itvls.Add(&interval.Interval{Low: 6, High: 7}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 6, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 7, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, overlapping by 3 positions (low inclusive and high exclusive) +// two intervals in the middle (low inclusive and high exclusive) func buildIntervalsDemo209() demo { // initialize Intervals minLow := 0 @@ -673,17 +926,25 @@ func buildIntervalsDemo209() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 6}) - itvls.Add(&interval.Interval{Low: 4, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 4, High: 5}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// three intervals (leading, middle and trailing), not overlapping (low inclusive and high exclusive) +// three intervals (leading, middle and trailing) (low inclusive and high exclusive) func buildIntervalsDemo210() demo { // initialize Intervals minLow := 0 @@ -693,18 +954,27 @@ func buildIntervalsDemo210() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: minLow, High: 2}) - itvls.Add(&interval.Interval{Low: 4, High: 4}) - itvls.Add(&interval.Interval{Low: 8, High: maxHigh}) + if err := itvls.Add(&interval.Interval{Low: minLow, High: 2}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: 2, High: 7}) gaps = append(gaps, interval.Interval{Low: maxHigh, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// three intervals (in the middle), overlapping (low inclusive and high exclusive) +// three intervals (in the middle) (low inclusive and high exclusive) func buildIntervalsDemo211() demo { // initialize Intervals minLow := 0 @@ -714,18 +984,29 @@ func buildIntervalsDemo211() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 3, High: 6}) - itvls.Add(&interval.Interval{Low: 5, High: 7}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 3, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 5, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 1}) gaps = append(gaps, interval.Interval{Low: 7, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 3, High: 3}) + overlaps = append(overlaps, interval.Interval{Low: 5, High: 5}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// complex case with a lot of intervals and overlapping (low inclusive and high exclusive) +// complex case with a lot of intervals (low inclusive and high exclusive) func buildIntervalsDemo212() demo { // initialize Intervals minLow := 0 @@ -735,16 +1016,36 @@ func buildIntervalsDemo212() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 5, High: 7}) - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 35, High: 35}) - itvls.Add(&interval.Interval{Low: 3, High: 6}) - itvls.Add(&interval.Interval{Low: 18, High: 20}) - itvls.Add(&interval.Interval{Low: 20, High: 30}) - itvls.Add(&interval.Interval{Low: 25, High: 28}) - itvls.Add(&interval.Interval{Low: minLow, High: 1}) - itvls.Add(&interval.Interval{Low: 30, High: 32}) - itvls.Add(&interval.Interval{Low: 10, High: 12}) + if err := itvls.Add(&interval.Interval{Low: 5, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 35, High: 35}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 3, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 18, High: 20}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 20, High: 30}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 25, High: 28}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: minLow, High: 1}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 30, High: 32}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 10, High: 12}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} @@ -752,7 +1053,13 @@ func buildIntervalsDemo212() demo { gaps = append(gaps, interval.Interval{Low: 7, High: 9}) gaps = append(gaps, interval.Interval{Low: 12, High: 17}) gaps = append(gaps, interval.Interval{Low: 32, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 3, High: 3}) + overlaps = append(overlaps, interval.Interval{Low: 5, High: 5}) + overlaps = append(overlaps, interval.Interval{Low: 25, High: 27}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } ///////////////////////////////////////////////////////////////// @@ -771,7 +1078,10 @@ func buildIntervalsDemo301() demo { // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval at the beginning (low exclusive and high inclusive) @@ -784,13 +1094,18 @@ func buildIntervalsDemo302() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: minLow, High: 4}) + if err := itvls.Add(&interval.Interval{Low: minLow, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: minLow}) gaps = append(gaps, interval.Interval{Low: 5, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval at the end (low exclusive and high inclusive) @@ -803,12 +1118,17 @@ func buildIntervalsDemo303() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 8, High: maxHigh}) + if err := itvls.Add(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 8}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // one interval in the middle (low exclusive and high inclusive) @@ -821,13 +1141,18 @@ func buildIntervalsDemo304() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 5, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 5, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 5}) gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } // two intervals in the middle, one inside the other (low exclusive and high inclusive) @@ -840,17 +1165,25 @@ func buildIntervalsDemo305() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 8}) - itvls.Add(&interval.Interval{Low: 4, High: 6}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 5, High: 6}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, not overlapping (low exclusive and high inclusive) +// two intervals in the middle (low exclusive and high inclusive) func buildIntervalsDemo306() demo { // initialize Intervals minLow := 0 @@ -860,18 +1193,25 @@ func buildIntervalsDemo306() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 6, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 6, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 5, High: 6}) gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, consecutives (not overlapping) (low exclusive and high inclusive) +// two intervals in the middle, consecutives (low exclusive and high inclusive) func buildIntervalsDemo307() demo { // initialize Intervals minLow := 0 @@ -881,17 +1221,24 @@ func buildIntervalsDemo307() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 4, High: 6}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 7, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, overlapping by 1 position (low exclusive and high inclusive) +// two intervals in the middle (low exclusive and high inclusive) func buildIntervalsDemo308() demo { // initialize Intervals minLow := 0 @@ -901,17 +1248,24 @@ func buildIntervalsDemo308() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 6}) - itvls.Add(&interval.Interval{Low: 6, High: 7}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 6, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// two intervals in the middle, overlapping by 3 positions (low exclusive and high inclusive) +// two intervals in the middle (low exclusive and high inclusive) func buildIntervalsDemo309() demo { // initialize Intervals minLow := 0 @@ -921,17 +1275,25 @@ func buildIntervalsDemo309() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 6}) - itvls.Add(&interval.Interval{Low: 4, High: 8}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 8}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 9, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 5, High: 6}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// three intervals (leading, middle and trailing), not overlapping (low exclusive and high inclusive) +// three intervals (leading, middle and trailing) (low exclusive and high inclusive) func buildIntervalsDemo310() demo { // initialize Intervals minLow := 0 @@ -941,18 +1303,27 @@ func buildIntervalsDemo310() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: minLow, High: 2}) - itvls.Add(&interval.Interval{Low: 4, High: 4}) - itvls.Add(&interval.Interval{Low: 8, High: maxHigh}) + if err := itvls.Add(&interval.Interval{Low: minLow, High: 2}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 4, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 8, High: maxHigh}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: minLow}) gaps = append(gaps, interval.Interval{Low: 3, High: 8}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// three intervals (in the middle), overlapping (low exclusive and high inclusive) +// three intervals (in the middle) (low exclusive and high inclusive) func buildIntervalsDemo311() demo { // initialize Intervals minLow := 0 @@ -962,18 +1333,29 @@ func buildIntervalsDemo311() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 3, High: 6}) - itvls.Add(&interval.Interval{Low: 5, High: 7}) + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 3, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 5, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} gaps = append(gaps, interval.Interval{Low: minLow, High: 2}) gaps = append(gaps, interval.Interval{Low: 8, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 4, High: 4}) + overlaps = append(overlaps, interval.Interval{Low: 6, High: 6}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } -// complex case with a lot of intervals and overlapping (low exclusive and high inclusive) +// complex case with a lot of intervals (low exclusive and high inclusive) func buildIntervalsDemo312() demo { // initialize Intervals minLow := 0 @@ -983,16 +1365,36 @@ func buildIntervalsDemo312() demo { itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive) // add intervals - itvls.Add(&interval.Interval{Low: 5, High: 7}) - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 35, High: 35}) - itvls.Add(&interval.Interval{Low: 3, High: 6}) - itvls.Add(&interval.Interval{Low: 18, High: 20}) - itvls.Add(&interval.Interval{Low: 20, High: 30}) - itvls.Add(&interval.Interval{Low: 25, High: 28}) - itvls.Add(&interval.Interval{Low: minLow, High: 1}) - itvls.Add(&interval.Interval{Low: 30, High: 32}) - itvls.Add(&interval.Interval{Low: 10, High: 12}) + if err := itvls.Add(&interval.Interval{Low: 5, High: 7}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 2, High: 4}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 35, High: 35}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 3, High: 6}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 18, High: 20}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 20, High: 30}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 25, High: 28}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: minLow, High: 1}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 30, High: 32}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + if err := itvls.Add(&interval.Interval{Low: 10, High: 12}); err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } // calculate expected gaps gaps := []interval.Interval{} @@ -1001,5 +1403,11 @@ func buildIntervalsDemo312() demo { gaps = append(gaps, interval.Interval{Low: 8, High: 10}) gaps = append(gaps, interval.Interval{Low: 13, High: 18}) gaps = append(gaps, interval.Interval{Low: 33, High: maxHigh}) - return demo{Intervals: itvls, ExpectedGaps: gaps} + + // calculate expected overlaps + overlaps := []interval.Interval{} + overlaps = append(overlaps, interval.Interval{Low: 4, High: 4}) + overlaps = append(overlaps, interval.Interval{Low: 6, High: 6}) + overlaps = append(overlaps, interval.Interval{Low: 26, High: 28}) + return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps} } diff --git a/example/main.go b/example/main.go index c2e317f..241c599 100644 --- a/example/main.go +++ b/example/main.go @@ -110,7 +110,10 @@ func initIntervals(xys []xy) interval.Intervals { } for _, xy := range xys { - intervals.Add(&interval.Interval{Low: xy.x, High: xy.y}) + err := intervals.Add(&interval.Interval{Low: xy.x, High: xy.y}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } } intervals.Sort() return intervals diff --git a/inclusives.go b/inclusives.go index 7a7fea4..958690e 100644 --- a/inclusives.go +++ b/inclusives.go @@ -1,22 +1,28 @@ package interval -import ( - "fmt" -) +import "fmt" func (intvls *intervals) getInclusives(intervalLow, intervalHigh int) (int, int, error) { low := intvls.getInclusiveLow(intervalLow) high := intvls.getInclusiveHigh(intervalHigh) + err := intvls.checkValidInterval(low, high) + if err != nil { + return 0, 0, err + } + return low, high, nil +} + +func (intvls *intervals) checkValidInterval(low, high int) error { // if we get an incoherent result it's because it's invalid, for example in this case: // (low,high)=(0,1) --> if we add 1 to the Low and substract 1 to the High ends with (1,0) which is not valid if low > high { - return 0, 0, fmt.Errorf("low (%v) can not be bigger than high (%v)", low, high) + return fmt.Errorf("low (%v) can not be bigger than high (%v)", low, high) } if high < low { - return 0, 0, fmt.Errorf("high (%v) can not be smaller than low (%v)", high, low) + return fmt.Errorf("high (%v) can not be smaller than low (%v)", high, low) } - return low, high, nil + return nil } func (intvls *intervals) getInclusiveLow(value int) int { diff --git a/interval_test.go b/interval_test.go index 5a59ef5..a5410d9 100644 --- a/interval_test.go +++ b/interval_test.go @@ -10,13 +10,35 @@ import ( func TestInsert(t *testing.T) { itvls := interval.NewIntervals(0, 100, true, true) - itvls.Add(&interval.Interval{Low: 5, High: 7}) - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 3, High: 6}) - itvls.Add(&interval.Interval{Low: 18, High: 20}) - itvls.Add(&interval.Interval{Low: 20, High: 30}) - itvls.Add(&interval.Interval{Low: 25, High: 28}) - itvls.Add(&interval.Interval{Low: 30, High: 32}) + var err error + err = itvls.Add(&interval.Interval{Low: 5, High: 7}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 2, High: 4}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 3, High: 6}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 18, High: 20}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 20, High: 30}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 25, High: 28}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 30, High: 32}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } tt := []struct { name string @@ -35,13 +57,35 @@ func TestInsert(t *testing.T) { func TestFindIntervalsForValue(t *testing.T) { itvls := interval.NewIntervals(0, 100, true, true) - itvls.Add(&interval.Interval{Low: 5, High: 7}) - itvls.Add(&interval.Interval{Low: 2, High: 4}) - itvls.Add(&interval.Interval{Low: 3, High: 6}) - itvls.Add(&interval.Interval{Low: 18, High: 20}) - itvls.Add(&interval.Interval{Low: 20, High: 30}) - itvls.Add(&interval.Interval{Low: 25, High: 28}) - itvls.Add(&interval.Interval{Low: 30, High: 32}) + var err error + err = itvls.Add(&interval.Interval{Low: 5, High: 7}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 2, High: 4}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 3, High: 6}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 18, High: 20}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 20, High: 30}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 25, High: 28}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } + err = itvls.Add(&interval.Interval{Low: 30, High: 32}) + if err != nil { + fmt.Printf("invalid interval discarded: %v\n", err) + } valueToFind1 := 2 matches1 := itvls.FindIntervalsForValue(valueToFind1) diff --git a/intervals.go b/intervals.go index 3237147..e0cb8fb 100644 --- a/intervals.go +++ b/intervals.go @@ -13,7 +13,8 @@ const ( // Intervals is an interface to handle Interval structures discovering the existence of gaps or overlays type Intervals interface { - Add(itvl *Interval) + // Add appends a new interval to the list. If the interval range (low, high) is invalid, it returns an error + Add(itvl *Interval) error // Sort sorts the intervals list by the Low property (ascending) Sort() diff --git a/overlap_test.go b/overlap_test.go new file mode 100644 index 0000000..9120ef8 --- /dev/null +++ b/overlap_test.go @@ -0,0 +1,143 @@ +package interval_test + +import ( + "testing" + + "bitbucket.org/differenttravel/interval" +) + +func TestOverlapped(t *testing.T) { + // tests for low/high inclusive + demo001 := buildIntervalsDemo001() + demo002 := buildIntervalsDemo002() + demo003 := buildIntervalsDemo003() + demo004 := buildIntervalsDemo004() + demo005 := buildIntervalsDemo005() + demo006 := buildIntervalsDemo006() + demo007 := buildIntervalsDemo007() + demo008 := buildIntervalsDemo008() + demo009 := buildIntervalsDemo009() + demo010 := buildIntervalsDemo010() + demo011 := buildIntervalsDemo011() + demo012 := buildIntervalsDemo012() + + // tests for low/high exclusive + demo101 := buildIntervalsDemo101() + demo102 := buildIntervalsDemo102() + demo103 := buildIntervalsDemo103() + demo104 := buildIntervalsDemo104() + demo105 := buildIntervalsDemo105() + demo106 := buildIntervalsDemo106() + demo107 := buildIntervalsDemo107() + demo108 := buildIntervalsDemo108() + demo109 := buildIntervalsDemo109() + demo110 := buildIntervalsDemo110() + demo111 := buildIntervalsDemo111() + demo112 := buildIntervalsDemo112() + + // tests for low inclusive and high exclusive + demo201 := buildIntervalsDemo201() + demo202 := buildIntervalsDemo202() + demo203 := buildIntervalsDemo203() + demo204 := buildIntervalsDemo204() + demo205 := buildIntervalsDemo205() + demo206 := buildIntervalsDemo206() + demo207 := buildIntervalsDemo207() + demo208 := buildIntervalsDemo208() + demo209 := buildIntervalsDemo209() + demo210 := buildIntervalsDemo210() + demo211 := buildIntervalsDemo211() + demo212 := buildIntervalsDemo212() + + // tests for low exclusive and high inclusive + demo301 := buildIntervalsDemo301() + demo302 := buildIntervalsDemo302() + demo303 := buildIntervalsDemo303() + demo304 := buildIntervalsDemo304() + demo305 := buildIntervalsDemo305() + demo306 := buildIntervalsDemo306() + demo307 := buildIntervalsDemo307() + demo308 := buildIntervalsDemo308() + demo309 := buildIntervalsDemo309() + demo310 := buildIntervalsDemo310() + demo311 := buildIntervalsDemo311() + demo312 := buildIntervalsDemo312() + tt := []struct { + name string + intvls interval.Intervals + expectedOverlaps []interval.Interval + }{ + {name: "demo001", intvls: demo001.Intervals, expectedOverlaps: demo001.ExpectedOverlaps}, + {name: "demo002", intvls: demo002.Intervals, expectedOverlaps: demo002.ExpectedOverlaps}, + {name: "demo003", intvls: demo003.Intervals, expectedOverlaps: demo003.ExpectedOverlaps}, + {name: "demo004", intvls: demo004.Intervals, expectedOverlaps: demo004.ExpectedOverlaps}, + {name: "demo005", intvls: demo005.Intervals, expectedOverlaps: demo005.ExpectedOverlaps}, + {name: "demo006", intvls: demo006.Intervals, expectedOverlaps: demo006.ExpectedOverlaps}, + {name: "demo007", intvls: demo007.Intervals, expectedOverlaps: demo007.ExpectedOverlaps}, + {name: "demo008", intvls: demo008.Intervals, expectedOverlaps: demo008.ExpectedOverlaps}, + {name: "demo009", intvls: demo009.Intervals, expectedOverlaps: demo009.ExpectedOverlaps}, + {name: "demo010", intvls: demo010.Intervals, expectedOverlaps: demo010.ExpectedOverlaps}, + {name: "demo011", intvls: demo011.Intervals, expectedOverlaps: demo011.ExpectedOverlaps}, + {name: "demo012", intvls: demo012.Intervals, expectedOverlaps: demo012.ExpectedOverlaps}, + + {name: "demo101", intvls: demo101.Intervals, expectedOverlaps: demo101.ExpectedOverlaps}, + {name: "demo102", intvls: demo102.Intervals, expectedOverlaps: demo102.ExpectedOverlaps}, + {name: "demo103", intvls: demo103.Intervals, expectedOverlaps: demo103.ExpectedOverlaps}, + {name: "demo104", intvls: demo104.Intervals, expectedOverlaps: demo104.ExpectedOverlaps}, + {name: "demo105", intvls: demo105.Intervals, expectedOverlaps: demo105.ExpectedOverlaps}, + {name: "demo106", intvls: demo106.Intervals, expectedOverlaps: demo106.ExpectedOverlaps}, + {name: "demo107", intvls: demo107.Intervals, expectedOverlaps: demo107.ExpectedOverlaps}, + {name: "demo108", intvls: demo108.Intervals, expectedOverlaps: demo108.ExpectedOverlaps}, + {name: "demo109", intvls: demo109.Intervals, expectedOverlaps: demo109.ExpectedOverlaps}, + {name: "demo110", intvls: demo110.Intervals, expectedOverlaps: demo110.ExpectedOverlaps}, + {name: "demo111", intvls: demo111.Intervals, expectedOverlaps: demo111.ExpectedOverlaps}, + {name: "demo112", intvls: demo112.Intervals, expectedOverlaps: demo112.ExpectedOverlaps}, + + {name: "demo201", intvls: demo201.Intervals, expectedOverlaps: demo201.ExpectedOverlaps}, + {name: "demo202", intvls: demo202.Intervals, expectedOverlaps: demo202.ExpectedOverlaps}, + {name: "demo203", intvls: demo203.Intervals, expectedOverlaps: demo203.ExpectedOverlaps}, + {name: "demo204", intvls: demo204.Intervals, expectedOverlaps: demo204.ExpectedOverlaps}, + {name: "demo205", intvls: demo205.Intervals, expectedOverlaps: demo205.ExpectedOverlaps}, + {name: "demo206", intvls: demo206.Intervals, expectedOverlaps: demo206.ExpectedOverlaps}, + {name: "demo207", intvls: demo207.Intervals, expectedOverlaps: demo207.ExpectedOverlaps}, + {name: "demo208", intvls: demo208.Intervals, expectedOverlaps: demo208.ExpectedOverlaps}, + {name: "demo209", intvls: demo209.Intervals, expectedOverlaps: demo209.ExpectedOverlaps}, + {name: "demo210", intvls: demo210.Intervals, expectedOverlaps: demo210.ExpectedOverlaps}, + {name: "demo211", intvls: demo211.Intervals, expectedOverlaps: demo211.ExpectedOverlaps}, + {name: "demo212", intvls: demo212.Intervals, expectedOverlaps: demo212.ExpectedOverlaps}, + + {name: "demo301", intvls: demo301.Intervals, expectedOverlaps: demo301.ExpectedOverlaps}, + {name: "demo302", intvls: demo302.Intervals, expectedOverlaps: demo302.ExpectedOverlaps}, + {name: "demo303", intvls: demo303.Intervals, expectedOverlaps: demo303.ExpectedOverlaps}, + {name: "demo304", intvls: demo304.Intervals, expectedOverlaps: demo304.ExpectedOverlaps}, + {name: "demo305", intvls: demo305.Intervals, expectedOverlaps: demo305.ExpectedOverlaps}, + {name: "demo306", intvls: demo306.Intervals, expectedOverlaps: demo306.ExpectedOverlaps}, + {name: "demo307", intvls: demo307.Intervals, expectedOverlaps: demo307.ExpectedOverlaps}, + {name: "demo308", intvls: demo308.Intervals, expectedOverlaps: demo308.ExpectedOverlaps}, + {name: "demo309", intvls: demo309.Intervals, expectedOverlaps: demo309.ExpectedOverlaps}, + {name: "demo310", intvls: demo310.Intervals, expectedOverlaps: demo310.ExpectedOverlaps}, + {name: "demo311", intvls: demo311.Intervals, expectedOverlaps: demo311.ExpectedOverlaps}, + {name: "demo312", intvls: demo312.Intervals, expectedOverlaps: demo312.ExpectedOverlaps}, + } + + for _, tc := range tt { + t.Run(tc.name, func(t *testing.T) { + // if tc.name == "demo105" { + // t.Log("break here") + // } + overlaps := tc.intvls.Overlapped() + unexpectedLength := false + if len(overlaps) != len(tc.expectedOverlaps) { + t.Errorf("unexpected overlaps length: expected %d; got %d", len(tc.expectedOverlaps), len(overlaps)) + unexpectedLength = true + } + if !unexpectedLength { + for i, overlap := range overlaps { + if overlap.Low != tc.expectedOverlaps[i].Low || overlap.High != tc.expectedOverlaps[i].High { + t.Errorf("unexpected overlap[%d]: expected %v; got %v", i, tc.expectedOverlaps[i], overlap) + } + } + } + }) + } +}