From 6529866b5759e294de1634f8963eb1d252d7decc Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Wed, 14 Feb 2018 13:30:07 -0600
Subject: [PATCH 1/4] templates for testing various container operations

---
 roaring/roaring_helpers_test.go  | 256 ++++++++++++++++++++
 roaring/roaring_internal_test.go | 390 +++++++++++++++++++++++++++++--
 2 files changed, 628 insertions(+), 18 deletions(-)
 create mode 100644 roaring/roaring_helpers_test.go

diff --git a/roaring/roaring_helpers_test.go b/roaring/roaring_helpers_test.go
new file mode 100644
index 000000000..de3dd002c
--- /dev/null
+++ b/roaring/roaring_helpers_test.go
@@ -0,0 +1,256 @@
+// 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 {
+	array := make([]uint16, 0)
+	array = append(array, uint16(0))
+	array = append(array, uint16(65535))
+	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 := make([]uint64, bitmapN)
+	bitmap[0] = 0xFFFFFFFFFFFFFFFE
+	for i := 1; i < bitmapN; i++ {
+		bitmap[i] = 0xFFFFFFFFFFFFFFFF
+	}
+	return bitmap
+}
+
+func bitmapLastBitUnset() []uint64 {
+	bitmap := make([]uint64, bitmapN)
+	for i := 0; i < bitmapN-1; i++ {
+		bitmap[i] = 0xFFFFFFFFFFFFFFFF
+	}
+	bitmap[bitmapN-1] = 0x7FFFFFFFFFFFFFFF
+	return bitmap
+}
+
+func bitmapInnerBitsSet() []uint64 {
+	bitmap := make([]uint64, bitmapN)
+	bitmap[0] = 0xFFFFFFFFFFFFFFFE
+	for i := 1; i < bitmapN-1; i++ {
+		bitmap[i] = 0xFFFFFFFFFFFFFFFF
+	}
+	bitmap[bitmapN-1] = 0x7FFFFFFFFFFFFFFF
+	return bitmap
+}
+
+func bitmapOuterBitsSet() []uint64 {
+	bitmap := make([]uint64, bitmapN)
+	bitmap[0] = 0x0000000000000001
+	for i := 1; i < bitmapN-1; i++ {
+		bitmap[i] = 0x0000000000000000
+	}
+	bitmap[bitmapN-1] = 0x8000000000000000
+	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
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+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()),
+	}
+
+	// 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()),
+	}
+
+	// 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()),
+	}
+
+	return cts
+}
diff --git a/roaring/roaring_internal_test.go b/roaring/roaring_internal_test.go
index 28b398c96..ce9ab217d 100644
--- a/roaring/roaring_internal_test.go
+++ b/roaring/roaring_internal_test.go
@@ -18,6 +18,8 @@ import (
 	"bytes"
 	"fmt"
 	"reflect"
+	"runtime"
+	"strings"
 	"testing"
 )
 
@@ -2660,24 +2662,6 @@ func bitmapLast() []uint64 {
 	return bitmap
 }
 
-func bitmapFull() []uint64 {
-	bitmap := make([]uint64, bitmapN)
-	for i := 0; i < bitmapN; i++ {
-		bitmap[i] = 0xFFFFFFFFFFFFFFFF
-	}
-	return bitmap
-}
-
-func bitmapEmpty() []uint64 {
-	bitmap := make([]uint64, bitmapN)
-	for i := 0; i < bitmapN; i++ {
-		bitmap[i] = 0
-	}
-	return bitmap
-}
-
-var containerWidth uint64 = 65536
-
 // rleCont returns a slice of numbers all in the range starting from
 // container_width*num, and ending at container_width*(num+1)-1. If left is
 // true, then the first 100 bits will be set, if mid is true, 100 bits in the
@@ -2759,3 +2743,373 @@ func bitmapVariousContainers() *Bitmap {
 	bm.Optimize()
 	return bm
 }
+
+///////////////////////////////////////////////////////////////////////////
+
+func getFunctionName(i interface{}) string {
+	x := runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
+	y := strings.Split(x, ".")
+	y = y[len(y)-1:]
+	return y[0]
+}
+
+func TestContainerCombinations(t *testing.T) {
+
+	cts := setupContainerTests()
+
+	containerTypes := []byte{ContainerArray, ContainerBitmap, ContainerRun}
+
+	// map used for a more descriptive print
+	cm := map[byte]string{
+		ContainerArray:  "array",
+		ContainerBitmap: "bitmap",
+		ContainerRun:    "run",
+	}
+
+	testOps := []testOp{
+		// intersect
+		{intersect, "empty", "empty", "empty"},
+		{intersect, "empty", "full", "empty"},
+		{intersect, "empty", "firstBitSet", "empty"},
+		{intersect, "empty", "lastBitSet", "empty"},
+		{intersect, "empty", "firstBitUnset", "empty"},
+		{intersect, "empty", "lastBitUnset", "empty"},
+		{intersect, "empty", "innerBitsSet", "empty"},
+		{intersect, "empty", "outerBitsSet", "empty"},
+		//
+		{intersect, "full", "empty", "empty"},
+		{intersect, "full", "full", "full"},
+		{intersect, "full", "firstBitSet", "firstBitSet"},
+		{intersect, "full", "lastBitSet", "lastBitSet"},
+		{intersect, "full", "firstBitUnset", "firstBitUnset"},
+		{intersect, "full", "lastBitUnset", "lastBitUnset"},
+		{intersect, "full", "innerBitsSet", "innerBitsSet"},
+		{intersect, "full", "outerBitsSet", "outerBitsSet"},
+		//
+		{intersect, "firstBitSet", "empty", "empty"},
+		{intersect, "firstBitSet", "full", "firstBitSet"},
+		{intersect, "firstBitSet", "firstBitSet", "firstBitSet"},
+		{intersect, "firstBitSet", "lastBitSet", "empty"},
+		{intersect, "firstBitSet", "firstBitUnset", "empty"},
+		{intersect, "firstBitSet", "lastBitUnset", "firstBitSet"},
+		{intersect, "firstBitSet", "innerBitsSet", "empty"},
+		{intersect, "firstBitSet", "outerBitsSet", "firstBitSet"},
+		//
+		{intersect, "lastBitSet", "empty", "empty"},
+		{intersect, "lastBitSet", "full", "lastBitSet"},
+		{intersect, "lastBitSet", "firstBitSet", "empty"},
+		{intersect, "lastBitSet", "lastBitSet", "lastBitSet"},
+		{intersect, "lastBitSet", "firstBitUnset", "lastBitSet"},
+		{intersect, "lastBitSet", "lastBitUnset", "empty"},
+		{intersect, "lastBitSet", "innerBitsSet", "empty"},
+		{intersect, "lastBitSet", "outerBitsSet", "lastBitSet"},
+		//
+		{intersect, "firstBitUnset", "empty", "empty"},
+		{intersect, "firstBitUnset", "full", "firstBitUnset"},
+		{intersect, "firstBitUnset", "firstBitSet", "empty"},
+		{intersect, "firstBitUnset", "lastBitSet", "lastBitSet"},
+		{intersect, "firstBitUnset", "firstBitUnset", "firstBitUnset"},
+		{intersect, "firstBitUnset", "lastBitUnset", "innerBitsSet"},
+		{intersect, "firstBitUnset", "innerBitsSet", "innerBitsSet"},
+		{intersect, "firstBitUnset", "outerBitsSet", "lastBitSet"},
+		//
+		{intersect, "lastBitUnset", "empty", "empty"},
+		{intersect, "lastBitUnset", "full", "lastBitUnset"},
+		{intersect, "lastBitUnset", "firstBitSet", "firstBitSet"},
+		{intersect, "lastBitUnset", "lastBitSet", "empty"},
+		{intersect, "lastBitUnset", "firstBitUnset", "innerBitsSet"},
+		{intersect, "lastBitUnset", "lastBitUnset", "lastBitUnset"},
+		{intersect, "lastBitUnset", "innerBitsSet", "innerBitsSet"},
+		{intersect, "lastBitUnset", "outerBitsSet", "firstBitSet"},
+		//
+		{intersect, "innerBitsSet", "empty", "empty"},
+		{intersect, "innerBitsSet", "full", "innerBitsSet"},
+		{intersect, "innerBitsSet", "firstBitSet", "empty"},
+		{intersect, "innerBitsSet", "lastBitSet", "empty"},
+		{intersect, "innerBitsSet", "firstBitUnset", "innerBitsSet"},
+		{intersect, "innerBitsSet", "lastBitUnset", "innerBitsSet"},
+		{intersect, "innerBitsSet", "innerBitsSet", "innerBitsSet"},
+		{intersect, "innerBitsSet", "outerBitsSet", "empty"},
+		//
+		{intersect, "outerBitsSet", "empty", "empty"},
+		{intersect, "outerBitsSet", "full", "outerBitsSet"},
+		{intersect, "outerBitsSet", "firstBitSet", "firstBitSet"},
+		{intersect, "outerBitsSet", "lastBitSet", "lastBitSet"},
+		{intersect, "outerBitsSet", "firstBitUnset", "lastBitSet"},
+		{intersect, "outerBitsSet", "lastBitUnset", "firstBitSet"},
+		{intersect, "outerBitsSet", "innerBitsSet", "empty"},
+		{intersect, "outerBitsSet", "outerBitsSet", "outerBitsSet"},
+
+		// union
+		{union, "empty", "empty", "empty"},
+		{union, "empty", "full", "full"},
+		{union, "empty", "firstBitSet", "firstBitSet"},
+		{union, "empty", "lastBitSet", "lastBitSet"},
+		{union, "empty", "firstBitUnset", "firstBitUnset"},
+		{union, "empty", "lastBitUnset", "lastBitUnset"},
+		{union, "empty", "innerBitsSet", "innerBitsSet"},
+		{union, "empty", "outerBitsSet", "outerBitsSet"},
+		//
+		{union, "full", "empty", "full"},
+		{union, "full", "full", "full"},
+		{union, "full", "firstBitSet", "full"},
+		{union, "full", "lastBitSet", "full"},
+		{union, "full", "firstBitUnset", "full"},
+		{union, "full", "lastBitUnset", "full"},
+		{union, "full", "innerBitsSet", "full"},
+		{union, "full", "outerBitsSet", "full"},
+		//
+		{union, "firstBitSet", "empty", "firstBitSet"},
+		{union, "firstBitSet", "full", "full"},
+		{union, "firstBitSet", "firstBitSet", "firstBitSet"},
+		{union, "firstBitSet", "lastBitSet", "outerBitsSet"},
+		{union, "firstBitSet", "firstBitUnset", "full"},
+		{union, "firstBitSet", "lastBitUnset", "lastBitUnset"},
+		{union, "firstBitSet", "innerBitsSet", "lastBitUnset"},
+		{union, "firstBitSet", "outerBitsSet", "outerBitsSet"},
+		//
+		{union, "lastBitSet", "empty", "lastBitSet"},
+		{union, "lastBitSet", "full", "full"},
+		{union, "lastBitSet", "firstBitSet", "outerBitsSet"},
+		{union, "lastBitSet", "lastBitSet", "lastBitSet"},
+		{union, "lastBitSet", "firstBitUnset", "firstBitUnset"},
+		{union, "lastBitSet", "lastBitUnset", "full"},
+		{union, "lastBitSet", "innerBitsSet", "firstBitUnset"},
+		{union, "lastBitSet", "outerBitsSet", "outerBitsSet"},
+		//
+		{union, "firstBitUnset", "empty", "firstBitUnset"},
+		{union, "firstBitUnset", "full", "full"},
+		{union, "firstBitUnset", "firstBitSet", "full"},
+		{union, "firstBitUnset", "lastBitSet", "firstBitUnset"},
+		{union, "firstBitUnset", "firstBitUnset", "firstBitUnset"},
+		{union, "firstBitUnset", "lastBitUnset", "full"},
+		{union, "firstBitUnset", "innerBitsSet", "firstBitUnset"},
+		{union, "firstBitUnset", "outerBitsSet", "full"},
+		//
+		{union, "lastBitUnset", "empty", "lastBitUnset"},
+		{union, "lastBitUnset", "full", "full"},
+		{union, "lastBitUnset", "firstBitSet", "lastBitUnset"},
+		{union, "lastBitUnset", "lastBitSet", "full"},
+		{union, "lastBitUnset", "firstBitUnset", "full"},
+		{union, "lastBitUnset", "lastBitUnset", "lastBitUnset"},
+		{union, "lastBitUnset", "innerBitsSet", "lastBitUnset"},
+		{union, "lastBitUnset", "outerBitsSet", "full"},
+		//
+		{union, "innerBitsSet", "empty", "innerBitsSet"},
+		{union, "innerBitsSet", "full", "full"},
+		{union, "innerBitsSet", "firstBitSet", "lastBitUnset"},
+		{union, "innerBitsSet", "lastBitSet", "firstBitUnset"},
+		{union, "innerBitsSet", "firstBitUnset", "firstBitUnset"},
+		{union, "innerBitsSet", "lastBitUnset", "lastBitUnset"},
+		{union, "innerBitsSet", "innerBitsSet", "innerBitsSet"},
+		{union, "innerBitsSet", "outerBitsSet", "full"},
+		//
+		{union, "outerBitsSet", "empty", "outerBitsSet"},
+		{union, "outerBitsSet", "full", "full"},
+		{union, "outerBitsSet", "firstBitSet", "outerBitsSet"},
+		{union, "outerBitsSet", "lastBitSet", "outerBitsSet"},
+		{union, "outerBitsSet", "firstBitUnset", "full"},
+		{union, "outerBitsSet", "lastBitUnset", "full"},
+		{union, "outerBitsSet", "innerBitsSet", "full"},
+		{union, "outerBitsSet", "outerBitsSet", "outerBitsSet"},
+
+		// difference
+		{difference, "empty", "empty", "empty"},
+		{difference, "empty", "full", "empty"},
+		{difference, "empty", "firstBitSet", "empty"},
+		{difference, "empty", "lastBitSet", "empty"},
+		{difference, "empty", "firstBitUnset", "empty"},
+		{difference, "empty", "lastBitUnset", "empty"},
+		{difference, "empty", "innerBitsSet", "empty"},
+		{difference, "empty", "outerBitsSet", "empty"},
+		//
+		{difference, "full", "empty", "full"},
+		{difference, "full", "full", "empty"},
+		{difference, "full", "firstBitSet", "firstBitUnset"},
+		{difference, "full", "lastBitSet", "lastBitUnset"},
+		{difference, "full", "firstBitUnset", "firstBitSet"},
+		{difference, "full", "lastBitUnset", "lastBitSet"},
+		{difference, "full", "innerBitsSet", "outerBitsSet"},
+		{difference, "full", "outerBitsSet", "innerBitsSet"},
+		//
+		{difference, "firstBitSet", "empty", "firstBitSet"},
+		{difference, "firstBitSet", "full", "empty"},
+		{difference, "firstBitSet", "firstBitSet", "empty"},
+		{difference, "firstBitSet", "lastBitSet", "firstBitSet"},
+		{difference, "firstBitSet", "firstBitUnset", "firstBitSet"},
+		{difference, "firstBitSet", "lastBitUnset", "empty"},
+		{difference, "firstBitSet", "innerBitsSet", "firstBitSet"},
+		{difference, "firstBitSet", "outerBitsSet", "empty"},
+		//
+		{difference, "lastBitSet", "empty", "lastBitSet"},
+		{difference, "lastBitSet", "full", "empty"},
+		{difference, "lastBitSet", "firstBitSet", "lastBitSet"},
+		{difference, "lastBitSet", "lastBitSet", "empty"},
+		{difference, "lastBitSet", "firstBitUnset", "empty"},
+		{difference, "lastBitSet", "lastBitUnset", "lastBitSet"},
+		{difference, "lastBitSet", "innerBitsSet", "lastBitSet"},
+		{difference, "lastBitSet", "outerBitsSet", "empty"},
+		//
+		{difference, "firstBitUnset", "empty", "firstBitUnset"},
+		{difference, "firstBitUnset", "full", "empty"},
+		{difference, "firstBitUnset", "firstBitSet", "firstBitUnset"},
+		{difference, "firstBitUnset", "lastBitSet", "innerBitsSet"},
+		{difference, "firstBitUnset", "firstBitUnset", "empty"},
+		{difference, "firstBitUnset", "lastBitUnset", "lastBitSet"},
+		{difference, "firstBitUnset", "innerBitsSet", "lastBitSet"},
+		{difference, "firstBitUnset", "outerBitsSet", "innerBitsSet"},
+		//
+		{difference, "lastBitUnset", "empty", "lastBitUnset"},
+		{difference, "lastBitUnset", "full", "empty"},
+		{difference, "lastBitUnset", "firstBitSet", "innerBitsSet"},
+		{difference, "lastBitUnset", "lastBitSet", "lastBitUnset"},
+		{difference, "lastBitUnset", "firstBitUnset", "firstBitSet"},
+		{difference, "lastBitUnset", "lastBitUnset", "empty"},
+		{difference, "lastBitUnset", "innerBitsSet", "firstBitSet"},
+		{difference, "lastBitUnset", "outerBitsSet", "innerBitsSet"},
+		//
+		{difference, "innerBitsSet", "empty", "innerBitsSet"},
+		{difference, "innerBitsSet", "full", "empty"},
+		{difference, "innerBitsSet", "firstBitSet", "innerBitsSet"},
+		{difference, "innerBitsSet", "lastBitSet", "innerBitsSet"},
+		{difference, "innerBitsSet", "firstBitUnset", "empty"},
+		{difference, "innerBitsSet", "lastBitUnset", "empty"},
+		{difference, "innerBitsSet", "innerBitsSet", "empty"},
+		{difference, "innerBitsSet", "outerBitsSet", "innerBitsSet"},
+		//
+		{difference, "outerBitsSet", "empty", "outerBitsSet"},
+		{difference, "outerBitsSet", "full", "empty"},
+		{difference, "outerBitsSet", "firstBitSet", "lastBitSet"},
+		{difference, "outerBitsSet", "lastBitSet", "firstBitSet"},
+		{difference, "outerBitsSet", "firstBitUnset", "firstBitSet"},
+		{difference, "outerBitsSet", "lastBitUnset", "lastBitSet"},
+		{difference, "outerBitsSet", "innerBitsSet", "outerBitsSet"},
+		{difference, "outerBitsSet", "outerBitsSet", "empty"},
+
+		// xor
+		{xor, "empty", "empty", "empty"},
+		{xor, "empty", "full", "full"},
+		{xor, "empty", "firstBitSet", "firstBitSet"},
+		{xor, "empty", "lastBitSet", "lastBitSet"},
+		{xor, "empty", "firstBitUnset", "firstBitUnset"},
+		{xor, "empty", "lastBitUnset", "lastBitUnset"},
+		{xor, "empty", "innerBitsSet", "innerBitsSet"},
+		{xor, "empty", "outerBitsSet", "outerBitsSet"},
+		//
+		{xor, "full", "empty", "full"},
+		{xor, "full", "full", "empty"},
+		{xor, "full", "firstBitSet", "firstBitUnset"},
+		{xor, "full", "lastBitSet", "lastBitUnset"},
+		{xor, "full", "firstBitUnset", "firstBitSet"},
+		{xor, "full", "lastBitUnset", "lastBitSet"},
+		{xor, "full", "innerBitsSet", "outerBitsSet"},
+		{xor, "full", "outerBitsSet", "innerBitsSet"},
+		//
+		{xor, "firstBitSet", "empty", "firstBitSet"},
+		{xor, "firstBitSet", "full", "firstBitUnset"},
+		{xor, "firstBitSet", "firstBitSet", "empty"},
+		{xor, "firstBitSet", "lastBitSet", "outerBitsSet"},
+		{xor, "firstBitSet", "firstBitUnset", "full"},
+		{xor, "firstBitSet", "lastBitUnset", "innerBitsSet"},
+		{xor, "firstBitSet", "innerBitsSet", "lastBitUnset"},
+		{xor, "firstBitSet", "outerBitsSet", "lastBitSet"},
+		//
+		{xor, "lastBitSet", "empty", "lastBitSet"},
+		{xor, "lastBitSet", "full", "lastBitUnset"},
+		{xor, "lastBitSet", "firstBitSet", "outerBitsSet"},
+		{xor, "lastBitSet", "lastBitSet", "empty"},
+		{xor, "lastBitSet", "firstBitUnset", "innerBitsSet"},
+		{xor, "lastBitSet", "lastBitUnset", "full"},
+		{xor, "lastBitSet", "innerBitsSet", "firstBitUnset"},
+		{xor, "lastBitSet", "outerBitsSet", "firstBitSet"},
+		//
+		{xor, "firstBitUnset", "empty", "firstBitUnset"},
+		{xor, "firstBitUnset", "full", "firstBitSet"},
+		{xor, "firstBitUnset", "firstBitSet", "full"},
+		{xor, "firstBitUnset", "lastBitSet", "innerBitsSet"},
+		{xor, "firstBitUnset", "firstBitUnset", "empty"},
+		{xor, "firstBitUnset", "lastBitUnset", "outerBitsSet"},
+		{xor, "firstBitUnset", "innerBitsSet", "lastBitSet"},
+		{xor, "firstBitUnset", "outerBitsSet", "lastBitUnset"},
+		//
+		{xor, "lastBitUnset", "empty", "lastBitUnset"},
+		{xor, "lastBitUnset", "full", "lastBitSet"},
+		{xor, "lastBitUnset", "firstBitSet", "innerBitsSet"},
+		{xor, "lastBitUnset", "lastBitSet", "full"},
+		{xor, "lastBitUnset", "firstBitUnset", "outerBitsSet"},
+		{xor, "lastBitUnset", "lastBitUnset", "empty"},
+		{xor, "lastBitUnset", "innerBitsSet", "firstBitSet"},
+		{xor, "lastBitUnset", "outerBitsSet", "firstBitUnset"},
+		//
+		{xor, "innerBitsSet", "empty", "innerBitsSet"},
+		{xor, "innerBitsSet", "full", "outerBitsSet"},
+		{xor, "innerBitsSet", "firstBitSet", "lastBitUnset"},
+		{xor, "innerBitsSet", "lastBitSet", "firstBitUnset"},
+		{xor, "innerBitsSet", "firstBitUnset", "lastBitSet"},
+		{xor, "innerBitsSet", "lastBitUnset", "firstBitSet"},
+		{xor, "innerBitsSet", "innerBitsSet", "empty"},
+		{xor, "innerBitsSet", "outerBitsSet", "full"},
+		//
+		{xor, "outerBitsSet", "empty", "outerBitsSet"},
+		{xor, "outerBitsSet", "full", "innerBitsSet"},
+		{xor, "outerBitsSet", "firstBitSet", "lastBitSet"},
+		{xor, "outerBitsSet", "lastBitSet", "firstBitSet"},
+		{xor, "outerBitsSet", "firstBitUnset", "lastBitUnset"},
+		{xor, "outerBitsSet", "lastBitUnset", "firstBitUnset"},
+		{xor, "outerBitsSet", "innerBitsSet", "full"},
+		{xor, "outerBitsSet", "outerBitsSet", "empty"},
+	}
+	for _, testOp := range testOps {
+		for _, x := range containerTypes {
+			for _, y := range containerTypes {
+				desc := fmt.Sprintf("%s(%s/%s, %s/%s)", getFunctionName(testOp.f), cm[x], testOp.x, cm[y], testOp.y)
+				ret := testOp.f(cts[x][testOp.x], cts[y][testOp.y])
+				exp := testOp.exp
+
+				// Convert to all container types and check result.
+				for _, ct := range containerTypes {
+					clone := ret.clone()
+					if ct == ContainerArray {
+						if clone.isBitmap() {
+							clone.bitmapToArray()
+						} else if clone.isRun() {
+							clone.runToArray()
+						}
+						if clone.n != cts[ct][exp].n {
+							t.Fatalf("test %s expected array n=%d, but got n=%d", desc, cts[ct][exp].n, clone.n)
+						}
+						// Because xorRunRun resulting in an empty container returns an array container with a
+						// nil slice array, then we need to check len() on array first (look for 0).
+						if !(len(clone.array) == 0 && len(cts[ct][exp].array) == 0) && !reflect.DeepEqual(clone.array, cts[ct][exp].array) {
+							t.Fatalf("test %s expected array %X, but got %X", desc, cts[ct][exp].array, clone.array)
+						}
+					} else if ct == ContainerBitmap {
+						if clone.isArray() {
+							clone.arrayToBitmap()
+						} else if clone.isRun() {
+							clone.runToBitmap()
+						}
+						if clone.n != cts[ct][exp].n {
+							t.Fatalf("test %s expected bitmap n=%d, but got n=%d", desc, cts[ct][exp].n, clone.n)
+						}
+						if !reflect.DeepEqual(clone.bitmap, cts[ct][exp].bitmap) {
+							t.Fatalf("test %s expected bitmap %X, but got %X", desc, cts[ct][exp].bitmap, clone.bitmap)
+						}
+					} else if ct == ContainerRun {
+						if clone.isArray() {
+							clone.arrayToRun()
+						} else if clone.isBitmap() {
+							clone.bitmapToRun()
+						}
+						if clone.n != cts[ct][exp].n {
+							t.Fatalf("test %s expected runs n=%d, but got n=%d", desc, cts[ct][exp].n, clone.n)
+						}
+						if !reflect.DeepEqual(clone.runs, cts[ct][exp].runs) {
+							t.Fatalf("test %s expected runs %X, but got %X", desc, cts[ct][exp].runs, clone.runs)
+						}
+					}
+				}
+			}
+		}
+	}
+}

From 673232baf9261e85d440238bd1c77e770a3955e7 Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Wed, 14 Feb 2018 13:30:38 -0600
Subject: [PATCH 2/4] bug fixes found by running container operation tests

---
 roaring/roaring.go | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/roaring/roaring.go b/roaring/roaring.go
index b7cdec1c9..b42da1418 100644
--- a/roaring/roaring.go
+++ b/roaring/roaring.go
@@ -2181,7 +2181,7 @@ func unionArrayArray(a, b *container) *container {
 // unionArrayRun optimistically assumes that the result will be a run container,
 // and converts to a bitmap or array container afterwards if necessary.
 func unionArrayRun(a, b *container) *container {
-	if b.n == maxContainerVal {
+	if b.n == maxContainerVal+1 {
 		return b.clone()
 	}
 	output := &container{containerType: ContainerRun}
@@ -2238,10 +2238,10 @@ func (c *container) runAppendInterval(v interval16) int {
 }
 
 func unionRunRun(a, b *container) *container {
-	if a.n == maxContainerVal {
+	if a.n == maxContainerVal+1 {
 		return a.clone()
 	}
-	if b.n == maxContainerVal {
+	if b.n == maxContainerVal+1 {
 		return b.clone()
 	}
 	na, nb := len(a.runs), len(b.runs)
@@ -2272,9 +2272,12 @@ func unionRunRun(a, b *container) *container {
 }
 
 func unionBitmapRun(a, b *container) *container {
-	if b.n == maxContainerVal {
+	if b.n == maxContainerVal+1 {
 		return b.clone()
 	}
+	if a.n == maxContainerVal+1 {
+		return a.clone()
+	}
 	output := a.clone()
 	for j := 0; j < len(b.runs); j++ {
 		output.bitmapSetRange(uint64(b.runs[j].start), uint64(b.runs[j].last)+1)
@@ -2289,7 +2292,7 @@ func (c *container) bitmapSetRange(i, j uint64) {
 	x := i >> 6
 	y := (j - 1) >> 6
 	var X uint64 = maxBitmap << (i % 64)
-	var Y uint64 = maxBitmap >> (64 - (j % 64))
+	var Y uint64 = maxBitmap >> (63 - ((j - 1) % 64))
 	xcnt := popcnt(X)
 	ycnt := popcnt(Y)
 	if x == y {
@@ -2312,7 +2315,7 @@ func (c *container) bitmapXorRange(i, j uint64) {
 	x := i >> 6
 	y := (j - 1) >> 6
 	var X uint64 = maxBitmap << (i % 64)
-	var Y uint64 = maxBitmap >> (64 - (j % 64))
+	var Y uint64 = maxBitmap >> (63 - ((j - 1) % 64))
 	if x == y {
 		cnt := popcnt(c.bitmap[x])
 		c.bitmap[x] ^= (X & Y) //// flip
@@ -2784,7 +2787,9 @@ func xorArrayBitmap(a, b *container) *container {
 		}
 	}
 
-	if output.count() < ArrayMaxSize {
+	// It's possible that output was converted from bitmap to array in output.remove()
+	// so we only do this conversion if output is still a bitmap container.
+	if output.containerType == ContainerBitmap && output.count() < ArrayMaxSize {
 		output.bitmapToArray()
 	}
 
@@ -3199,7 +3204,7 @@ func xorRunRun(a, b *container) *container {
 	if nb == 0 {
 		return a.clone()
 	}
-	output := &container{}
+	output := &container{containerType: ContainerRun}
 
 	lastI, lastJ := -1, -1
 

From 911af238ff8b6cf5ff2a5f4af52b0ecafc7ee19a Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Wed, 14 Feb 2018 15:06:53 -0600
Subject: [PATCH 3/4] clean up roaring container helper functions

---
 roaring/roaring_helpers_test.go | 25 +++++--------------------
 1 file changed, 5 insertions(+), 20 deletions(-)

diff --git a/roaring/roaring_helpers_test.go b/roaring/roaring_helpers_test.go
index de3dd002c..204b2fe2f 100644
--- a/roaring/roaring_helpers_test.go
+++ b/roaring/roaring_helpers_test.go
@@ -68,10 +68,7 @@ func arrayInnerBitsSet() []uint16 {
 }
 
 func arrayOuterBitsSet() []uint16 {
-	array := make([]uint16, 0)
-	array = append(array, uint16(0))
-	array = append(array, uint16(65535))
-	return array
+	return []uint16{0, 65535}
 }
 
 ////////////////// bitmap
@@ -100,39 +97,27 @@ func bitmapLastBitSet() []uint64 {
 }
 
 func bitmapFirstBitUnset() []uint64 {
-	bitmap := make([]uint64, bitmapN)
+	bitmap := bitmapFull()
 	bitmap[0] = 0xFFFFFFFFFFFFFFFE
-	for i := 1; i < bitmapN; i++ {
-		bitmap[i] = 0xFFFFFFFFFFFFFFFF
-	}
 	return bitmap
 }
 
 func bitmapLastBitUnset() []uint64 {
-	bitmap := make([]uint64, bitmapN)
-	for i := 0; i < bitmapN-1; i++ {
-		bitmap[i] = 0xFFFFFFFFFFFFFFFF
-	}
+	bitmap := bitmapFull()
 	bitmap[bitmapN-1] = 0x7FFFFFFFFFFFFFFF
 	return bitmap
 }
 
 func bitmapInnerBitsSet() []uint64 {
-	bitmap := make([]uint64, bitmapN)
+	bitmap := bitmapFull()
 	bitmap[0] = 0xFFFFFFFFFFFFFFFE
-	for i := 1; i < bitmapN-1; i++ {
-		bitmap[i] = 0xFFFFFFFFFFFFFFFF
-	}
 	bitmap[bitmapN-1] = 0x7FFFFFFFFFFFFFFF
 	return bitmap
 }
 
 func bitmapOuterBitsSet() []uint64 {
-	bitmap := make([]uint64, bitmapN)
+	bitmap := bitmapEmpty()
 	bitmap[0] = 0x0000000000000001
-	for i := 1; i < bitmapN-1; i++ {
-		bitmap[i] = 0x0000000000000000
-	}
 	bitmap[bitmapN-1] = 0x8000000000000000
 	return bitmap
 }

From 685a0075ae52779579adeed6a750be77d59cb263 Mon Sep 17 00:00:00 2001
From: Travis Turner <travis@pilosa.com>
Date: Thu, 15 Feb 2018 10:20:54 -0600
Subject: [PATCH 4/4] add evenBits/oddBits container tests and related bug fix

---
 roaring/roaring.go               |  16 ++-
 roaring/roaring_helpers_test.go  |  54 +++++++++
 roaring/roaring_internal_test.go | 187 ++++++++++++++++++++++++++-----
 3 files changed, 223 insertions(+), 34 deletions(-)

diff --git a/roaring/roaring.go b/roaring/roaring.go
index b42da1418..8d88b2088 100644
--- a/roaring/roaring.go
+++ b/roaring/roaring.go
@@ -2476,10 +2476,18 @@ func differenceArrayRun(a, b *container) *container {
 
 	if i < len(a.array) {
 		// keep all array elements after end of runs
-		output.array = append(output.array, a.array[i:]...)
-		// TODO: consider handling container.n mutations in one place
-		// like we do with container.add().
-		output.n += len(a.array[i:])
+		// It's possible that output was converted from array to bitmap in output.add()
+		// so check container type before proceeding.
+		if output.containerType == ContainerArray {
+			output.array = append(output.array, a.array[i:]...)
+			// TODO: consider handling container.n mutations in one place
+			// like we do with container.add().
+			output.n += len(a.array[i:])
+		} else {
+			for _, v := range a.array[i:] {
+				output.add(v)
+			}
+		}
 	}
 	return output
 }
diff --git a/roaring/roaring_helpers_test.go b/roaring/roaring_helpers_test.go
index 204b2fe2f..ea6d86cd9 100644
--- a/roaring/roaring_helpers_test.go
+++ b/roaring/roaring_helpers_test.go
@@ -71,6 +71,22 @@ 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)
@@ -122,6 +138,22 @@ func bitmapOuterBitsSet() []uint64 {
 	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)
@@ -170,6 +202,22 @@ func runOuterBitsSet() []interval16 {
 	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 {
@@ -211,6 +259,8 @@ func setupContainerTests() map[byte]map[string]*container {
 		"lastBitUnset":  doContainer(ContainerArray, arrayLastBitUnset()),
 		"innerBitsSet":  doContainer(ContainerArray, arrayInnerBitsSet()),
 		"outerBitsSet":  doContainer(ContainerArray, arrayOuterBitsSet()),
+		"oddBitsSet":    doContainer(ContainerArray, arrayOddBitsSet()),
+		"evenBitsSet":   doContainer(ContainerArray, arrayEvenBitsSet()),
 	}
 
 	// bitmap containers
@@ -223,6 +273,8 @@ func setupContainerTests() map[byte]map[string]*container {
 		"lastBitUnset":  doContainer(ContainerBitmap, bitmapLastBitUnset()),
 		"innerBitsSet":  doContainer(ContainerBitmap, bitmapInnerBitsSet()),
 		"outerBitsSet":  doContainer(ContainerBitmap, bitmapOuterBitsSet()),
+		"oddBitsSet":    doContainer(ContainerBitmap, bitmapOddBitsSet()),
+		"evenBitsSet":   doContainer(ContainerBitmap, bitmapEvenBitsSet()),
 	}
 
 	// run containers
@@ -235,6 +287,8 @@ func setupContainerTests() map[byte]map[string]*container {
 		"lastBitUnset":  doContainer(ContainerRun, runLastBitUnset()),
 		"innerBitsSet":  doContainer(ContainerRun, runInnerBitsSet()),
 		"outerBitsSet":  doContainer(ContainerRun, runOuterBitsSet()),
+		"oddBitsSet":    doContainer(ContainerRun, runOddBitsSet()),
+		"evenBitsSet":   doContainer(ContainerRun, runEvenBitsSet()),
 	}
 
 	return cts
diff --git a/roaring/roaring_internal_test.go b/roaring/roaring_internal_test.go
index ce9ab217d..dca413811 100644
--- a/roaring/roaring_internal_test.go
+++ b/roaring/roaring_internal_test.go
@@ -1641,7 +1641,7 @@ func TestDifferenceBitmapRun(t *testing.T) {
 			exp:    []uint64{0x0000000000000000},
 		},
 		{
-			bitmap: bitmapLast(),
+			bitmap: bitmapLastBitSet(),
 			runs:   []interval16{{start: 65535, last: 65535}},
 			exp:    bitmapEmpty(),
 		},
@@ -1689,12 +1689,12 @@ func TestDifferenceBitmapArray(t *testing.T) {
 			exp:    []uint16{8, 9, 11, 12, 13, 14, 15},
 		},
 		{
-			bitmap: bitmapOdds(),
+			bitmap: bitmapOddBitsSet(),
 			array:  []uint16{0, 1, 2, 3, 4, 5, 6, 7, 10},
 			exp:    []uint16{9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63},
 		},
 		{
-			bitmap: bitmapOdds(),
+			bitmap: bitmapOddBitsSet(),
 			array:  []uint16{63},
 			exp:    []uint16{1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61},
 		},
@@ -2610,12 +2610,12 @@ func TestIntersectArrayBitmap(t *testing.T) {
 		},
 		{
 			array:  []uint16{0, 1, 63, 120, 543, 639, 12000, 65534, 65535},
-			bitmap: bitmapOdds(),
+			bitmap: bitmapOddBitsSet(),
 			exp:    []uint16{1, 63, 543, 639, 65535},
 		},
 		{
 			array:  []uint16{0, 1, 63, 120, 543, 639, 12000, 65534, 65535},
-			bitmap: bitmapEvens(),
+			bitmap: bitmapEvenBitsSet(),
 			exp:    []uint16{0, 120, 12000, 65534},
 		},
 	}
@@ -2637,31 +2637,6 @@ func TestIntersectArrayBitmap(t *testing.T) {
 	}
 }
 
-func bitmapOdds() []uint64 {
-	bitmap := make([]uint64, bitmapN)
-	for i := 0; i < bitmapN; i++ {
-		bitmap[i] = 0xAAAAAAAAAAAAAAAA
-	}
-	return bitmap
-}
-
-func bitmapEvens() []uint64 {
-	bitmap := make([]uint64, bitmapN)
-	for i := 0; i < bitmapN; i++ {
-		bitmap[i] = 0x5555555555555555
-	}
-	return bitmap
-}
-
-func bitmapLast() []uint64 {
-	bitmap := make([]uint64, bitmapN)
-	for i := 0; i < bitmapN-1; i++ {
-		bitmap[i] = 0
-	}
-	bitmap[bitmapN-1] = 0x8000000000000000
-	return bitmap
-}
-
 // rleCont returns a slice of numbers all in the range starting from
 // container_width*num, and ending at container_width*(num+1)-1. If left is
 // true, then the first 100 bits will be set, if mid is true, 100 bits in the
@@ -2776,6 +2751,8 @@ func TestContainerCombinations(t *testing.T) {
 		{intersect, "empty", "lastBitUnset", "empty"},
 		{intersect, "empty", "innerBitsSet", "empty"},
 		{intersect, "empty", "outerBitsSet", "empty"},
+		{intersect, "empty", "oddBitsSet", "empty"},
+		{intersect, "empty", "evenBitsSet", "empty"},
 		//
 		{intersect, "full", "empty", "empty"},
 		{intersect, "full", "full", "full"},
@@ -2785,6 +2762,8 @@ func TestContainerCombinations(t *testing.T) {
 		{intersect, "full", "lastBitUnset", "lastBitUnset"},
 		{intersect, "full", "innerBitsSet", "innerBitsSet"},
 		{intersect, "full", "outerBitsSet", "outerBitsSet"},
+		{intersect, "full", "oddBitsSet", "oddBitsSet"},
+		{intersect, "full", "evenBitsSet", "evenBitsSet"},
 		//
 		{intersect, "firstBitSet", "empty", "empty"},
 		{intersect, "firstBitSet", "full", "firstBitSet"},
@@ -2794,6 +2773,8 @@ func TestContainerCombinations(t *testing.T) {
 		{intersect, "firstBitSet", "lastBitUnset", "firstBitSet"},
 		{intersect, "firstBitSet", "innerBitsSet", "empty"},
 		{intersect, "firstBitSet", "outerBitsSet", "firstBitSet"},
+		{intersect, "firstBitSet", "oddBitsSet", "empty"},
+		{intersect, "firstBitSet", "evenBitsSet", "firstBitSet"},
 		//
 		{intersect, "lastBitSet", "empty", "empty"},
 		{intersect, "lastBitSet", "full", "lastBitSet"},
@@ -2803,6 +2784,8 @@ func TestContainerCombinations(t *testing.T) {
 		{intersect, "lastBitSet", "lastBitUnset", "empty"},
 		{intersect, "lastBitSet", "innerBitsSet", "empty"},
 		{intersect, "lastBitSet", "outerBitsSet", "lastBitSet"},
+		{intersect, "lastBitSet", "oddBitsSet", "lastBitSet"},
+		{intersect, "lastBitSet", "evenBitsSet", "empty"},
 		//
 		{intersect, "firstBitUnset", "empty", "empty"},
 		{intersect, "firstBitUnset", "full", "firstBitUnset"},
@@ -2812,6 +2795,8 @@ func TestContainerCombinations(t *testing.T) {
 		{intersect, "firstBitUnset", "lastBitUnset", "innerBitsSet"},
 		{intersect, "firstBitUnset", "innerBitsSet", "innerBitsSet"},
 		{intersect, "firstBitUnset", "outerBitsSet", "lastBitSet"},
+		{intersect, "firstBitUnset", "oddBitsSet", "oddBitsSet"},
+		//{intersect, "firstBitUnset", "evenBitsSet", ""},
 		//
 		{intersect, "lastBitUnset", "empty", "empty"},
 		{intersect, "lastBitUnset", "full", "lastBitUnset"},
@@ -2821,6 +2806,8 @@ func TestContainerCombinations(t *testing.T) {
 		{intersect, "lastBitUnset", "lastBitUnset", "lastBitUnset"},
 		{intersect, "lastBitUnset", "innerBitsSet", "innerBitsSet"},
 		{intersect, "lastBitUnset", "outerBitsSet", "firstBitSet"},
+		//{intersect, "lastBitUnset", "oddBitsSet", ""},
+		{intersect, "lastBitUnset", "evenBitsSet", "evenBitsSet"},
 		//
 		{intersect, "innerBitsSet", "empty", "empty"},
 		{intersect, "innerBitsSet", "full", "innerBitsSet"},
@@ -2830,6 +2817,8 @@ func TestContainerCombinations(t *testing.T) {
 		{intersect, "innerBitsSet", "lastBitUnset", "innerBitsSet"},
 		{intersect, "innerBitsSet", "innerBitsSet", "innerBitsSet"},
 		{intersect, "innerBitsSet", "outerBitsSet", "empty"},
+		//{intersect, "innerBitsSet", "oddBitsSet", ""},
+		//{intersect, "innerBitsSet", "evenBitsSet", ""},
 		//
 		{intersect, "outerBitsSet", "empty", "empty"},
 		{intersect, "outerBitsSet", "full", "outerBitsSet"},
@@ -2839,6 +2828,30 @@ func TestContainerCombinations(t *testing.T) {
 		{intersect, "outerBitsSet", "lastBitUnset", "firstBitSet"},
 		{intersect, "outerBitsSet", "innerBitsSet", "empty"},
 		{intersect, "outerBitsSet", "outerBitsSet", "outerBitsSet"},
+		{intersect, "outerBitsSet", "oddBitsSet", "lastBitSet"},
+		{intersect, "outerBitsSet", "evenBitsSet", "firstBitSet"},
+		//
+		{intersect, "oddBitsSet", "empty", "empty"},
+		{intersect, "oddBitsSet", "full", "oddBitsSet"},
+		{intersect, "oddBitsSet", "firstBitSet", "empty"},
+		{intersect, "oddBitsSet", "lastBitSet", "lastBitSet"},
+		{intersect, "oddBitsSet", "firstBitUnset", "oddBitsSet"},
+		//{intersect, "oddBitsSet", "lastBitUnset", ""},
+		//{intersect, "oddBitsSet", "innerBitsSet", ""},
+		{intersect, "oddBitsSet", "outerBitsSet", "lastBitSet"},
+		{intersect, "oddBitsSet", "oddBitsSet", "oddBitsSet"},
+		{intersect, "oddBitsSet", "evenBitsSet", "empty"},
+		//
+		{intersect, "evenBitsSet", "empty", "empty"},
+		{intersect, "evenBitsSet", "full", "evenBitsSet"},
+		{intersect, "evenBitsSet", "firstBitSet", "firstBitSet"},
+		{intersect, "evenBitsSet", "lastBitSet", "empty"},
+		//{intersect, "evenBitsSet", "firstBitUnset", ""},
+		{intersect, "evenBitsSet", "lastBitUnset", "evenBitsSet"},
+		//{intersect, "evenBitsSet", "innerBitsSet", ""},
+		{intersect, "evenBitsSet", "outerBitsSet", "firstBitSet"},
+		{intersect, "evenBitsSet", "oddBitsSet", "empty"},
+		{intersect, "evenBitsSet", "evenBitsSet", "evenBitsSet"},
 
 		// union
 		{union, "empty", "empty", "empty"},
@@ -2849,6 +2862,8 @@ func TestContainerCombinations(t *testing.T) {
 		{union, "empty", "lastBitUnset", "lastBitUnset"},
 		{union, "empty", "innerBitsSet", "innerBitsSet"},
 		{union, "empty", "outerBitsSet", "outerBitsSet"},
+		{union, "empty", "oddBitsSet", "oddBitsSet"},
+		{union, "empty", "evenBitsSet", "evenBitsSet"},
 		//
 		{union, "full", "empty", "full"},
 		{union, "full", "full", "full"},
@@ -2858,6 +2873,8 @@ func TestContainerCombinations(t *testing.T) {
 		{union, "full", "lastBitUnset", "full"},
 		{union, "full", "innerBitsSet", "full"},
 		{union, "full", "outerBitsSet", "full"},
+		{union, "full", "oddBitsSet", "full"},
+		{union, "full", "evenBitsSet", "full"},
 		//
 		{union, "firstBitSet", "empty", "firstBitSet"},
 		{union, "firstBitSet", "full", "full"},
@@ -2867,6 +2884,8 @@ func TestContainerCombinations(t *testing.T) {
 		{union, "firstBitSet", "lastBitUnset", "lastBitUnset"},
 		{union, "firstBitSet", "innerBitsSet", "lastBitUnset"},
 		{union, "firstBitSet", "outerBitsSet", "outerBitsSet"},
+		//{union, "firstBitSet", "oddBitsSet", ""},
+		{union, "firstBitSet", "evenBitsSet", "evenBitsSet"},
 		//
 		{union, "lastBitSet", "empty", "lastBitSet"},
 		{union, "lastBitSet", "full", "full"},
@@ -2876,6 +2895,8 @@ func TestContainerCombinations(t *testing.T) {
 		{union, "lastBitSet", "lastBitUnset", "full"},
 		{union, "lastBitSet", "innerBitsSet", "firstBitUnset"},
 		{union, "lastBitSet", "outerBitsSet", "outerBitsSet"},
+		{union, "lastBitSet", "oddBitsSet", "oddBitsSet"},
+		//{union, "lastBitSet", "evenBitsSet", ""},
 		//
 		{union, "firstBitUnset", "empty", "firstBitUnset"},
 		{union, "firstBitUnset", "full", "full"},
@@ -2885,6 +2906,8 @@ func TestContainerCombinations(t *testing.T) {
 		{union, "firstBitUnset", "lastBitUnset", "full"},
 		{union, "firstBitUnset", "innerBitsSet", "firstBitUnset"},
 		{union, "firstBitUnset", "outerBitsSet", "full"},
+		{union, "firstBitUnset", "oddBitsSet", "firstBitUnset"},
+		{union, "firstBitUnset", "evenBitsSet", "full"},
 		//
 		{union, "lastBitUnset", "empty", "lastBitUnset"},
 		{union, "lastBitUnset", "full", "full"},
@@ -2894,6 +2917,8 @@ func TestContainerCombinations(t *testing.T) {
 		{union, "lastBitUnset", "lastBitUnset", "lastBitUnset"},
 		{union, "lastBitUnset", "innerBitsSet", "lastBitUnset"},
 		{union, "lastBitUnset", "outerBitsSet", "full"},
+		{union, "lastBitUnset", "oddBitsSet", "full"},
+		{union, "lastBitUnset", "evenBitsSet", "lastBitUnset"},
 		//
 		{union, "innerBitsSet", "empty", "innerBitsSet"},
 		{union, "innerBitsSet", "full", "full"},
@@ -2903,6 +2928,8 @@ func TestContainerCombinations(t *testing.T) {
 		{union, "innerBitsSet", "lastBitUnset", "lastBitUnset"},
 		{union, "innerBitsSet", "innerBitsSet", "innerBitsSet"},
 		{union, "innerBitsSet", "outerBitsSet", "full"},
+		{union, "innerBitsSet", "oddBitsSet", "firstBitUnset"},
+		{union, "innerBitsSet", "evenBitsSet", "lastBitUnset"},
 		//
 		{union, "outerBitsSet", "empty", "outerBitsSet"},
 		{union, "outerBitsSet", "full", "full"},
@@ -2912,6 +2939,30 @@ func TestContainerCombinations(t *testing.T) {
 		{union, "outerBitsSet", "lastBitUnset", "full"},
 		{union, "outerBitsSet", "innerBitsSet", "full"},
 		{union, "outerBitsSet", "outerBitsSet", "outerBitsSet"},
+		//{union, "outerBitsSet", "oddBitsSet", ""},
+		//{union, "outerBitsSet", "evenBitsSet", ""},
+		//
+		{union, "oddBitsSet", "empty", "oddBitsSet"},
+		{union, "oddBitsSet", "full", "full"},
+		//{union, "oddBitsSet", "firstBitSet", ""},
+		{union, "oddBitsSet", "lastBitSet", "oddBitsSet"},
+		{union, "oddBitsSet", "firstBitUnset", "firstBitUnset"},
+		{union, "oddBitsSet", "lastBitUnset", "full"},
+		{union, "oddBitsSet", "innerBitsSet", "firstBitUnset"},
+		//{union, "oddBitsSet", "outerBitsSet", ""},
+		{union, "oddBitsSet", "oddBitsSet", "oddBitsSet"},
+		{union, "oddBitsSet", "evenBitsSet", "full"},
+		//
+		{union, "evenBitsSet", "empty", "evenBitsSet"},
+		{union, "evenBitsSet", "full", "full"},
+		{union, "evenBitsSet", "firstBitSet", "evenBitsSet"},
+		//{union, "evenBitsSet", "lastBitSet", ""},
+		{union, "evenBitsSet", "firstBitUnset", "full"},
+		{union, "evenBitsSet", "lastBitUnset", "lastBitUnset"},
+		{union, "evenBitsSet", "innerBitsSet", "lastBitUnset"},
+		//{union, "evenBitsSet", "outerBitsSet", ""},
+		{union, "evenBitsSet", "oddBitsSet", "full"},
+		{union, "evenBitsSet", "evenBitsSet", "evenBitsSet"},
 
 		// difference
 		{difference, "empty", "empty", "empty"},
@@ -2922,6 +2973,8 @@ func TestContainerCombinations(t *testing.T) {
 		{difference, "empty", "lastBitUnset", "empty"},
 		{difference, "empty", "innerBitsSet", "empty"},
 		{difference, "empty", "outerBitsSet", "empty"},
+		{difference, "empty", "oddBitsSet", "empty"},
+		{difference, "empty", "evenBitsSet", "empty"},
 		//
 		{difference, "full", "empty", "full"},
 		{difference, "full", "full", "empty"},
@@ -2931,6 +2984,8 @@ func TestContainerCombinations(t *testing.T) {
 		{difference, "full", "lastBitUnset", "lastBitSet"},
 		{difference, "full", "innerBitsSet", "outerBitsSet"},
 		{difference, "full", "outerBitsSet", "innerBitsSet"},
+		{difference, "full", "oddBitsSet", "evenBitsSet"},
+		{difference, "full", "evenBitsSet", "oddBitsSet"},
 		//
 		{difference, "firstBitSet", "empty", "firstBitSet"},
 		{difference, "firstBitSet", "full", "empty"},
@@ -2940,6 +2995,8 @@ func TestContainerCombinations(t *testing.T) {
 		{difference, "firstBitSet", "lastBitUnset", "empty"},
 		{difference, "firstBitSet", "innerBitsSet", "firstBitSet"},
 		{difference, "firstBitSet", "outerBitsSet", "empty"},
+		{difference, "firstBitSet", "oddBitsSet", "firstBitSet"},
+		{difference, "firstBitSet", "evenBitsSet", "empty"},
 		//
 		{difference, "lastBitSet", "empty", "lastBitSet"},
 		{difference, "lastBitSet", "full", "empty"},
@@ -2949,6 +3006,8 @@ func TestContainerCombinations(t *testing.T) {
 		{difference, "lastBitSet", "lastBitUnset", "lastBitSet"},
 		{difference, "lastBitSet", "innerBitsSet", "lastBitSet"},
 		{difference, "lastBitSet", "outerBitsSet", "empty"},
+		{difference, "lastBitSet", "oddBitsSet", "empty"},
+		{difference, "lastBitSet", "evenBitsSet", "lastBitSet"},
 		//
 		{difference, "firstBitUnset", "empty", "firstBitUnset"},
 		{difference, "firstBitUnset", "full", "empty"},
@@ -2958,6 +3017,8 @@ func TestContainerCombinations(t *testing.T) {
 		{difference, "firstBitUnset", "lastBitUnset", "lastBitSet"},
 		{difference, "firstBitUnset", "innerBitsSet", "lastBitSet"},
 		{difference, "firstBitUnset", "outerBitsSet", "innerBitsSet"},
+		//{difference, "firstBitUnset", "oddBitsSet", ""},
+		{difference, "firstBitUnset", "evenBitsSet", "oddBitsSet"},
 		//
 		{difference, "lastBitUnset", "empty", "lastBitUnset"},
 		{difference, "lastBitUnset", "full", "empty"},
@@ -2967,6 +3028,8 @@ func TestContainerCombinations(t *testing.T) {
 		{difference, "lastBitUnset", "lastBitUnset", "empty"},
 		{difference, "lastBitUnset", "innerBitsSet", "firstBitSet"},
 		{difference, "lastBitUnset", "outerBitsSet", "innerBitsSet"},
+		{difference, "lastBitUnset", "oddBitsSet", "evenBitsSet"},
+		//{difference, "lastBitUnset", "evenBitsSet", ""},
 		//
 		{difference, "innerBitsSet", "empty", "innerBitsSet"},
 		{difference, "innerBitsSet", "full", "empty"},
@@ -2976,6 +3039,8 @@ func TestContainerCombinations(t *testing.T) {
 		{difference, "innerBitsSet", "lastBitUnset", "empty"},
 		{difference, "innerBitsSet", "innerBitsSet", "empty"},
 		{difference, "innerBitsSet", "outerBitsSet", "innerBitsSet"},
+		//{difference, "innerBitsSet", "oddBitsSet", ""},
+		//{difference, "innerBitsSet", "evenBitsSet", ""},
 		//
 		{difference, "outerBitsSet", "empty", "outerBitsSet"},
 		{difference, "outerBitsSet", "full", "empty"},
@@ -2985,6 +3050,30 @@ func TestContainerCombinations(t *testing.T) {
 		{difference, "outerBitsSet", "lastBitUnset", "lastBitSet"},
 		{difference, "outerBitsSet", "innerBitsSet", "outerBitsSet"},
 		{difference, "outerBitsSet", "outerBitsSet", "empty"},
+		{difference, "outerBitsSet", "oddBitsSet", "firstBitSet"},
+		{difference, "outerBitsSet", "evenBitsSet", "lastBitSet"},
+		//
+		{difference, "oddBitsSet", "empty", "oddBitsSet"},
+		{difference, "oddBitsSet", "full", "empty"},
+		{difference, "oddBitsSet", "firstBitSet", "oddBitsSet"},
+		//{difference, "oddBitsSet", "lastBitSet", ""},
+		{difference, "oddBitsSet", "firstBitUnset", "empty"},
+		{difference, "oddBitsSet", "lastBitUnset", "lastBitSet"},
+		{difference, "oddBitsSet", "innerBitsSet", "lastBitSet"},
+		//{difference, "oddBitsSet", "outerBitsSet", ""},
+		{difference, "oddBitsSet", "oddBitsSet", "empty"},
+		{difference, "oddBitsSet", "evenBitsSet", "oddBitsSet"},
+		//
+		{difference, "evenBitsSet", "empty", "evenBitsSet"},
+		{difference, "evenBitsSet", "full", "empty"},
+		//{difference, "evenBitsSet", "firstBitSet", ""},
+		{difference, "evenBitsSet", "lastBitSet", "evenBitsSet"},
+		{difference, "evenBitsSet", "firstBitUnset", "firstBitSet"},
+		{difference, "evenBitsSet", "lastBitUnset", "empty"},
+		{difference, "evenBitsSet", "innerBitsSet", "firstBitSet"},
+		//{difference, "evenBitsSet", "outerBitsSet", ""},
+		{difference, "evenBitsSet", "oddBitsSet", "evenBitsSet"},
+		{difference, "evenBitsSet", "evenBitsSet", "empty"},
 
 		// xor
 		{xor, "empty", "empty", "empty"},
@@ -2995,6 +3084,8 @@ func TestContainerCombinations(t *testing.T) {
 		{xor, "empty", "lastBitUnset", "lastBitUnset"},
 		{xor, "empty", "innerBitsSet", "innerBitsSet"},
 		{xor, "empty", "outerBitsSet", "outerBitsSet"},
+		{xor, "empty", "oddBitsSet", "oddBitsSet"},
+		{xor, "empty", "evenBitsSet", "evenBitsSet"},
 		//
 		{xor, "full", "empty", "full"},
 		{xor, "full", "full", "empty"},
@@ -3004,6 +3095,8 @@ func TestContainerCombinations(t *testing.T) {
 		{xor, "full", "lastBitUnset", "lastBitSet"},
 		{xor, "full", "innerBitsSet", "outerBitsSet"},
 		{xor, "full", "outerBitsSet", "innerBitsSet"},
+		{xor, "full", "oddBitsSet", "evenBitsSet"},
+		{xor, "full", "evenBitsSet", "oddBitsSet"},
 		//
 		{xor, "firstBitSet", "empty", "firstBitSet"},
 		{xor, "firstBitSet", "full", "firstBitUnset"},
@@ -3013,6 +3106,8 @@ func TestContainerCombinations(t *testing.T) {
 		{xor, "firstBitSet", "lastBitUnset", "innerBitsSet"},
 		{xor, "firstBitSet", "innerBitsSet", "lastBitUnset"},
 		{xor, "firstBitSet", "outerBitsSet", "lastBitSet"},
+		//{xor, "firstBitSet", "oddBitsSet", ""},
+		//{xor, "firstBitSet", "evenBitsSet", ""},
 		//
 		{xor, "lastBitSet", "empty", "lastBitSet"},
 		{xor, "lastBitSet", "full", "lastBitUnset"},
@@ -3022,6 +3117,8 @@ func TestContainerCombinations(t *testing.T) {
 		{xor, "lastBitSet", "lastBitUnset", "full"},
 		{xor, "lastBitSet", "innerBitsSet", "firstBitUnset"},
 		{xor, "lastBitSet", "outerBitsSet", "firstBitSet"},
+		//{xor, "lastBitSet", "oddBitsSet", ""},
+		//{xor, "lastBitSet", "evenBitsSet", ""},
 		//
 		{xor, "firstBitUnset", "empty", "firstBitUnset"},
 		{xor, "firstBitUnset", "full", "firstBitSet"},
@@ -3031,6 +3128,8 @@ func TestContainerCombinations(t *testing.T) {
 		{xor, "firstBitUnset", "lastBitUnset", "outerBitsSet"},
 		{xor, "firstBitUnset", "innerBitsSet", "lastBitSet"},
 		{xor, "firstBitUnset", "outerBitsSet", "lastBitUnset"},
+		//{xor, "firstBitUnset", "oddBitsSet", ""},
+		//{xor, "firstBitUnset", "evenBitsSet", ""},
 		//
 		{xor, "lastBitUnset", "empty", "lastBitUnset"},
 		{xor, "lastBitUnset", "full", "lastBitSet"},
@@ -3040,6 +3139,8 @@ func TestContainerCombinations(t *testing.T) {
 		{xor, "lastBitUnset", "lastBitUnset", "empty"},
 		{xor, "lastBitUnset", "innerBitsSet", "firstBitSet"},
 		{xor, "lastBitUnset", "outerBitsSet", "firstBitUnset"},
+		//{xor, "lastBitUnset", "oddBitsSet", ""},
+		//{xor, "lastBitUnset", "evenBitsSet", ""},
 		//
 		{xor, "innerBitsSet", "empty", "innerBitsSet"},
 		{xor, "innerBitsSet", "full", "outerBitsSet"},
@@ -3049,6 +3150,8 @@ func TestContainerCombinations(t *testing.T) {
 		{xor, "innerBitsSet", "lastBitUnset", "firstBitSet"},
 		{xor, "innerBitsSet", "innerBitsSet", "empty"},
 		{xor, "innerBitsSet", "outerBitsSet", "full"},
+		//{xor, "innerBitsSet", "oddBitsSet", ""},
+		//{xor, "innerBitsSet", "evenBitsSet", ""},
 		//
 		{xor, "outerBitsSet", "empty", "outerBitsSet"},
 		{xor, "outerBitsSet", "full", "innerBitsSet"},
@@ -3058,6 +3161,30 @@ func TestContainerCombinations(t *testing.T) {
 		{xor, "outerBitsSet", "lastBitUnset", "firstBitUnset"},
 		{xor, "outerBitsSet", "innerBitsSet", "full"},
 		{xor, "outerBitsSet", "outerBitsSet", "empty"},
+		//{xor, "outerBitsSet", "oddBitsSet", ""},
+		//{xor, "outerBitsSet", "evenBitsSet", ""},
+		//
+		{xor, "oddBitsSet", "empty", "oddBitsSet"},
+		{xor, "oddBitsSet", "full", "evenBitsSet"},
+		//{xor, "oddBitsSet", "firstBitSet", ""},
+		//{xor, "oddBitsSet", "lastBitSet", ""},
+		//{xor, "oddBitsSet", "firstBitUnset", ""},
+		//{xor, "oddBitsSet", "lastBitUnset", ""},
+		//{xor, "oddBitsSet", "innerBitsSet", ""},
+		//{xor, "oddBitsSet", "outerBitsSet", ""},
+		{xor, "oddBitsSet", "oddBitsSet", "empty"},
+		{xor, "oddBitsSet", "evenBitsSet", "full"},
+		//
+		{xor, "evenBitsSet", "empty", "evenBitsSet"},
+		{xor, "evenBitsSet", "full", "oddBitsSet"},
+		//{xor, "evenBitsSet", "firstBitSet", ""},
+		//{xor, "evenBitsSet", "lastBitSet", ""},
+		//{xor, "evenBitsSet", "firstBitUnset", ""},
+		//{xor, "evenBitsSet", "lastBitUnset", ""},
+		//{xor, "evenBitsSet", "innerBitsSet", ""},
+		//{xor, "evenBitsSet", "outerBitsSet", ""},
+		{xor, "evenBitsSet", "oddBitsSet", "full"},
+		{xor, "evenBitsSet", "evenBitsSet", "empty"},
 	}
 	for _, testOp := range testOps {
 		for _, x := range containerTypes {