From f9d1375f1e1333b938d3480ba362c3b36500bc9a Mon Sep 17 00:00:00 2001 From: Daniel Gil Date: Thu, 31 May 2018 09:24:37 +0200 Subject: [PATCH] Added merge and find testcases. --- demo_test.go | 364 ++++++++++++++++++++++++++++++++++++++++------- find_test.go | 90 ++++++++++++ interval_test.go | 107 -------------- merge_test.go | 143 +++++++++++++++++++ report_test.go | 55 +++++++ 5 files changed, 601 insertions(+), 158 deletions(-) create mode 100644 find_test.go delete mode 100644 interval_test.go create mode 100644 merge_test.go create mode 100644 report_test.go diff --git a/demo_test.go b/demo_test.go index b2c4281..e5d6022 100644 --- a/demo_test.go +++ b/demo_test.go @@ -7,9 +7,12 @@ import ( ) type demo struct { - Intervals interval.Intervals - ExpectedGaps []interval.Interval - ExpectedOverlaps []interval.Interval + 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} } diff --git a/find_test.go b/find_test.go new file mode 100644 index 0000000..6b8683e --- /dev/null +++ b/find_test.go @@ -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) + } + } + } + }) + } +} diff --git a/interval_test.go b/interval_test.go deleted file mode 100644 index a5410d9..0000000 --- a/interval_test.go +++ /dev/null @@ -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) -} diff --git a/merge_test.go b/merge_test.go new file mode 100644 index 0000000..7a01ca4 --- /dev/null +++ b/merge_test.go @@ -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) + } + } + } + }) + } +} diff --git a/report_test.go b/report_test.go new file mode 100644 index 0000000..0471c83 --- /dev/null +++ b/report_test.go @@ -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()) + }) + } +}