Combining (Aggregating/Adding/Subtracting) ranges in Golang - test coverage

ranges_test.go

package ranges_test
// tests for https://gist.github.com/petrkotek/317dbcf6a73387682bc8d899b09c36df

import (
	"bitbucket.org/kayakrent/booking-api/lib/ranges"

	"math"
	"reflect"
	"testing"
)

func TestStandardAggregator_Aggregate(t *testing.T) {
	aggregator := ranges.StandardAggregator{}

	table := []struct {
		name           string
		input          []*ranges.Range
		expectedOutput []*ranges.Range
		expectedError  error
	}{
		{
			name:           "empty range",
			input:          []*ranges.Range{},
			expectedOutput: []*ranges.Range{},
			expectedError:  nil,
		},
		{
			name: "single range 1",
			input: []*ranges.Range{
				{From: 0, To: 10, Value: 1},
			},
			expectedOutput: []*ranges.Range{
				{From: 0, To: 10, Value: 1},
			},
			expectedError: nil,
		},
		{
			name: "single range 2",
			input: []*ranges.Range{
				{From: -10, To: -5, Value: -5},
			},
			expectedOutput: []*ranges.Range{
				{From: -10, To: -5, Value: -5},
			},
			expectedError: nil,
		},
		{
			name: "single range 3",
			input: []*ranges.Range{
				{From: math.MinInt64, To: math.MaxInt64, Value: 1},
			},
			expectedOutput: []*ranges.Range{
				{From: math.MinInt64, To: math.MaxInt64, Value: 1},
			},
			expectedError: nil,
		},
		{
			name: "two unconnected ranges",
			input: []*ranges.Range{
				{From: 0, To: 10, Value: 1},
				{From: 20, To: 30, Value: 2},
			},
			expectedOutput: []*ranges.Range{
				{From: 0, To: 10, Value: 1},
				{From: 20, To: 30, Value: 2},
			},
			expectedError: nil,
		},
		{
			name: "two overlapping ranges 1 (right)",
			input: []*ranges.Range{
				{From: 0, To: 20, Value: 1},
				{From: 10, To: 30, Value: 2},
			},
			expectedOutput: []*ranges.Range{
				{From: 0, To: 10, Value: 1},
				{From: 10, To: 20, Value: 3},
				{From: 20, To: 30, Value: 2},
			},
			expectedError: nil,
		},
		{
			name: "two overlapping ranges 2 (middle)",
			input: []*ranges.Range{
				{From: 0, To: 20, Value: 1},
				{From: 5, To: 15, Value: 2},
			},
			expectedOutput: []*ranges.Range{
				{From: 0, To: 5, Value: 1},
				{From: 5, To: 15, Value: 3},
				{From: 15, To: 20, Value: 1},
			},
			expectedError: nil,
		},
		{
			name: "two overlapping ranges 3 (left)",
			input: []*ranges.Range{
				{From: 0, To: 20, Value: 1},
				{From: -10, To: 10, Value: 2},
			},
			expectedOutput: []*ranges.Range{
				{From: -10, To: 0, Value: 2},
				{From: 0, To: 10, Value: 3},
				{From: 10, To: 20, Value: 1},
			},
			expectedError: nil,
		},
		{
			name: "two overlapping ranges 4 (shared from)",
			input: []*ranges.Range{
				{From: 0, To: 20, Value: 1},
				{From: 0, To: 10, Value: 2},
			},
			expectedOutput: []*ranges.Range{
				{From: 0, To: 10, Value: 3},
				{From: 10, To: 20, Value: 1},
			},
			expectedError: nil,
		},
		{
			name: "two overlapping ranges 2 (same)",
			input: []*ranges.Range{
				{From: 0, To: 10, Value: 1},
				{From: 0, To: 10, Value: 2},
			},
			expectedOutput: []*ranges.Range{
				{From: 0, To: 10, Value: 3},
			},
			expectedError: nil,
		},
		{
			name: "combining neighbor ranges 1",
			input: []*ranges.Range{
				{From: 10, To: 20, Value: 1},
				{From: 20, To: 30, Value: 1},
			},
			expectedOutput: []*ranges.Range{
				{From: 10, To: 30, Value: 1},
			},
			expectedError: nil,
		},
	}

	for _, row := range table {
		output, err := aggregator.Aggregate(row.input)

		if err != row.expectedError {
			t.Errorf("Aggregate(%s) returned unexpected error", row.name)
		}

		if !reflect.DeepEqual(row.expectedOutput, output) {
			t.Errorf("Aggregate(%s) returned unexpected output", row.name)
		}
	}
}