stale/intervals
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added merge and find testcases.

Browse Source
This commit is contained in:
Daniel Gil 2018-05-31 09:24:37 +02:00
parent 98c89357f5
commit f9d1375f1e
5 changed files with 601 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

358
demo_test.go
View File

@ -10,6 +10,9 @@ type demo struct {
Intervals interval.Intervals
ExpectedGaps []interval.Interval
ExpectedOverlaps []interval.Interval
ExpectedMerges []interval.Interval
ExpectedFindMatches []interval.Interval
ValueToFind int
}
///////////////////////////////////////////////////////////
@ -31,7 +34,11 @@ func buildIntervalsDemo001() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval at the beginning (low/high inclusive)
@ -54,7 +61,12 @@ func buildIntervalsDemo002() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: minLow, High: 4})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval at the end (low/high inclusive)
@ -77,7 +89,12 @@ func buildIntervalsDemo003() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 8, High: maxHigh})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval in the middle (low/high inclusive)
@ -101,7 +118,12 @@ func buildIntervalsDemo004() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 5, High: 8})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle, one inside the other (low/high inclusive)
@ -129,7 +151,12 @@ func buildIntervalsDemo005() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
overlaps = append(overlaps, interval.Interval{Low: 4, High: 6})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 8})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle, not overlapping (low/high inclusive)
@ -157,7 +184,13 @@ func buildIntervalsDemo006() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 4})
merges = append(merges, interval.Interval{Low: 6, High: 8})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle, consecutives (not overlapping) (low/high inclusive)
@ -184,7 +217,12 @@ func buildIntervalsDemo007() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 6})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle, overlapping by 1 position (low/high inclusive)
@ -212,7 +250,12 @@ func buildIntervalsDemo008() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
overlaps = append(overlaps, interval.Interval{Low: 6, High: 6})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle, overlapping by 3 positions (low/high inclusive)
@ -240,7 +283,12 @@ func buildIntervalsDemo009() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
overlaps = append(overlaps, interval.Interval{Low: 4, High: 6})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 8})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// three intervals (leading, middle and trailing), not overlapping (low/high inclusive)
@ -270,7 +318,14 @@ func buildIntervalsDemo010() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: minLow, High: 2})
merges = append(merges, interval.Interval{Low: 4, High: 4})
merges = append(merges, interval.Interval{Low: 8, High: maxHigh})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// three intervals (in the middle), overlapping (low/high inclusive)
@ -302,7 +357,12 @@ func buildIntervalsDemo011() demo {
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}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// complex case with a lot of intervals and overlapping (low/high inclusive)
@ -360,7 +420,15 @@ func buildIntervalsDemo012() demo {
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}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: minLow, High: 7})
merges = append(merges, interval.Interval{Low: 10, High: 12})
merges = append(merges, interval.Interval{Low: 18, High: 32})
merges = append(merges, interval.Interval{Low: 35, High: 35})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
///////////////////////////////////////////////////////////
@ -382,7 +450,11 @@ func buildIntervalsDemo101() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval at the beginning (low/high exclusive)
@ -406,7 +478,12 @@ func buildIntervalsDemo102() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 1, High: 3})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval at the end (low/high exclusive)
@ -430,7 +507,12 @@ func buildIntervalsDemo103() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 9, High: 9})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval in the middle (low/high exclusive)
@ -454,7 +536,12 @@ func buildIntervalsDemo104() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 6, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle, one inside the other (low/high exclusive)
@ -482,7 +569,12 @@ func buildIntervalsDemo105() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
overlaps = append(overlaps, interval.Interval{Low: 5, High: 5})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle (low/high exclusive)
@ -510,7 +602,13 @@ func buildIntervalsDemo106() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 3})
merges = append(merges, interval.Interval{Low: 7, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle, consecutives (low/high exclusive)
@ -538,7 +636,13 @@ func buildIntervalsDemo107() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 3})
merges = append(merges, interval.Interval{Low: 5, High: 5})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle (low/high exclusive)
@ -565,7 +669,12 @@ func buildIntervalsDemo108() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 5})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle (low/high exclusive)
@ -593,7 +702,12 @@ func buildIntervalsDemo109() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
overlaps = append(overlaps, interval.Interval{Low: 5, High: 5})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// three intervals (leading, middle and trailing) (low/high exclusive)
@ -624,7 +738,13 @@ func buildIntervalsDemo110() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 1, High: 1})
merges = append(merges, interval.Interval{Low: 9, High: 9})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// three intervals (in the middle) (low/high exclusive)
@ -654,7 +774,12 @@ func buildIntervalsDemo111() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 6})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// complex case with a lot of intervals (low/high exclusive)
@ -710,7 +835,16 @@ func buildIntervalsDemo112() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
overlaps = append(overlaps, interval.Interval{Low: 26, High: 27})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 6})
merges = append(merges, interval.Interval{Low: 11, High: 11})
merges = append(merges, interval.Interval{Low: 19, High: 19})
merges = append(merges, interval.Interval{Low: 21, High: 29})
merges = append(merges, interval.Interval{Low: 31, High: 31})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
/////////////////////////////////////////////////////////////////
@ -732,7 +866,11 @@ func buildIntervalsDemo201() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval at the beginning (low inclusive and high exclusive)
@ -755,7 +893,12 @@ func buildIntervalsDemo202() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: minLow, High: 3})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval at the end (low inclusive and high exclusive)
@ -779,7 +922,12 @@ func buildIntervalsDemo203() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 8, High: maxHigh - 1})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval in the middle (low inclusive and high exclusive)
@ -803,7 +951,12 @@ func buildIntervalsDemo204() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 5, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle, one inside the other (low inclusive and high exclusive)
@ -831,7 +984,12 @@ func buildIntervalsDemo205() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
overlaps = append(overlaps, interval.Interval{Low: 4, High: 5})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle (low inclusive and high exclusive)
@ -859,7 +1017,13 @@ func buildIntervalsDemo206() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 3})
merges = append(merges, interval.Interval{Low: 6, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle, consecutives (low inclusive and high exclusive)
@ -886,7 +1050,12 @@ func buildIntervalsDemo207() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 5})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle (low inclusive and high exclusive)
@ -913,7 +1082,12 @@ func buildIntervalsDemo208() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 6})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle (low inclusive and high exclusive)
@ -941,7 +1115,12 @@ func buildIntervalsDemo209() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
overlaps = append(overlaps, interval.Interval{Low: 4, High: 5})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// three intervals (leading, middle and trailing) (low inclusive and high exclusive)
@ -971,7 +1150,13 @@ func buildIntervalsDemo210() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: minLow, High: 1})
merges = append(merges, interval.Interval{Low: 8, High: 9})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// three intervals (in the middle) (low inclusive and high exclusive)
@ -1003,7 +1188,12 @@ func buildIntervalsDemo211() demo {
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}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 2, High: 6})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// complex case with a lot of intervals (low inclusive and high exclusive)
@ -1059,7 +1249,15 @@ func buildIntervalsDemo212() demo {
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}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: minLow, High: minLow})
merges = append(merges, interval.Interval{Low: 2, High: 6})
merges = append(merges, interval.Interval{Low: 10, High: 11})
merges = append(merges, interval.Interval{Low: 18, High: 31})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
/////////////////////////////////////////////////////////////////
@ -1081,7 +1279,11 @@ func buildIntervalsDemo301() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval at the beginning (low exclusive and high inclusive)
@ -1105,7 +1307,12 @@ func buildIntervalsDemo302() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 1, High: 4})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval at the end (low exclusive and high inclusive)
@ -1128,7 +1335,12 @@ func buildIntervalsDemo303() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 9, High: maxHigh})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// one interval in the middle (low exclusive and high inclusive)
@ -1152,7 +1364,12 @@ func buildIntervalsDemo304() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 6, High: 8})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle, one inside the other (low exclusive and high inclusive)
@ -1180,7 +1397,12 @@ func buildIntervalsDemo305() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
overlaps = append(overlaps, interval.Interval{Low: 5, High: 6})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 8})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle (low exclusive and high inclusive)
@ -1208,7 +1430,13 @@ func buildIntervalsDemo306() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 4})
merges = append(merges, interval.Interval{Low: 7, High: 8})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle, consecutives (low exclusive and high inclusive)
@ -1235,7 +1463,12 @@ func buildIntervalsDemo307() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 6})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle (low exclusive and high inclusive)
@ -1262,7 +1495,12 @@ func buildIntervalsDemo308() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// two intervals in the middle (low exclusive and high inclusive)
@ -1290,7 +1528,12 @@ func buildIntervalsDemo309() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
overlaps = append(overlaps, interval.Interval{Low: 5, High: 6})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 8})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// three intervals (leading, middle and trailing) (low exclusive and high inclusive)
@ -1320,7 +1563,13 @@ func buildIntervalsDemo310() demo {
// calculate expected overlaps
overlaps := []interval.Interval{}
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 1, High: 2})
merges = append(merges, interval.Interval{Low: 9, High: maxHigh})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// three intervals (in the middle) (low exclusive and high inclusive)
@ -1352,7 +1601,12 @@ func buildIntervalsDemo311() demo {
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}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 3, High: 7})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}
// complex case with a lot of intervals (low exclusive and high inclusive)
@ -1409,5 +1663,13 @@ func buildIntervalsDemo312() demo {
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}
// calculate expected merges
merges := []interval.Interval{}
merges = append(merges, interval.Interval{Low: 1, High: 1})
merges = append(merges, interval.Interval{Low: 3, High: 7})
merges = append(merges, interval.Interval{Low: 11, High: 12})
merges = append(merges, interval.Interval{Low: 19, High: 32})
return demo{Intervals: itvls, ExpectedGaps: gaps, ExpectedOverlaps: overlaps, ExpectedMerges: merges}
}

90
find_test.go Normal file
View File

@ -0,0 +1,90 @@
package interval_test
import (
"fmt"
"testing"
"bitbucket.org/differenttravel/interval"
)
func initIntervalsForDemo001() interval.Intervals {
// initialize Intervals
minLow := 0
maxHigh := 100
lowInclusive := true
highInclusive := true
itvls := interval.NewIntervals(minLow, maxHigh, lowInclusive, highInclusive)
// add new intervals
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: 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: 30, High: 32}); err != nil {
fmt.Printf("invalid interval discarded: %v\n", err)
}
return itvls
}
// matches for value=2
func buildFindDemo001() demo {
itvls := initIntervalsForDemo001()
matches := []interval.Interval{}
matches = append(matches, interval.Interval{Low: 2, High: 4})
return demo{Intervals: itvls, ExpectedFindMatches: matches, ValueToFind: 2}
}
// matches for value=4
func buildFindDemo002() demo {
itvls := initIntervalsForDemo001()
matches := []interval.Interval{}
matches = append(matches, interval.Interval{Low: 2, High: 4})
matches = append(matches, interval.Interval{Low: 3, High: 6})
return demo{Intervals: itvls, ExpectedFindMatches: matches, ValueToFind: 4}
}
func TestFindIntervalsForValue(t *testing.T) {
demo001 := buildFindDemo001()
demo002 := buildFindDemo002()
tt := []struct {
name string
valueToFind int
intvls interval.Intervals
expectedMatches []interval.Interval
}{
{name: "demo001", valueToFind: demo001.ValueToFind, intvls: demo001.Intervals, expectedMatches: demo001.ExpectedFindMatches},
{name: "demo002", valueToFind: demo002.ValueToFind, intvls: demo002.Intervals, expectedMatches: demo002.ExpectedFindMatches},
}
for _, tc := range tt {
t.Run(tc.name, func(t *testing.T) {
matches := tc.intvls.FindIntervalsForValue(tc.valueToFind)
unexpectedLength := false
if len(matches) != len(tc.expectedMatches) {
t.Errorf("unexpected gaps length: expected %d; got %d", len(tc.expectedMatches), len(matches))
unexpectedLength = true
}
if !unexpectedLength {
for i, m := range matches {
if m.Low != tc.expectedMatches[i].Low || m.High != tc.expectedMatches[i].High {
t.Errorf("unexpected gap[%d]: expected %v; got %v", i, tc.expectedMatches[i], m)
}
}
}
})
}
}

107
interval_test.go
View File

@ -1,107 +0,0 @@
package interval_test
import (
"fmt"
"testing"
"bitbucket.org/differenttravel/interval"
)
func TestInsert(t *testing.T) {
itvls := interval.NewIntervals(0, 100, true, true)
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
itvls interval.Intervals
}{
{name: "normal case", itvls: itvls},
}
for _, tc := range tt {
t.Run(tc.name, func(t *testing.T) {
t.Log(tc.itvls.Report())
})
}
}
func TestFindIntervalsForValue(t *testing.T) {
itvls := interval.NewIntervals(0, 100, true, true)
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)
matches1Txt := fmt.Sprintf("\nFind(value=%d)={", valueToFind1)
for _, m := range matches1 {
matches1Txt += fmt.Sprintf("%v,", m)
}
matches1Txt += "}"
t.Logf(matches1Txt)
valueToFind2 := 4
matches2 := itvls.FindIntervalsForValue(4)
matches2Txt := fmt.Sprintf("\nFind(value=%d)={", valueToFind2)
for _, m := range matches2 {
matches2Txt += fmt.Sprintf("%v,", m)
}
matches2Txt += "}"
t.Logf(matches2Txt)
}

143
merge_test.go Normal file
View File

@ -0,0 +1,143 @@
package interval_test
import (
"testing"
"bitbucket.org/differenttravel/interval"
)
func TestMerge(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
expectedMerges []interval.Interval
}{
{name: "demo001", intvls: demo001.Intervals, expectedMerges: demo001.ExpectedMerges},
{name: "demo002", intvls: demo002.Intervals, expectedMerges: demo002.ExpectedMerges},
{name: "demo003", intvls: demo003.Intervals, expectedMerges: demo003.ExpectedMerges},
{name: "demo004", intvls: demo004.Intervals, expectedMerges: demo004.ExpectedMerges},
{name: "demo005", intvls: demo005.Intervals, expectedMerges: demo005.ExpectedMerges},
{name: "demo006", intvls: demo006.Intervals, expectedMerges: demo006.ExpectedMerges},
{name: "demo007", intvls: demo007.Intervals, expectedMerges: demo007.ExpectedMerges},
{name: "demo008", intvls: demo008.Intervals, expectedMerges: demo008.ExpectedMerges},
{name: "demo009", intvls: demo009.Intervals, expectedMerges: demo009.ExpectedMerges},
{name: "demo010", intvls: demo010.Intervals, expectedMerges: demo010.ExpectedMerges},
{name: "demo011", intvls: demo011.Intervals, expectedMerges: demo011.ExpectedMerges},
{name: "demo012", intvls: demo012.Intervals, expectedMerges: demo012.ExpectedMerges},
{name: "demo101", intvls: demo101.Intervals, expectedMerges: demo101.ExpectedMerges},
{name: "demo102", intvls: demo102.Intervals, expectedMerges: demo102.ExpectedMerges},
{name: "demo103", intvls: demo103.Intervals, expectedMerges: demo103.ExpectedMerges},
{name: "demo104", intvls: demo104.Intervals, expectedMerges: demo104.ExpectedMerges},
{name: "demo105", intvls: demo105.Intervals, expectedMerges: demo105.ExpectedMerges},
{name: "demo106", intvls: demo106.Intervals, expectedMerges: demo106.ExpectedMerges},
{name: "demo107", intvls: demo107.Intervals, expectedMerges: demo107.ExpectedMerges},
{name: "demo108", intvls: demo108.Intervals, expectedMerges: demo108.ExpectedMerges},
{name: "demo109", intvls: demo109.Intervals, expectedMerges: demo109.ExpectedMerges},
{name: "demo110", intvls: demo110.Intervals, expectedMerges: demo110.ExpectedMerges},
{name: "demo111", intvls: demo111.Intervals, expectedMerges: demo111.ExpectedMerges},
{name: "demo112", intvls: demo112.Intervals, expectedMerges: demo112.ExpectedMerges},
{name: "demo201", intvls: demo201.Intervals, expectedMerges: demo201.ExpectedMerges},
{name: "demo202", intvls: demo202.Intervals, expectedMerges: demo202.ExpectedMerges},
{name: "demo203", intvls: demo203.Intervals, expectedMerges: demo203.ExpectedMerges},
{name: "demo204", intvls: demo204.Intervals, expectedMerges: demo204.ExpectedMerges},
{name: "demo205", intvls: demo205.Intervals, expectedMerges: demo205.ExpectedMerges},
{name: "demo206", intvls: demo206.Intervals, expectedMerges: demo206.ExpectedMerges},
{name: "demo207", intvls: demo207.Intervals, expectedMerges: demo207.ExpectedMerges},
{name: "demo208", intvls: demo208.Intervals, expectedMerges: demo208.ExpectedMerges},
{name: "demo209", intvls: demo209.Intervals, expectedMerges: demo209.ExpectedMerges},
{name: "demo210", intvls: demo210.Intervals, expectedMerges: demo210.ExpectedMerges},
{name: "demo211", intvls: demo211.Intervals, expectedMerges: demo211.ExpectedMerges},
{name: "demo212", intvls: demo212.Intervals, expectedMerges: demo212.ExpectedMerges},
{name: "demo301", intvls: demo301.Intervals, expectedMerges: demo301.ExpectedMerges},
{name: "demo302", intvls: demo302.Intervals, expectedMerges: demo302.ExpectedMerges},
{name: "demo303", intvls: demo303.Intervals, expectedMerges: demo303.ExpectedMerges},
{name: "demo304", intvls: demo304.Intervals, expectedMerges: demo304.ExpectedMerges},
{name: "demo305", intvls: demo305.Intervals, expectedMerges: demo305.ExpectedMerges},
{name: "demo306", intvls: demo306.Intervals, expectedMerges: demo306.ExpectedMerges},
{name: "demo307", intvls: demo307.Intervals, expectedMerges: demo307.ExpectedMerges},
{name: "demo308", intvls: demo308.Intervals, expectedMerges: demo308.ExpectedMerges},
{name: "demo309", intvls: demo309.Intervals, expectedMerges: demo309.ExpectedMerges},
{name: "demo310", intvls: demo310.Intervals, expectedMerges: demo310.ExpectedMerges},
{name: "demo311", intvls: demo311.Intervals, expectedMerges: demo311.ExpectedMerges},
{name: "demo312", intvls: demo312.Intervals, expectedMerges: demo312.ExpectedMerges},
}
for _, tc := range tt {
t.Run(tc.name, func(t *testing.T) {
// if tc.name == "demo105" {
// t.Log("break here")
// }
merges := tc.intvls.Merge()
unexpectedLength := false
if len(merges) != len(tc.expectedMerges) {
t.Errorf("unexpected merges length: expected %d; got %d", len(tc.expectedMerges), len(merges))
unexpectedLength = true
}
if !unexpectedLength {
for i, merge := range merges {
if merge.Low != tc.expectedMerges[i].Low || merge.High != tc.expectedMerges[i].High {
t.Errorf("unexpected merge[%d]: expected %v; got %v", i, tc.expectedMerges[i], merge)
}
}
}
})
}
}

55
report_test.go Normal file
View File

@ -0,0 +1,55 @@
package interval_test
import (
"fmt"
"testing"
"bitbucket.org/differenttravel/interval"
)
func TestReport(t *testing.T) {
itvls := interval.NewIntervals(0, 100, true, true)
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
itvls interval.Intervals
}{
{name: "normal case", itvls: itvls},
}
for _, tc := range tt {
t.Run(tc.name, func(t *testing.T) {
t.Log(tc.itvls.Report())
})
}
}