func TestLDBDataset(t *testing.T) { assert := assert.New(t) dir, err := ioutil.TempDir(os.TempDir(), "") assert.NoError(err) ldbPath := path.Join(dir, "name") cs := chunks.NewLevelDBStoreUseFlags(ldbPath, "") ds := datas.NewDatabase(cs) id := "dsName" set := dataset.NewDataset(ds, id) commit := types.String("Commit Value") set, err = set.Commit(commit) assert.NoError(err) ds.Close() spec := fmt.Sprintf("ldb:%s::%s", ldbPath, id) sp, err := ParseDatasetSpec(spec) assert.NoError(err) dataset, err := sp.Dataset() assert.NoError(err) assert.EqualValues(commit, dataset.HeadValue()) os.Remove(dir) }
func TestReadRef(t *testing.T) { assert := assert.New(t) dir, err := ioutil.TempDir(os.TempDir(), "") assert.NoError(err) datasetId := "dsName" ldbPath := path.Join(dir, "/name") cs1 := chunks.NewLevelDBStoreUseFlags(ldbPath, "") database1 := datas.NewDatabase(cs1) dataset1 := dataset.NewDataset(database1, datasetId) commit := types.String("Commit Value") dataset1, err = dataset1.Commit(commit) assert.NoError(err) r1 := dataset1.Head().Hash() dataset1.Database().Close() spec2 := fmt.Sprintf("ldb:%s::%s", ldbPath, r1.String()) sp2, err := ParsePathSpec(spec2) assert.NoError(err) database, v2, err := sp2.Value() assert.NoError(err) assert.EqualValues(r1.String(), v2.Hash().String()) database.Close() }
func assertEncoding(t *testing.T, expect []interface{}, v Value) { vs := NewTestValueStore() tw := &nomsTestWriter{} enc := valueEncoder{tw, vs} enc.writeValue(v) assert.EqualValues(t, expect, tw.a) ir := &nomsTestReader{expect, 0} dec := valueDecoder{ir, vs, staticTypeCache} v2 := dec.readValue() assert.True(t, ir.atEnd()) assert.True(t, v.Equals(v2)) }
func TestMemDataset(t *testing.T) { assert := assert.New(t) spec := "mem::datasetTest" sp1, err := ParseDatasetSpec(spec) assert.NoError(err) dataset1, err := sp1.Dataset() assert.NoError(err) commit := types.String("Commit Value") dsTest, err := dataset1.Commit(commit) assert.NoError(err) assert.EqualValues(commit, dsTest.HeadValue()) }
func TestDatasetCommitTracker(t *testing.T) { assert := assert.New(t) id1 := "testdataset" id2 := "othertestdataset" cs := chunks.NewMemoryStore() ds1 := NewDataset(datas.NewDatabase(cs), id1) ds1Commit := types.String("Commit value for " + id1) ds1, err := ds1.CommitValue(ds1Commit) assert.NoError(err) ds2 := NewDataset(datas.NewDatabase(cs), id2) ds2Commit := types.String("Commit value for " + id2) ds2, err = ds2.CommitValue(ds2Commit) assert.NoError(err) assert.EqualValues(ds1Commit, ds1.Head().Get(datas.ValueField)) assert.EqualValues(ds2Commit, ds2.Head().Get(datas.ValueField)) assert.False(ds2.Head().Get(datas.ValueField).Equals(ds1Commit)) assert.False(ds1.Head().Get(datas.ValueField).Equals(ds2Commit)) assert.Equal("tcu8fn066i70qi99pkd5u3gq0lqncek7", cs.Root().String()) }
func TestDatasetCommitTracker(t *testing.T) { assert := assert.New(t) id1 := "testdataset" id2 := "othertestdataset" cs := chunks.NewMemoryStore() ds1 := NewDataset(datas.NewDatabase(cs), id1) ds1Commit := types.String("Commit value for " + id1) ds1, err := ds1.Commit(ds1Commit) assert.NoError(err) ds2 := NewDataset(datas.NewDatabase(cs), id2) ds2Commit := types.String("Commit value for " + id2) ds2, err = ds2.Commit(ds2Commit) assert.NoError(err) assert.EqualValues(ds1Commit, ds1.Head().Get(datas.ValueField)) assert.EqualValues(ds2Commit, ds2.Head().Get(datas.ValueField)) assert.False(ds2.Head().Get(datas.ValueField).Equals(ds1Commit)) assert.False(ds1.Head().Get(datas.ValueField).Equals(ds2Commit)) assert.Equal("sha1-898dfd332626292e92cd4a5d85e5c486dce1d57f", cs.Root().String()) }
func TestGetRequestBatch(t *testing.T) { assert := assert.New(t) r0 := hash.Parse("00000000000000000000000000000000") c1 := NewChunk([]byte("abc")) r1 := c1.Hash() c2 := NewChunk([]byte("123")) r2 := c2.Hash() tally := func(b bool, trueCnt, falseCnt *int) { if b { *trueCnt++ } else { *falseCnt++ } } req0chan := make(chan bool, 1) req1chan := make(chan Chunk, 1) req2chan := make(chan bool, 1) req3chan := make(chan bool, 1) req4chan := make(chan Chunk, 1) batch := ReadBatch{ r0: []OutstandingRequest{OutstandingHas(req0chan), OutstandingGet(req1chan)}, r1: []OutstandingRequest{OutstandingHas(req2chan)}, r2: []OutstandingRequest{OutstandingHas(req3chan), OutstandingGet(req4chan)}, } go func() { for requestedRef, reqs := range batch { for _, req := range reqs { if requestedRef == r1 { req.Satisfy(c1) delete(batch, r1) } else if requestedRef == r2 { req.Satisfy(c2) delete(batch, r2) } } } }() var r1True, r1False, r2True, r2False int for b := range req2chan { tally(b, &r1True, &r1False) } for b := range req3chan { tally(b, &r2True, &r2False) } for c := range req4chan { assert.EqualValues(c2.Hash(), c.Hash()) } assert.Equal(1, r1True) assert.Equal(0, r1False) assert.Equal(1, r2True) assert.Equal(0, r2False) go batch.Close() var r0True, r0False int for b := range req0chan { tally(b, &r0True, &r0False) } for c := range req1chan { assert.EqualValues(EmptyChunk.Hash(), c.Hash()) } assert.Equal(0, r0True) assert.Equal(1, r0False) }
// EqualValues asserts that two objects are equal or convertable to the same types // and equal. // // assert.EqualValues(t, uint32(123), int32(123), "123 and 123 should be equal") // // Returns whether the assertion was successful (true) or not (false). func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { if !assert.EqualValues(t, expected, actual, msgAndArgs...) { t.FailNow() } }