Merge pull request #1118 from travisturner/roaring-test-templates-0.8

Roaring test templates 0.8 (plus container_type and lint changes)

roaring/internal_test.go

@@ -1,57 +0,0 @@
-// Copyright 2017 Pilosa Corp.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package roaring
-
-import (
-	"reflect"
-	"testing"
-)
-
-// Ensure iterator returns values from a bitmap.
-func TestBitmapIterator(t *testing.T) {
-	for i, tt := range []struct {
-		bitmap []uint64
-		values []uint16
-	}{
-		// Empty
-		{
-			bitmap: []uint64{6}, // 0110
-			values: []uint16{1, 2},
-		},
-
-		// Single uint64 bitmap
-		{
-			bitmap: []uint64{6}, // 0110
-			values: []uint16{1, 2},
-		},
-
-		// Multi uint64 bitmap
-		{
-			bitmap: []uint64{1 << 63, 1, 0, 1, 3 << 62},
-			values: []uint16{63, 64, 192, 318, 319},
-		},
-	} {
-		itr := newBitmapIterator(tt.bitmap)
-
-		var a []uint16
-		for v, eof := itr.next(); !eof; v, eof = itr.next() {
-			a = append(a, v)
-		}
-
-		if !reflect.DeepEqual(a, tt.values) {
-			t.Errorf("%d. unexpected values: exp=%+v, got=%+v", i, a, tt.values)
-		}
-	}
-}

roaring/roaring_helpers_test.go

@@ -0,0 +1,295 @@
+// Copyright 2017 Pilosa Corp.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package roaring
+
+///////////////////////////////////////////////////////////////////////////
+
+var containerWidth uint64 = 65536
+
+////////////////// array
+func arrayEmpty() []uint16 {
+	return make([]uint16, 0)
+}
+
+func arrayFull() []uint16 {
+	array := make([]uint16, containerWidth)
+	for i := 0; i < int(containerWidth); i++ {
+		array[i] = uint16(i)
+	}
+	return array
+}
+
+func arrayFirstBitSet() []uint16 {
+	array := make([]uint16, 0)
+	array = append(array, uint16(0))
+	return array
+}
+
+func arrayLastBitSet() []uint16 {
+	array := make([]uint16, 0)
+	array = append(array, uint16(65535))
+	return array
+}
+
+func arrayFirstBitUnset() []uint16 {
+	array := make([]uint16, containerWidth-1)
+	for i := 1; i < int(containerWidth); i++ {
+		array[i-1] = uint16(i)
+	}
+	return array
+}
+
+func arrayLastBitUnset() []uint16 {
+	array := make([]uint16, containerWidth-1)
+	for i := 0; i < int(containerWidth)-1; i++ {
+		array[i] = uint16(i)
+	}
+	return array
+}
+
+func arrayInnerBitsSet() []uint16 {
+	array := make([]uint16, containerWidth-2)
+	for i := 1; i < int(containerWidth)-1; i++ {
+		array[i-1] = uint16(i)
+	}
+	return array
+}
+
+func arrayOuterBitsSet() []uint16 {
+	return []uint16{0, 65535}
+}
+
+func arrayOddBitsSet() []uint16 {
+	array := make([]uint16, containerWidth/2)
+	for i := 0; i < int(containerWidth/2); i++ {
+		array[i] = uint16(2*i + 1)
+	}
+	return array
+}
+
+func arrayEvenBitsSet() []uint16 {
+	array := make([]uint16, containerWidth/2)
+	for i := 0; i < int(containerWidth/2); i++ {
+		array[i] = uint16(2 * i)
+	}
+	return array
+}
+
+////////////////// bitmap
+func bitmapEmpty() []uint64 {
+	return make([]uint64, bitmapN)
+}
+
+func bitmapFull() []uint64 {
+	bitmap := make([]uint64, bitmapN)
+	for i := 0; i < bitmapN; i++ {
+		bitmap[i] = 0xFFFFFFFFFFFFFFFF
+	}
+	return bitmap
+}
+
+func bitmapFirstBitSet() []uint64 {
+	bitmap := make([]uint64, bitmapN)
+	bitmap[0] = 0x0000000000000001
+	return bitmap
+}
+
+func bitmapLastBitSet() []uint64 {
+	bitmap := make([]uint64, bitmapN)
+	bitmap[bitmapN-1] = 0x8000000000000000
+	return bitmap
+}
+
+func bitmapFirstBitUnset() []uint64 {
+	bitmap := bitmapFull()
+	bitmap[0] = 0xFFFFFFFFFFFFFFFE
+	return bitmap
+}
+
+func bitmapLastBitUnset() []uint64 {
+	bitmap := bitmapFull()
+	bitmap[bitmapN-1] = 0x7FFFFFFFFFFFFFFF
+	return bitmap
+}
+
+func bitmapInnerBitsSet() []uint64 {
+	bitmap := bitmapFull()
+	bitmap[0] = 0xFFFFFFFFFFFFFFFE
+	bitmap[bitmapN-1] = 0x7FFFFFFFFFFFFFFF
+	return bitmap
+}
+
+func bitmapOuterBitsSet() []uint64 {
+	bitmap := bitmapEmpty()
+	bitmap[0] = 0x0000000000000001
+	bitmap[bitmapN-1] = 0x8000000000000000
+	return bitmap
+}
+
+func bitmapOddBitsSet() []uint64 {
+	bitmap := make([]uint64, bitmapN)
+	for i := 0; i < bitmapN; i++ {
+		bitmap[i] = 0xAAAAAAAAAAAAAAAA
+	}
+	return bitmap
+}
+
+func bitmapEvenBitsSet() []uint64 {
+	bitmap := make([]uint64, bitmapN)
+	for i := 0; i < bitmapN; i++ {
+		bitmap[i] = 0x5555555555555555
+	}
+	return bitmap
+}
+
+////////////////// run
+func runEmpty() []interval16 {
+	return make([]interval16, 0)
+}
+
+func runFull() []interval16 {
+	run := make([]interval16, 0)
+	run = append(run, interval16{start: 0, last: 65535})
+	return run
+}
+
+func runFirstBitSet() []interval16 {
+	run := make([]interval16, 0)
+	run = append(run, interval16{start: 0, last: 0})
+	return run
+}
+
+func runLastBitSet() []interval16 {
+	run := make([]interval16, 0)
+	run = append(run, interval16{start: 65535, last: 65535})
+	return run
+}
+
+func runFirstBitUnset() []interval16 {
+	run := make([]interval16, 0)
+	run = append(run, interval16{start: 1, last: 65535})
+	return run
+}
+
+func runLastBitUnset() []interval16 {
+	run := make([]interval16, 0)
+	run = append(run, interval16{start: 0, last: 65534})
+	return run
+}
+
+func runInnerBitsSet() []interval16 {
+	run := make([]interval16, 0)
+	run = append(run, interval16{start: 1, last: 65534})
+	return run
+}
+
+func runOuterBitsSet() []interval16 {
+	run := make([]interval16, 0)
+	run = append(run, interval16{start: 0, last: 0})
+	run = append(run, interval16{start: 65535, last: 65535})
+	return run
+}
+
+func runOddBitsSet() []interval16 {
+	run := make([]interval16, containerWidth/2)
+	for i := 0; i < int(containerWidth/2); i++ {
+		run[i] = interval16{start: uint16(2*i + 1), last: uint16(2*i + 1)}
+	}
+	return run
+}
+
+func runEvenBitsSet() []interval16 {
+	run := make([]interval16, containerWidth/2)
+	for i := 0; i < int(containerWidth/2); i++ {
+		run[i] = interval16{start: uint16(2 * i), last: uint16(2 * i)}
+	}
+	return run
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+type testOp struct {
+	f   func(a, b *container) *container
+	x   string
+	y   string
+	exp string
+}
+
+func doContainer(containerType byte, data interface{}) *container {
+	c := &container{
+		containerType: containerType,
+	}
+
+	switch containerType {
+	case ContainerArray:
+		c.array = data.([]uint16)
+	case ContainerBitmap:
+		c.bitmap = data.([]uint64)
+	case ContainerRun:
+		c.runs = data.([]interval16)
+	}
+	c.n = c.count()
+
+	return c
+}
+
+func setupContainerTests() map[byte]map[string]*container {
+
+	cts := make(map[byte]map[string]*container)
+
+	// array containers
+	cts[ContainerArray] = map[string]*container{
+		"empty":         doContainer(ContainerArray, arrayEmpty()),
+		"full":          doContainer(ContainerArray, arrayFull()),
+		"firstBitSet":   doContainer(ContainerArray, arrayFirstBitSet()),
+		"lastBitSet":    doContainer(ContainerArray, arrayLastBitSet()),
+		"firstBitUnset": doContainer(ContainerArray, arrayFirstBitUnset()),
+		"lastBitUnset":  doContainer(ContainerArray, arrayLastBitUnset()),
+		"innerBitsSet":  doContainer(ContainerArray, arrayInnerBitsSet()),
+		"outerBitsSet":  doContainer(ContainerArray, arrayOuterBitsSet()),
+		"oddBitsSet":    doContainer(ContainerArray, arrayOddBitsSet()),
+		"evenBitsSet":   doContainer(ContainerArray, arrayEvenBitsSet()),
+	}
+
+	// bitmap containers
+	cts[ContainerBitmap] = map[string]*container{
+		"empty":         doContainer(ContainerBitmap, bitmapEmpty()),
+		"full":          doContainer(ContainerBitmap, bitmapFull()),
+		"firstBitSet":   doContainer(ContainerBitmap, bitmapFirstBitSet()),
+		"lastBitSet":    doContainer(ContainerBitmap, bitmapLastBitSet()),
+		"firstBitUnset": doContainer(ContainerBitmap, bitmapFirstBitUnset()),
+		"lastBitUnset":  doContainer(ContainerBitmap, bitmapLastBitUnset()),
+		"innerBitsSet":  doContainer(ContainerBitmap, bitmapInnerBitsSet()),
+		"outerBitsSet":  doContainer(ContainerBitmap, bitmapOuterBitsSet()),
+		"oddBitsSet":    doContainer(ContainerBitmap, bitmapOddBitsSet()),
+		"evenBitsSet":   doContainer(ContainerBitmap, bitmapEvenBitsSet()),
+	}
+
+	// run containers
+	cts[ContainerRun] = map[string]*container{
+		"empty":         doContainer(ContainerRun, runEmpty()),
+		"full":          doContainer(ContainerRun, runFull()),
+		"firstBitSet":   doContainer(ContainerRun, runFirstBitSet()),
+		"lastBitSet":    doContainer(ContainerRun, runLastBitSet()),
+		"firstBitUnset": doContainer(ContainerRun, runFirstBitUnset()),
+		"lastBitUnset":  doContainer(ContainerRun, runLastBitUnset()),
+		"innerBitsSet":  doContainer(ContainerRun, runInnerBitsSet()),
+		"outerBitsSet":  doContainer(ContainerRun, runOuterBitsSet()),
+		"oddBitsSet":    doContainer(ContainerRun, runOddBitsSet()),
+		"evenBitsSet":   doContainer(ContainerRun, runEvenBitsSet()),
+	}
+
+	return cts
+}