mirror of
https://github.com/featurebasedb/featurebase.git
synced 2026-10-10 12:57:54 +00:00
Merge pull request #4 from benbjohnson/tests
Convert tests to standard library testing.
This commit is contained in:
Ben Johnson
commit
ad0b37d0f1
13 changed files with 532 additions and 485 deletions
|
|
@ -1,26 +0,0 @@
|
|||
package cruncher
|
||||
|
||||
import (
|
||||
"github.com/umbel/pilosa/core"
|
||||
"github.com/umbel/pilosa/dispatch"
|
||||
"github.com/umbel/pilosa/executor"
|
||||
"github.com/umbel/pilosa/transport"
|
||||
)
|
||||
|
||||
type Cruncher struct {
|
||||
*core.Service
|
||||
close_chan chan bool
|
||||
}
|
||||
|
||||
func (cruncher *Cruncher) Run() {
|
||||
cruncher.Service.Run()
|
||||
}
|
||||
|
||||
func NewCruncher() *Cruncher {
|
||||
service := core.NewService()
|
||||
cruncher := Cruncher{service, make(chan bool)}
|
||||
cruncher.Transport = transport.NewTcpTransport(service)
|
||||
cruncher.Dispatch = dispatch.NewDispatch(service)
|
||||
cruncher.Executor = executor.NewExecutor(service)
|
||||
return &cruncher
|
||||
}
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
package cruncher
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
. "github.com/smartystreets/goconvey/convey"
|
||||
)
|
||||
|
||||
func TestCruncher(t *testing.T) {
|
||||
Convey("Basic Cruncher Tests", t, func() {
|
||||
spew.Dump("cruncher test")
|
||||
})
|
||||
}
|
||||
|
|
@ -1,26 +1,17 @@
|
|||
package db
|
||||
package db_test
|
||||
|
||||
import (
|
||||
"log"
|
||||
"testing"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
. "github.com/smartystreets/goconvey/convey"
|
||||
"github.com/umbel/pilosa/db"
|
||||
"github.com/umbel/pilosa/util"
|
||||
)
|
||||
|
||||
func TestTopology(t *testing.T) {
|
||||
Convey("Basic DB structures", t, func() {
|
||||
log.Println("topology test")
|
||||
func TestCluster(t *testing.T) {
|
||||
c := db.NewCluster()
|
||||
d := c.GetOrCreateDatabase("main")
|
||||
|
||||
cluster := NewCluster()
|
||||
database := cluster.GetOrCreateDatabase("main")
|
||||
|
||||
frame := database.GetOrCreateFrame("general")
|
||||
slice := database.GetOrCreateSlice(0)
|
||||
|
||||
fragment_id := util.Id()
|
||||
spew.Dump(fragment_id)
|
||||
database.GetOrCreateFragment(frame, slice, fragment_id)
|
||||
})
|
||||
f := d.GetOrCreateFrame("general")
|
||||
sl := d.GetOrCreateSlice(0)
|
||||
d.GetOrCreateFragment(f, sl, util.Id())
|
||||
}
|
||||
|
|
|
|||
13
hold/hold.go
13
hold/hold.go
|
|
@ -23,6 +23,14 @@ type Holder struct {
|
|||
delchan chan delhold
|
||||
}
|
||||
|
||||
func NewHolder() *Holder {
|
||||
return &Holder{
|
||||
data: make(map[GUID]holdchan),
|
||||
getchan: make(chan gethold),
|
||||
delchan: make(chan delhold),
|
||||
}
|
||||
}
|
||||
|
||||
func (self *Holder) DelChan(id *GUID) {
|
||||
log.Trace("Holder.DelChan", id)
|
||||
req := delhold{id}
|
||||
|
|
@ -78,8 +86,3 @@ func (self *Holder) Run() {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
func NewHolder() *Holder {
|
||||
h := Holder{make(map[GUID]holdchan), make(chan gethold), make(chan delhold)}
|
||||
return &h
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,31 +1,41 @@
|
|||
package hold
|
||||
package hold_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
. "github.com/smartystreets/goconvey/convey"
|
||||
"github.com/umbel/pilosa/hold"
|
||||
"github.com/umbel/pilosa/util"
|
||||
)
|
||||
|
||||
func TestHoldChan(t *testing.T) {
|
||||
// Ensure hold can get a value that has been set.
|
||||
func TestHold_Get(t *testing.T) {
|
||||
h := hold.NewHolder()
|
||||
go h.Run()
|
||||
|
||||
Hold := Holder{make(map[util.GUID]holdchan), make(chan gethold), make(chan delhold)}
|
||||
go Hold.Run()
|
||||
|
||||
Convey("set then get", t, func() {
|
||||
id := util.RandomUUID()
|
||||
Hold.Set(&id, "derp", 10)
|
||||
derp, _ := Hold.Get(&id, 10)
|
||||
So(derp, ShouldEqual, "derp")
|
||||
})
|
||||
Convey("get then set", t, func() {
|
||||
id := util.RandomUUID()
|
||||
go func() {
|
||||
Hold.Set(&id, "derpsy", 10)
|
||||
}()
|
||||
time.Sleep(time.Second / 10)
|
||||
derp, _ := Hold.Get(&id, 10)
|
||||
So(derp, ShouldEqual, "derpsy")
|
||||
})
|
||||
id := util.RandomUUID()
|
||||
h.Set(&id, "derp", 10)
|
||||
if v, err := h.Get(&id, 10); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if v != "derp" {
|
||||
t.Fatalf("unexpected value: %v", v)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure hold can wait for a value that has not been set yet.
|
||||
func TestHold_Get_Delay(t *testing.T) {
|
||||
h := hold.NewHolder()
|
||||
go h.Run()
|
||||
|
||||
id := util.RandomUUID()
|
||||
go func() {
|
||||
time.Sleep(500 * time.Millisecond)
|
||||
h.Set(&id, "derpsy", 10)
|
||||
}()
|
||||
|
||||
if v, err := h.Get(&id, 10); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if v != "derpsy" {
|
||||
t.Fatalf("unexpected value: %v", v)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,6 +3,8 @@ package index
|
|||
import (
|
||||
"math/rand"
|
||||
"testing"
|
||||
|
||||
"github.com/umbel/pilosa/util"
|
||||
)
|
||||
|
||||
var (
|
||||
|
|
@ -12,17 +14,19 @@ var (
|
|||
)
|
||||
|
||||
func init() {
|
||||
println("GO")
|
||||
size = 1000
|
||||
|
||||
util.SetupStatsd()
|
||||
// SetupCassandra()
|
||||
|
||||
membrand = NewBrand("db", "frame", 0, NewMemoryStorage(), size, size, 0)
|
||||
for i := uint64(0); i < uint64(size); i++ {
|
||||
membrand.SetBit(i, 0, 1)
|
||||
}
|
||||
cassbrand = NewBrand("db", "frame", 0, NewCassStorage(), size, size, 0)
|
||||
for i := uint64(0); i < uint64(size); i++ {
|
||||
cassbrand.SetBit(i, 0, 1)
|
||||
}
|
||||
// cassbrand = NewBrand("db", "frame", 0, NewCassStorage(), size, size, 0)
|
||||
// for i := uint64(0); i < uint64(size); i++ {
|
||||
// cassbrand.SetBit(i, 0, 1)
|
||||
// }
|
||||
}
|
||||
|
||||
func benchmarkBrand(b *testing.B, size int, fill int, brand *Brand) {
|
||||
|
|
|
|||
|
|
@ -1,158 +1,295 @@
|
|||
package index
|
||||
package index_test
|
||||
|
||||
/*
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/umbel/pilosa/index"
|
||||
"github.com/umbel/pilosa/util"
|
||||
)
|
||||
|
||||
func TestFragment(t *testing.T) {
|
||||
general := util.Hex_to_SUUID("1")
|
||||
brand := util.Hex_to_SUUID("2")
|
||||
dummy := NewFragmentContainer()
|
||||
dummy.AddFragment("25", "general", 0, general)
|
||||
dummy.AddFragment("25", "b.n", 0, brand)
|
||||
|
||||
Convey("Get ", t, func() {
|
||||
bh, _ := dummy.Get(general, 1234)
|
||||
So(bh, ShouldNotEqual, 0)
|
||||
})
|
||||
|
||||
Convey("SetBit/Count 1 1", t, func() {
|
||||
bi1 := uint64(1234)
|
||||
changed, _ := dummy.SetBit(general, bi1, 1, 0)
|
||||
So(changed, ShouldEqual, true)
|
||||
changed, _ = dummy.SetBit(general, bi1, 1, 0)
|
||||
So(changed, ShouldEqual, false)
|
||||
bh, _ := dummy.Get(general, bi1)
|
||||
num, _ := dummy.Count(general, bh)
|
||||
So(num, ShouldEqual, 1)
|
||||
})
|
||||
|
||||
Convey("Union/Intersect/Difference", t, func() {
|
||||
bi1 := uint64(1234)
|
||||
bi2 := uint64(4321)
|
||||
|
||||
dummy.SetBit(general, bi2, 65537, 0) //set_bit creates the bitmap
|
||||
|
||||
bh1, _ := dummy.Get(general, bi1)
|
||||
bh2, _ := dummy.Get(general, bi2)
|
||||
|
||||
handles := []BitmapHandle{bh1, bh2}
|
||||
result, _ := dummy.Union(general, handles)
|
||||
|
||||
num, _ := dummy.Count(general, result)
|
||||
So(num, ShouldEqual, 2)
|
||||
result, _ = dummy.Intersect(general, handles)
|
||||
|
||||
num, _ = dummy.Count(general, result)
|
||||
So(num, ShouldEqual, 0)
|
||||
|
||||
result, _ = dummy.Difference(general, handles)
|
||||
num, _ = dummy.Count(general, result)
|
||||
So(num, ShouldEqual, 1)
|
||||
|
||||
})
|
||||
Convey("Union Empty", t, func() {
|
||||
|
||||
bi1 := uint64(1234)
|
||||
bh1, _ := dummy.Get(general, bi1)
|
||||
bh2, _ := dummy.Empty(general) //set_bit creates the bitmap
|
||||
|
||||
handles := []BitmapHandle{bh1, bh2}
|
||||
result, _ := dummy.Union(general, handles)
|
||||
|
||||
num, _ := dummy.Count(general, result)
|
||||
|
||||
So(num, ShouldEqual, 1)
|
||||
})
|
||||
Convey("Bytes", t, func() {
|
||||
bi1 := uint64(1234)
|
||||
bh1, _ := dummy.Get(general, bi1)
|
||||
before, _ := dummy.Count(general, bh1)
|
||||
|
||||
bytes, _ := dummy.GetBytes(general, bh1)
|
||||
bh2, _ := dummy.FromBytes(general, bytes)
|
||||
|
||||
after, _ := dummy.Count(general, bh2)
|
||||
So(before, ShouldEqual, after)
|
||||
})
|
||||
Convey("Empty ", t, func() {
|
||||
bh, _ := dummy.Empty(general)
|
||||
before, _ := dummy.Count(general, bh)
|
||||
So(before, ShouldEqual, 0)
|
||||
})
|
||||
|
||||
Convey("GetList ", t, func() {
|
||||
bhs, _ := dummy.GetList(general, []uint64{1234, 4321, 789})
|
||||
result, _ := dummy.Union(general, bhs)
|
||||
num, _ := dummy.Count(general, result)
|
||||
So(num, ShouldEqual, 2)
|
||||
})
|
||||
|
||||
Convey("Brand SetBit Small", t, func() {
|
||||
bi1 := uint64(1029)
|
||||
for x := uint64(0); x < 1000; x++ {
|
||||
dummy.SetBit(brand, bi1, x, 0)
|
||||
}
|
||||
So(1, ShouldEqual, 1)
|
||||
})
|
||||
|
||||
// Convey("Brand SetBit Big", t, func() {
|
||||
// bi1 := uint64(1231)
|
||||
// bi2 := uint64(1232)
|
||||
// bi3 := uint64(1233)
|
||||
// bi4 := uint64(1234)
|
||||
// for x := uint64(0); x < 60000; x++ {
|
||||
// if x < 100 {
|
||||
// dummy.SetBit(brand, bi1, x)
|
||||
// dummy.SetBit(brand, bi4, x)
|
||||
// }
|
||||
// if x < 500 {
|
||||
// dummy.SetBit(brand, bi2, x)
|
||||
// }
|
||||
// if x%3 == 0 && x < 1000 {
|
||||
// dummy.SetBit(brand, bi3, x)
|
||||
// }
|
||||
// if x > 700 && x < 1000 {
|
||||
// dummy.SetBit(brand, bi4, x)
|
||||
// }
|
||||
// if x > 1000 {
|
||||
// dummy.SetBit(brand, x, x)
|
||||
// }
|
||||
// }
|
||||
// bh1, _ := dummy.Get(brand, bi1)
|
||||
// // dummy.Rank()
|
||||
// log.Println(dummy.TopN(brand, bh1, 4))
|
||||
// log.Println(dummy.Stats(brand))
|
||||
// So(1, ShouldEqual, 1)
|
||||
// })
|
||||
|
||||
Convey("Brand TopN", t, func() {
|
||||
dummy.SetBit(brand, uint64(1), 1, 2)
|
||||
dummy.SetBit(brand, uint64(1), 2, 2)
|
||||
dummy.SetBit(brand, uint64(1), 3, 2)
|
||||
dummy.SetBit(brand, uint64(2), 1, 2)
|
||||
dummy.SetBit(brand, uint64(2), 2, 2)
|
||||
dummy.SetBit(brand, uint64(3), 1, 2)
|
||||
bh1, _ := dummy.Get(brand, uint64(1))
|
||||
c := []uint64{2}
|
||||
results, _ := dummy.TopN(brand, bh1, 4, c)
|
||||
pair := results[0]
|
||||
So(pair.Key, ShouldEqual, 1)
|
||||
So(pair.Count, ShouldEqual, 3)
|
||||
})
|
||||
Convey("Clear ", t, func() {
|
||||
res, _ := dummy.Clear(general)
|
||||
So(res, ShouldEqual, true)
|
||||
})
|
||||
Convey("store ", t, func() {
|
||||
b := uint64(1029)
|
||||
compressed := "H4sIAAAJbogA/2JmYWBR+9/IzMjI6pxRmpfN+L+JgZGJkdk7tZKRjYGRNSwxpzSV8X8LAwOD8v9moDIup5z85GzHoqLESpAwI1AjWITxfxtQjdj/ViZGRo7o2NLMvBIzE5Ag0BiGf4zq/5uYGBV+/IeCUQZWBiikNP83AQN1NKwIMRgYAAAAAP//AQAA//9U05AivAIAAA=="
|
||||
dummy.LoadBitmap(brand, b, compressed, 0)
|
||||
bh1, _ := dummy.Get(brand, b)
|
||||
before, _ := dummy.Count(brand, bh1)
|
||||
So(4096, ShouldEqual, before)
|
||||
})
|
||||
|
||||
func init() {
|
||||
index.Backend = "memory"
|
||||
}
|
||||
|
||||
// Ensure a fragment can be retrieved from the container.
|
||||
func TestFragmentContainer_Get(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "general", 0, 1)
|
||||
fc.MustClear(1)
|
||||
|
||||
if bh, err := fc.Get(util.SUUID(1), 1234); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if bh == 0 {
|
||||
t.Fatal("expected non-zero bitmap handle")
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure a bit can be set on a bitmap.
|
||||
func TestFragmentContainer_SetBit(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "general", 0, 1)
|
||||
fc.MustClear(1)
|
||||
|
||||
// Set a bit on the bitmap.
|
||||
if changed, err := fc.SetBit(1, uint64(1234), 1, 0); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if changed == false {
|
||||
t.Fatal("expected change")
|
||||
}
|
||||
|
||||
// Set the same bit on the bitmap. No change should be indicated.
|
||||
if changed, err := fc.SetBit(1, uint64(1234), 1, 0); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if changed == true {
|
||||
t.Fatal("expected no change")
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure the number of bits on a bitmap can be counted.
|
||||
func TestFragmentContainer_Count(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "general", 0, util.SUUID(1))
|
||||
|
||||
// Set a bit on the bitmap.
|
||||
bi1 := uint64(1234)
|
||||
if changed, err := fc.SetBit(util.SUUID(1), bi1, 1, 0); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if changed == false {
|
||||
t.Fatal("expected change")
|
||||
}
|
||||
|
||||
// Verify that one bit is set.
|
||||
if bh, err := fc.Get(util.SUUID(1), bi1); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if n, err := fc.Count(util.SUUID(1), bh); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if n != 1 {
|
||||
t.Fatal("unexpected count: %d", n)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure the bits in two bitmaps can be unioned.
|
||||
func TestFragmentContainer_Union(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "general", 0, 1)
|
||||
fc.MustSetBit(1, 1234, 1, 0)
|
||||
fc.MustSetBit(1, 4321, 65537, 0)
|
||||
|
||||
// Union the handles together.
|
||||
if result, err := fc.Union(1, []index.BitmapHandle{fc.MustGet(1, 1234), fc.MustGet(1, 4321)}); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if n := fc.MustCount(1, result); n != 2 {
|
||||
t.Fatalf("unexpected union bit count: %d", n)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure unioning a bitmap with an empty bitmap returns a single bit count.
|
||||
func TestFragmentContainer_Union_Empty(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "general", 0, 1)
|
||||
fc.MustSetBit(1, 1234, 1, 0)
|
||||
|
||||
// Union the handles together.
|
||||
if result, err := fc.Union(1, []index.BitmapHandle{fc.MustGet(1, 1234), fc.MustGet(1, 4321)}); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if n := fc.MustCount(1, result); n != 1 {
|
||||
t.Fatalf("unexpected empty union bit count: %d", n)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure the bits in two bitmaps can be intersected.
|
||||
func TestFragmentContainer_Intersect(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "general", 0, 1)
|
||||
fc.MustSetBit(1, 1234, 1, 0)
|
||||
fc.MustSetBit(1, 4321, 65537, 0)
|
||||
|
||||
// Intersect the handles together.
|
||||
if result, err := fc.Intersect(1, []index.BitmapHandle{fc.MustGet(1, 1234), fc.MustGet(1, 4321)}); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if n := fc.MustCount(1, result); n != 0 {
|
||||
t.Fatal("unexpected intersect bit count: %d", n)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure the bits in two bitmaps can be diffed.
|
||||
func TestFragmentContainer_Difference(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "general", 0, 1)
|
||||
fc.MustSetBit(1, 1234, 1, 0)
|
||||
fc.MustSetBit(1, 4321, 65537, 0)
|
||||
|
||||
// Compute the difference between the handles.
|
||||
if result, err := fc.Difference(1, []index.BitmapHandle{fc.MustGet(1, 1234), fc.MustGet(1, 4321)}); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if n := fc.MustCount(1, result); n != 1 {
|
||||
t.Fatalf("unexpected difference bit count: %d", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure bitmaps can be marshaled and unmarshaled to bytes.
|
||||
func TestFragmentContainer_Bytes(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "general", 0, 1)
|
||||
fc.MustSetBit(1, 1234, 1, 0)
|
||||
|
||||
// Count bits and marshal to bytes.
|
||||
beforeN := fc.MustCount(1, 1234)
|
||||
buf, err := fc.GetBytes(1, 1234)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Marshal bytes back to a bitmap and re-count.
|
||||
bh2, err := fc.FromBytes(1, buf)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
afterN := fc.MustCount(1, bh2)
|
||||
|
||||
// Ensure the original bit count matches the new bitmap's bit count.
|
||||
if beforeN != afterN {
|
||||
t.Fatalf("unexpected bit count: before=%d, after=%d", beforeN, afterN)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure an empty bitmap can be returned.
|
||||
func TestFragmentContainer_Empty(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "general", 0, 1)
|
||||
bh, err := fc.Empty(1)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
} else if n := fc.MustCount(1, bh); n != 0 {
|
||||
t.Fatalf("unexpected bit count: %d", n)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure a list of bitmap handles can be returned.
|
||||
func TestFragmentContainer_GetList(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "general", 0, 1)
|
||||
fc.MustSetBit(1, 1234, 1, 0)
|
||||
fc.MustSetBit(1, 4321, 65537, 0)
|
||||
|
||||
a, err := fc.GetList(1, []uint64{1234, 4321, 789})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
// Compute the union to ensure they're the correct bitmaps.
|
||||
if res, err := fc.Union(1, a); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if n := fc.MustCount(1, res); n != 2 {
|
||||
t.Fatalf("unexpected bit count: %d", n)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure brand bitmaps can perform a small number of set bits.
|
||||
func TestFragmentContainer_SetBit_Brand_Small(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "b.n", 0, 2)
|
||||
for i := uint64(0); i < 1000; i++ {
|
||||
fc.SetBit(2, 1029, i, 0)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure the top n can be computed for a brand.
|
||||
func TestFragmentContainer_TopN_Brand(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "b.n", 0, 2)
|
||||
|
||||
// Set bits on the bitmap.
|
||||
fc.MustSetBit(2, uint64(1), 1, 2)
|
||||
fc.MustSetBit(2, uint64(1), 2, 2)
|
||||
fc.MustSetBit(2, uint64(1), 3, 2)
|
||||
fc.MustSetBit(2, uint64(2), 1, 2)
|
||||
fc.MustSetBit(2, uint64(2), 2, 2)
|
||||
fc.MustSetBit(2, uint64(3), 1, 2)
|
||||
|
||||
// Retrieve the bitmap handle for bitmap 1.
|
||||
bh := fc.MustGet(2, uint64(1))
|
||||
|
||||
// Compute the top-n.
|
||||
if results, err := fc.TopN(2, bh, 4, []uint64{2}); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if results[0].Key != 1 {
|
||||
t.Fatalf("unexpected key: %d", results[0].Key)
|
||||
} else if results[0].Count != 3 {
|
||||
t.Fatalf("unexpected value: %d", results[0].Count)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure a fragment can be cleared.
|
||||
func TestFragmentContainer_Clear(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "general", 0, 1)
|
||||
|
||||
// Compute the top-n.
|
||||
if res, err := fc.Clear(1); err != nil {
|
||||
t.Fatal(err)
|
||||
} else if res != true {
|
||||
t.Fatalf("unexpected result: %v", res)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure a fragment can be loaded from a compressed form.
|
||||
func TestFragmentContainer_LoadBitmap(t *testing.T) {
|
||||
fc := NewFragmentContainer()
|
||||
fc.AddFragment("25", "b.n", 0, 2)
|
||||
|
||||
// Load a bitmap from compressed data.
|
||||
buf := "H4sIAAAJbogA/2JmYWBR+9/IzMjI6pxRmpfN+L+JgZGJkdk7tZKRjYGRNSwxpzSV8X8LAwOD8v9moDIup5z85GzHoqLESpAwI1AjWITxfxtQjdj/ViZGRo7o2NLMvBIzE5Ag0BiGf4zq/5uYGBV+/IeCUQZWBiikNP83AQN1NKwIMRgYAAAAAP//AQAA//9U05AivAIAAA=="
|
||||
fc.LoadBitmap(2, 1029, buf, 0)
|
||||
|
||||
// Load and count bits.
|
||||
if n := fc.MustCount(2, fc.MustGet(2, 1029)); n != 4096 {
|
||||
t.Fatalf("unexpected bit count: %d", n)
|
||||
}
|
||||
}
|
||||
|
||||
// FragementContainer is a test wrapper for index.FragmentContainer.
|
||||
type FragmentContainer struct {
|
||||
*index.FragmentContainer
|
||||
}
|
||||
|
||||
// NewFragmentContainer returns a new instance of FragmentContainer.
|
||||
func NewFragmentContainer() *FragmentContainer {
|
||||
return &FragmentContainer{index.NewFragmentContainer()}
|
||||
}
|
||||
|
||||
// MustGet retrieves a bitmap by id. Panic on error.
|
||||
func (fc *FragmentContainer) MustGet(frag_id util.SUUID, bitmap_id uint64) index.BitmapHandle {
|
||||
bh, err := fc.Get(frag_id, bitmap_id)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return bh
|
||||
}
|
||||
|
||||
// MustSetBit sets a bit in a bitmap. Panic on error.
|
||||
func (fc *FragmentContainer) MustSetBit(frag_id util.SUUID, bitmap_id uint64, pos uint64, category uint64) bool {
|
||||
changed, err := fc.SetBit(frag_id, bitmap_id, pos, category)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return changed
|
||||
}
|
||||
|
||||
// MustClear clears a fragment. Panic on error.
|
||||
func (fc *FragmentContainer) MustClear(fragmentID util.SUUID) bool {
|
||||
v, err := fc.Clear(fragmentID)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// MustCount returns the number of set bits in a bitmap. Panic on error.
|
||||
func (fc *FragmentContainer) MustCount(frag_id util.SUUID, bitmap index.BitmapHandle) uint64 {
|
||||
v, err := fc.Count(frag_id, bitmap)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return v
|
||||
}
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -55,12 +55,12 @@ func SetupCassandra() {
|
|||
|
||||
func BuildSchema() {
|
||||
/*
|
||||
"CREATE KEYSPACE IF NOT EXISTS pilosa WITH strategy_class = SimpleStrategy AND strategy_options:replication_factor = 1"
|
||||
create keyspace if not exists pilosa with replication = {'class': 'SimpleStrategy', 'replication_factor' : 1} and durable_writes = true;
|
||||
CREATE KEYSPACE pilosa WITH replication = {'class': 'NetworkTopologyStrategy', 'pilpang': '2'} AND durable_writes = true;
|
||||
"CREATE KEYSPACE IF NOT EXISTS pilosa WITH strategy_class = SimpleStrategy AND strategy_options:replication_factor = 1"
|
||||
create keyspace if not exists pilosa with replication = {'class': 'SimpleStrategy', 'replication_factor' : 1} and durable_writes = true;
|
||||
CREATE KEYSPACE pilosa WITH replication = {'class': 'NetworkTopologyStrategy', 'pilpang': '2'} AND durable_writes = true;
|
||||
|
||||
CREATE TABLE IF NOT EXISTS bitmap (bitmap_id bigint, db varchar, frame varchar, slice int, filter int, chunkkey bigint, blockindex int, block bigint, PRIMARY KEY ((bitmap_id, db, frame, slice), chunkkey, blockindex) )
|
||||
"
|
||||
CREATE TABLE IF NOT EXISTS bitmap (bitmap_id bigint, db varchar, frame varchar, slice int, filter int, chunkkey bigint, blockindex int, block bigint, PRIMARY KEY ((bitmap_id, db, frame, slice), chunkkey, blockindex) )
|
||||
"
|
||||
*/
|
||||
|
||||
}
|
||||
|
|
@ -136,7 +136,7 @@ func (self *CassandraStorage) runBatch(batch *gocql.Batch) {
|
|||
if batch != nil {
|
||||
err := self.db.ExecuteBatch(batch)
|
||||
if err != nil {
|
||||
log.Warn("Batch ERROR", err)
|
||||
log.Warn("Batch ERROR: ", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,16 +15,15 @@ func NewMemoryStorage() Storage {
|
|||
return obj
|
||||
}
|
||||
|
||||
func (c *MemoryStorage) BeginBatch() {
|
||||
}
|
||||
func (c *MemoryStorage) Close() {
|
||||
}
|
||||
func (c *MemoryStorage) EndBatch() {
|
||||
}
|
||||
func (c *MemoryStorage) FlushBatch() {
|
||||
}
|
||||
func (c *MemoryStorage) Fetch(bitmap_id uint64, db string, frame string, slice int) (IBitmap, uint64) {
|
||||
func (c *MemoryStorage) BeginBatch() {}
|
||||
|
||||
func (c *MemoryStorage) Close() {}
|
||||
|
||||
func (c *MemoryStorage) EndBatch() {}
|
||||
|
||||
func (c *MemoryStorage) FlushBatch() {}
|
||||
|
||||
func (c *MemoryStorage) Fetch(bitmap_id uint64, db string, frame string, slice int) (IBitmap, uint64) {
|
||||
key := fmt.Sprintf("%d:%s:%s:%d", bitmap_id, db, frame, slice)
|
||||
bitmap, found := c.db[key]
|
||||
if !found {
|
||||
|
|
@ -41,11 +40,12 @@ func (c *MemoryStorage) Store(bitmap_id uint64, db string, frame string, slice i
|
|||
|
||||
func (c *MemoryStorage) StoreBlock(bitmap_id uint64, db string, frame string, slice int, filter uint64, chunk_key uint64, block_index int32, block uint64) error {
|
||||
//only use the cache and throw away everything
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (self *MemoryStorage) StoreBit(bid uint64, db string, frame string, slice int, filter uint64, bchunk uint64, block_index int32, bblock, count uint64) {
|
||||
}
|
||||
|
||||
func (self *MemoryStorage) RemoveBit(id uint64, db string, frame string, slice int, filter uint64, chunk uint64, block_index int32, count uint64) {
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -20,19 +20,6 @@ func TestStorage(t *testing.T) {
|
|||
filter := 10
|
||||
bitmap_id := uint64(999999)
|
||||
|
||||
// Convey("KV ", t, func() {
|
||||
// storage, _ := NewKVStorage("/tmp/", 0, db)
|
||||
// bm := storage.Fetch(bitmap_id, db, slice)
|
||||
// SetBit(bm, 0)
|
||||
// SetBit(bm, 1)
|
||||
// SetBit(bm, 2)
|
||||
// storage.Store(int64(bitmap_id), db, frame, slice, filter, bm.(*Bitmap))
|
||||
// bm2, _ := storage.Fetch(bitmap_id, db, slice)
|
||||
// So(BitCount(bm), ShouldEqual, BitCount(bm2))
|
||||
// So(BitCount(bm), ShouldEqual, bm.Count())
|
||||
// So(BitCount(bm), ShouldEqual, 3)
|
||||
// })
|
||||
|
||||
c, err := net.DialTimeout("tcp", "127.0.0.1:9042", 100*time.Millisecond)
|
||||
if err != nil {
|
||||
fmt.Println("NO cassandra. Skipping test.")
|
||||
|
|
|
|||
|
|
@ -1,133 +1,134 @@
|
|||
package index
|
||||
package index_test
|
||||
|
||||
/*
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/davecgh/go-spew/spew"
|
||||
. "github.com/smartystreets/goconvey/convey"
|
||||
"github.com/umbel/pilosa/index"
|
||||
)
|
||||
|
||||
func getTime(id uint64, s string) {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, s)
|
||||
log.Println("BEFORE")
|
||||
|
||||
for i, v := range GetTimeIds(uint64(id), t1, YMDH) {
|
||||
log.Println(i, v, s)
|
||||
func TestGetRange_1h_0(t *testing.T) {
|
||||
if m := index.GetRange(
|
||||
MustParseTime("2014-08-11 14:00"),
|
||||
MustParseTime("2014-08-11 16:00"),
|
||||
uint64(1),
|
||||
); len(m) != 2 {
|
||||
t.Fatalf("unexpected range len: %d", len(m))
|
||||
}
|
||||
log.Println("AFTER")
|
||||
}
|
||||
func TestDemo(t *testing.T) {
|
||||
Convey("Test ID", t, func() {
|
||||
getTime(uint64(1), "2014-08-11 14:00")
|
||||
So(1, ShouldEqual, 1)
|
||||
})
|
||||
}
|
||||
func TestTimeFrame(t *testing.T) {
|
||||
Convey("Test 1H", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, "2014-08-11 14:00")
|
||||
t2, _ := time.Parse(shortForm, "2014-08-11 16:00")
|
||||
m := GetRange(t1, t2, uint64(1))
|
||||
getTime(uint64(1), "2014-08-11 14:00")
|
||||
spew.Dump(m)
|
||||
|
||||
So(len(m), ShouldEqual, 2)
|
||||
})
|
||||
if true {
|
||||
return
|
||||
func TestGetRange_1h_1(t *testing.T) {
|
||||
if m := index.GetRange(
|
||||
MustParseTime("2014-01-02 10:03"),
|
||||
MustParseTime("2014-01-02 11:03"),
|
||||
uint64(1),
|
||||
); len(m) != 1 {
|
||||
t.Fatalf("unexpected range len: %d", len(m))
|
||||
}
|
||||
|
||||
Convey("Test ID", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
x, _ := time.Parse(shortForm, "1970-01-01 00:00:00")
|
||||
fmt.Println(x)
|
||||
|
||||
m := GetTimeIds(uint64(15027), x, YMD)
|
||||
spew.Dump(m)
|
||||
fmt.Println("OK")
|
||||
So(1, ShouldEqual, 1)
|
||||
})
|
||||
Convey("Test 1H", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, "2014-01-02 10:03")
|
||||
t2, _ := time.Parse(shortForm, "2014-01-02 11:03")
|
||||
m := GetRange(t1, t2, uint64(1))
|
||||
So(len(m), ShouldEqual, 1)
|
||||
})
|
||||
Convey("Test 2H", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, "2014-01-02 10:03")
|
||||
t2, _ := time.Parse(shortForm, "2014-01-02 12:03")
|
||||
m := GetRange(t1, t2, uint64(1))
|
||||
So(len(m), ShouldEqual, 2)
|
||||
})
|
||||
|
||||
Convey("Test 24H", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, "2014-01-02 12:03")
|
||||
t2, _ := time.Parse(shortForm, "2014-01-03 12:03")
|
||||
m := GetRange(t1, t2, uint64(1))
|
||||
So(len(m), ShouldEqual, 24)
|
||||
})
|
||||
Convey("Test 1D", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, "2014-01-02 00:00")
|
||||
t2, _ := time.Parse(shortForm, "2014-01-03 00:00")
|
||||
m := GetRange(t1, t2, uint64(1))
|
||||
So(len(m), ShouldEqual, 1)
|
||||
})
|
||||
|
||||
Convey("Test 1D1H", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, "2014-01-02 00:00")
|
||||
t2, _ := time.Parse(shortForm, "2014-01-03 01:00")
|
||||
m := GetRange(t1, t2, uint64(1))
|
||||
So(len(m), ShouldEqual, 2)
|
||||
})
|
||||
|
||||
Convey("Test 1H1D", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, "2014-01-02 23:00")
|
||||
t2, _ := time.Parse(shortForm, "2014-01-04 00:00")
|
||||
m := GetRange(t1, t2, uint64(1))
|
||||
So(len(m), ShouldEqual, 2)
|
||||
})
|
||||
|
||||
Convey("Test 1H1D1H", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, "2014-01-02 23:00")
|
||||
t2, _ := time.Parse(shortForm, "2014-01-04 01:00")
|
||||
m := GetRange(t1, t2, uint64(1))
|
||||
So(len(m), ShouldEqual, 3)
|
||||
})
|
||||
|
||||
Convey("Test 1Y", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, "2014-01-01 00:00")
|
||||
t2, _ := time.Parse(shortForm, "2015-01-01 00:00")
|
||||
m := GetRange(t1, t2, uint64(1))
|
||||
So(len(m), ShouldEqual, 1)
|
||||
})
|
||||
Convey("Test 1H1D1M", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, "2014-01-30 23:00")
|
||||
t2, _ := time.Parse(shortForm, "2014-03-01 00:00")
|
||||
m := GetRange(t1, t2, uint64(1))
|
||||
So(len(m), ShouldEqual, 3)
|
||||
})
|
||||
|
||||
Convey("Test 1H1D1MD1H1", t, func() {
|
||||
const shortForm = "2006-01-02 15:04"
|
||||
t1, _ := time.Parse(shortForm, "2014-01-30 23:00")
|
||||
t2, _ := time.Parse(shortForm, "2014-03-02 01:00")
|
||||
m := GetRange(t1, t2, uint64(1))
|
||||
So(len(m), ShouldEqual, 5)
|
||||
})
|
||||
|
||||
}
|
||||
*/
|
||||
|
||||
func TestGetRange_2h(t *testing.T) {
|
||||
if m := index.GetRange(
|
||||
MustParseTime("2014-01-02 10:03"),
|
||||
MustParseTime("2014-01-02 12:03"),
|
||||
uint64(1),
|
||||
); len(m) != 2 {
|
||||
t.Fatalf("unexpected range len: %d", len(m))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetRange_24h(t *testing.T) {
|
||||
if m := index.GetRange(
|
||||
MustParseTime("2014-01-02 12:03"),
|
||||
MustParseTime("2014-01-03 12:03"),
|
||||
uint64(1),
|
||||
); len(m) != 24 {
|
||||
t.Fatalf("unexpected range len: %d", len(m))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetRange_1d(t *testing.T) {
|
||||
if m := index.GetRange(
|
||||
MustParseTime("2014-01-02 00:00"),
|
||||
MustParseTime("2014-01-03 00:00"),
|
||||
uint64(1),
|
||||
); len(m) != 1 {
|
||||
t.Fatalf("unexpected range len: %d", len(m))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetRange_1d1h(t *testing.T) {
|
||||
if m := index.GetRange(
|
||||
MustParseTime("2014-01-02 00:00"),
|
||||
MustParseTime("2014-01-03 01:00"),
|
||||
uint64(1),
|
||||
); len(m) != 2 {
|
||||
t.Fatalf("unexpected range len: %d", len(m))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetRange_1h1d(t *testing.T) {
|
||||
if m := index.GetRange(
|
||||
MustParseTime("2014-01-02 23:00"),
|
||||
MustParseTime("2014-01-04 00:00"),
|
||||
uint64(1),
|
||||
); len(m) != 2 {
|
||||
t.Fatalf("unexpected range len: %d", len(m))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetRange_1h1d1h(t *testing.T) {
|
||||
if m := index.GetRange(
|
||||
MustParseTime("2014-01-02 23:00"),
|
||||
MustParseTime("2014-01-04 01:00"),
|
||||
uint64(1),
|
||||
); len(m) != 3 {
|
||||
t.Fatalf("unexpected range len: %d", len(m))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetRange_1y(t *testing.T) {
|
||||
if m := index.GetRange(
|
||||
MustParseTime("2014-01-01 00:00"),
|
||||
MustParseTime("2015-01-01 00:00"),
|
||||
uint64(1),
|
||||
); len(m) != 1 {
|
||||
t.Fatalf("unexpected range len: %d", len(m))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetRange_1h1d1m(t *testing.T) {
|
||||
if m := index.GetRange(
|
||||
MustParseTime("2014-01-30 23:00"),
|
||||
MustParseTime("2014-03-01 00:00"),
|
||||
uint64(1),
|
||||
); len(m) != 3 {
|
||||
t.Fatalf("unexpected range len: %d", len(m))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetRange_1h1d1m1d1h(t *testing.T) {
|
||||
if m := index.GetRange(
|
||||
MustParseTime("2014-01-30 23:00"),
|
||||
MustParseTime("2014-03-02 01:00"),
|
||||
uint64(1),
|
||||
); len(m) != 5 {
|
||||
t.Fatalf("unexpected range len: %d", len(m))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetTimeIds(t *testing.T) {
|
||||
_ = index.GetTimeIds(uint64(15027), MustParseTime("1970-01-01 00:00"), index.YMD)
|
||||
}
|
||||
|
||||
// DefaultTimeLayout is the time layout used by the tests.
|
||||
const DefaultTimeLayout = "2006-01-02 15:04"
|
||||
|
||||
// MustParseTime parses value using DefaultTimeLayout. Panic on error.
|
||||
func MustParseTime(value string) time.Time {
|
||||
v, err := time.Parse(DefaultTimeLayout, value)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
|
|
|||
49
util/id_test.go
Normal file
49
util/id_test.go
Normal file
|
|
@ -0,0 +1,49 @@
|
|||
package util
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// Ensure id can be parsed from string.
|
||||
func TestId_Small(t *testing.T) {
|
||||
if v := Hex_to_SUUID("1"); v != 1 {
|
||||
t.Fatalf("unexpected SUUID: %v", v)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure generated IDs are unique.
|
||||
func TestId_Unique(t *testing.T) {
|
||||
a, b := Id(), Id()
|
||||
if a == b {
|
||||
t.Fatalf("ids should be unique: %v != %v", a, b)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure ids can be converted to and from hex.
|
||||
func TestId_Hex(t *testing.T) {
|
||||
a := Id()
|
||||
b := Hex_to_SUUID(SUUID_to_Hex(a))
|
||||
if a != b {
|
||||
t.Fatalf("ids not equal: %v != %v", a, b)
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure ids can be generated in sequence.
|
||||
func TestId_Multiple(t *testing.T) {
|
||||
for i := 0; i < 10; i++ {
|
||||
println(SUUID_to_Hex(Id()))
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure a random UUID can be converted to a string.
|
||||
func TestRandomUUID_String(t *testing.T) {
|
||||
fmt.Println(RandomUUID().String())
|
||||
}
|
||||
|
||||
func BenchmarkId(b *testing.B) {
|
||||
// run the Fib function b.N times
|
||||
for n := 0; n < b.N; n++ {
|
||||
Id()
|
||||
}
|
||||
}
|
||||
|
|
@ -1,95 +0,0 @@
|
|||
package util
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"github.com/gocql/gocql"
|
||||
. "github.com/smartystreets/goconvey/convey"
|
||||
)
|
||||
|
||||
/*
|
||||
var (
|
||||
array [1000000]int
|
||||
muid = make(map[SUUID]int)
|
||||
muuid = make(map[*GUID]int)
|
||||
r int
|
||||
)
|
||||
|
||||
func init() {
|
||||
for i, _ := range array {
|
||||
muid[Id()] = i
|
||||
id := util.RandomUUID()
|
||||
muuid[&id] = i
|
||||
}
|
||||
|
||||
}
|
||||
*/
|
||||
func TestId(t *testing.T) {
|
||||
Convey("Test Small", t, func() {
|
||||
s := "1"
|
||||
//s := "0000000000000001"
|
||||
//s := "000000000000001"
|
||||
b2 := Hex_to_SUUID(s)
|
||||
So(1, ShouldEqual, b2)
|
||||
})
|
||||
Convey("Basic Usage", t, func() {
|
||||
bc1 := Id()
|
||||
println(SUUID_to_Hex(bc1))
|
||||
println(SUUID_to_Hex(bc1))
|
||||
bc2 := Id()
|
||||
println(SUUID_to_Hex(bc2))
|
||||
So(bc1, ShouldNotEqual, bc2)
|
||||
})
|
||||
Convey("Hex Encoded Usage", t, func() {
|
||||
b1 := Id()
|
||||
s := SUUID_to_Hex(b1)
|
||||
b2 := Hex_to_SUUID(s)
|
||||
So(b1, ShouldEqual, b2)
|
||||
})
|
||||
Convey("Gen 10", t, func() {
|
||||
for i := 0; i < 10; i++ {
|
||||
bc1 := Id()
|
||||
println(SUUID_to_Hex(bc1))
|
||||
}
|
||||
So(1, ShouldEqual, 1)
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
func BenchmarkId(b *testing.B) {
|
||||
// run the Fib function b.N times
|
||||
for n := 0; n < b.N; n++ {
|
||||
Id()
|
||||
}
|
||||
}
|
||||
|
||||
func BenchmarkUUID(b *testing.B) {
|
||||
// run the Fib function b.N times
|
||||
for n := 0; n < b.N; n++ {
|
||||
gocql.RandomUUID()
|
||||
}
|
||||
}
|
||||
func TestGUID(t *testing.T) {
|
||||
fmt.Println(RandomUUID().String())
|
||||
|
||||
}
|
||||
|
||||
/*
|
||||
func BenchmarkLookupId(b *testing.B) {
|
||||
x := Id()
|
||||
for i := 0; i < b.N; i++ {
|
||||
if a, found := muid[x]; found {
|
||||
muid[x] = a + 1
|
||||
}
|
||||
}
|
||||
}
|
||||
func BenchmarkLookupUUID(b *testing.B) {
|
||||
x := util.RandomUUID()
|
||||
for i := 0; i < b.N; i++ {
|
||||
if a, found := muuid[&x]; found {
|
||||
muuid[&x] = a + 1
|
||||
}
|
||||
}
|
||||
}
|
||||
*/
|
||||
Loading…
Add table
Reference in a new issue