package kdtree

import (

"math"

"math/rand"

"reflect"

"sync"

"testing"

"testing/quick"

)

// A pointSlice is a slice of points that implements the quick.Generator

// interface, generating a random set of points on the unit square.

type pointSlice []Point

func (pointSlice) Generate(r *rand.Rand, size int) reflect.Value {

}

// Generate implements the Generator interface for Points

func (p Point) Generate(r *rand.Rand, _ int) reflect.Value {

}

// TestInsert tests the insert function, ensuring that random points

// inserted into an empty tree maintain the K-D tree invariant.

func TestInsert(t *testing.T) {

}

// When splitting on the median, values after the median index may tie the median.

// Make sure that we correctly account for this when splitting and reusing slices.

// The test ensures that we don't panic.

// See issue 18.

func TestMedianTies(t *testing.T) {

}

// TestMake tests the Make function, ensuring that a tree built

// using random points respects the K-D tree invariant.

func TestMake(t *testing.T) {

}

// TestInRange tests the InRange function, ensuring that all points

// in the range are reported, and all points reported are indeed in

// the range.

func TestInRange(t *testing.T) {

}

// InvariantHolds returns the points in this subtree, and a bool

// that is true if the K-D tree invariant holds. The K-D tree invariant

// states that all points in the left subtree have values less than that

// of the current node on the splitting dimension, and the points

// in the right subtree have values greater than or equal to that of

// the current node.

func (t *T) invariantHolds() ([]Point, bool) {

}

func TestPreSort(t *testing.T) {

}

func TestPreSort_SplitMed(t *testing.T) {

}

// IsSortedOnDim returns true if the given slice is in sorted order

// on the given dimension.

func isSortedOnDim(dim int, nodes []*T) bool {

}

func TestDump(t *testing.T) {

}

func TestRaces(t *testing.T) {

}