structure_old/priority_queue/priority_queue_test.go

package plist

import (
	"testing"

	"github.com/emirpasic/gods/utils"

	"github.com/Pallinder/go-randomdata"

	"github.com/emirpasic/gods/trees/binaryheap"
)

func TestPriorityQueueGet(t *testing.T) {
	p := NewWithInt()

	var l []int
	for i := 0; i < 10; i++ {
		l = append(l, randomdata.Number(0, 1000))
	}

	for _, v := range l {
		p.Push(v)
		t.Log(p.String())
	}

	t.Error(p.data.Values())

}

func TestPriorityQueuePush(t *testing.T) {
	p := NewWithInt()

	var l []int
	for i := 0; i < 20; i++ {
		l = append(l, randomdata.Number(0, 5))
	}

	for _, v := range l {
		p.Push(v)
		t.Log(p.String())
	}

	t.Error(l)
	t.Error(p.data.Values(), p.Head, p.Tail)

	cur := p.Head
	for cur != nil {
		t.Error(cur.Value)
		cur = cur.Prev()
	}

	t.Error("-----")

	cur = p.Tail
	for cur != nil {
		t.Error(cur.Value)
		cur = cur.Next()
	}
}

func TestPriorityQueueRemove(t *testing.T) {
	p := NewWithInt()

	for i := 0; i < 20; i++ {
		p.Push(randomdata.Number(0, 10))
	}
	t.Error(p.Values())
	n, ok := p.GetNode(0)
	t.Error(n, ok, p.Head, p.Tail)

	for i := 0; i < 20; i++ {
		t.Error(p.Remove(0), p.data.Size())
		t.Error(p.Values())
	}
}

func BenchmarkPriorityQueuePush(b *testing.B) {
	p := NewWithInt()

	b.N = 1000000
	for i := 0; i < b.N; i++ {
		p.Push(randomdata.Number(0, 100000))
	}
}

func BenchmarkPriorityQueueRemove(b *testing.B) {
	p := NewWithInt()

	for i := 0; i < 1000000; i++ {
		p.Push(randomdata.Number(0, 100000))
	}

	b.StartTimer()
	b.N = 1000000
	for i := 0; i < b.N-100; i++ {
		p.Remove(randomdata.Number(0, 100))
	}
	for p.Remove(0) != nil {

	}
}

func BenchmarkPriorityQueueGet(b *testing.B) {
	p := NewWithInt()

	for i := 0; i < 500000; i++ {
		p.Push(randomdata.Number(0, 100000))
		// p.Values()
	}

	b.ResetTimer()
	b.StartTimer()
	b.N = 100000
	for i := 0; i < b.N; i++ {
		p.Get(randomdata.Number(0, 1000))
	}
	b.StopTimer()

}

func TestAVL(t *testing.T) {
	avl := NewWithIntComparator()
	for i := 0; i < 100; i++ {
		v := randomdata.Number(0, 100)
		avl.Put(v)
	}

	t.Error(avl.size)
	t.Error(avl.Values())
	f, ok := avl.Ceiling(1000)
	t.Error(f, ok)
	if ok {
		t.Error(f.Next().Value)
	}

	f, ok = avl.Floor(-1)
	t.Error(f, ok)
	if ok {
		t.Error(f.Next().Value)
	}

	root := avl.Root
	for root != nil {
		root = root.Next()
	}

	root = avl.Root
	for root != nil {
		root = root.Prev()
	}
}

func BenchmarkAVL(b *testing.B) {
	avl := NewWithIntComparator()
	b.N = 1000000

	b.StartTimer()
	for i := 0; i < b.N; i++ {
		v := randomdata.Number(0, 100000000)
		avl.Put(v)
	}

	for i := 0; i < b.N; i++ {
		avl.Find(i)
	}

	b.StopTimer()
}

func TestHeap(t *testing.T) {

	heap := binaryheap.NewWithIntComparator()

	for i := 0; i < 10; i++ {
		heap.Push(randomdata.Number(0, 1000))
	}

	t.Error(heap.Peek())
	t.Error(heap.Values())

	utils.Sort(heap.Values(), utils.IntComparator)

}

func BenchmarkList_InsertValues123(b *testing.B) {
	a := func(v1, v2 interface{}) int {
		if v1.(int) > v2.(int) {
			return -1
		}
		return 1
	}

	h := binaryheap.NewWith(a)

	TOPK := 50

	for i := 0; i < TOPK*1000; i++ {
		h.Push(i)
	}

	b.StartTimer()
	for i := 0; i < b.N; i++ {
		h.Push(i)
		l := []interface{}{}
		for n := 0; n < TOPK; n++ {
			v, _ := h.Pop()
			l = append(l, v)
		}

		for _, v := range l {
			h.Push(v)
		}
	}
	b.StopTimer()
}