func TestWithStacks(t *testing.T) { origin := fmt.Errorf("myerror") wrapped, isErrWithStacks := WithStacks(origin).(*ErrorWithStacks) assert.True(t, "isErrWithStacks", isErrWithStacks) assert.Equal(t, "wrapped.Err", wrapped.Err, origin) wrapped2, isErrWithStacks := WithStacks(wrapped).(*ErrorWithStacks) assert.True(t, "isErrWithStacks", isErrWithStacks) assert.Equal(t, "wrapped2", wrapped2, wrapped) }
func TestWithStacksAndMessage(t *testing.T) { origin := fmt.Errorf("origin") wrapped, isErrWithStacks := WithStacksAndMessage(origin, "%s:%d", "a", 123).(*ErrorWithStacks) assert.True(t, "isErrWithStacks", isErrWithStacks) assert.Equal(t, "wrapped.Err", wrapped.Err, origin) assert.ValueShould(t, "wrapped.Stacks[0]", wrapped.Stacks[0], strings.HasSuffix(wrapped.Stacks[0], ": a:123"), "does not contain message correctly") wrapped2, isErrWithStacks := WithStacksAndMessage(wrapped, "%s:%d", "b", 456).(*ErrorWithStacks) assert.True(t, "isErrWithStacks", isErrWithStacks) assert.Equal(t, "wrapped.Err", wrapped2.Err, origin) assert.ValueShould(t, "wrapped2.Stacks[0]", wrapped2.Stacks[0], strings.HasSuffix(wrapped2.Stacks[0], ": a:123: b:456"), "does not contain message correctly") }
func TestLikeGoSubFolder(t *testing.T) { pos_cases := []string{ "go", "v8", "v-8", } for _, c := range pos_cases { assert.True(t, fmt.Sprintf("LikeGoSubFolder %v", c), LikeGoSubFolder(c)) } neg_cases := []string{ "js", "1234", "1234-5678", "1234_5678", } for _, c := range neg_cases { assert.False(t, fmt.Sprintf("LikeGoSubFolder %v", c), LikeGoSubFolder(c)) } }
func TestBoltFileCache(t *testing.T) { fn := filepath.Join(os.TempDir(), "TestBoltFileCache.bolt") assert.NoErrorOrDie(t, os.RemoveAll(fn)) db, err := bh.Open(fn, 0755, nil) assert.NoErrorOrDie(t, err) counter := make(map[string]int) c := BoltFileCache{ DB: db, IncCounter: func(name string) { counter[name] = counter[name] + 1 }, } const ( sign1 = "abc" sign2 = "def" sign3 = "ghi" gofile = "file.go" rootfolder = "root" sub = "sub" subfolder = "root/sub" ) fi := &sppb.GoFileInfo{} ////////////////////////////////////////////////////////////// // New file found. ////////////////////////////////////////////////////////////// // Get before set, should return false assert.False(t, "c.Get", c.Get(sign1, fi)) assert.Equal(t, "counter", counter, map[string]int{ "crawler.filecache.missed": 1, }) // Set the info. c.Set(sign1, &sppb.GoFileInfo{Status: sppb.GoFileInfo_ShouldIgnore}) assert.Equal(t, "counter", counter, map[string]int{ "crawler.filecache.missed": 1, "crawler.filecache.sign_saved": 1, }) // Now, should fetch the cache assert.True(t, "c.Get", c.Get(sign1, fi)) assert.Equal(t, "fi", fi, &sppb.GoFileInfo{Status: sppb.GoFileInfo_ShouldIgnore}) assert.Equal(t, "counter", counter, map[string]int{ "crawler.filecache.missed": 1, "crawler.filecache.sign_saved": 1, "crawler.filecache.hit": 1, }) }
func TestRefCountBox_OpenFuncFailed(t *testing.T) { fn := path.Join(os.TempDir(), "TestRefCountBox.bolt") assert.NoError(t, os.RemoveAll(fn)) openFuncCalled := false failedErr := errors.New("failed") b := RefCountBox{ DataPath: func() string { return fn }, OpenFunc: func(path string) (DB, error) { openFuncCalled = true return DB{}, failedErr }, } db, err := b.Alloc() assert.Equal(t, "err", errorsp.Cause(err), failedErr) assert.ValueShould(t, "db.DB", db.DB, db.DB == nil, "is not nil") assert.ValueShould(t, "b.db.DB", b.db.DB, b.db.DB == nil, "is not nil") assert.Equal(t, "b.count", b.count, 0) assert.True(t, "openFuncCalled", openFuncCalled) }
func TestRefCountBox_OpenFunc(t *testing.T) { fn := path.Join(os.TempDir(), "TestRefCountBox.bolt") assert.NoError(t, os.RemoveAll(fn)) openFuncCalled := false b := RefCountBox{ DataPath: func() string { return fn }, OpenFunc: func(path string) (DB, error) { openFuncCalled = true return Open(path, 0644, nil) }, } db, err := b.Alloc() assert.NoError(t, err) assert.ValueShould(t, "db.DB", db.DB, db.DB != nil, "is nil") assert.Equal(t, "b.count", b.count, 1) assert.ValueShould(t, "b.db.DB", b.db.DB, b.db.DB != nil, "is nil") assert.True(t, "openFuncCalled", openFuncCalled) b.Free() assert.Equal(t, "b.count", b.count, 0) assert.ValueShould(t, "b.db.DB", b.db.DB, b.db.DB == nil, "is not nil") }
func TestGobReadWrite(t *testing.T) { db := open(t, "TestGobReadWrite") defer db.Close() k := [][]byte{[]byte("a"), []byte("b")} // Testing Tx.PutGob and Tx.GobValue assert.NoErrorOrDie(t, db.Update(func(tx Tx) error { return tx.PutGob(k, &Da{S: "hello"}) })) found1 := false assert.NoError(t, db.View(func(tx Tx) error { return tx.GobValue(k, func(v interface{}) error { found1 = true da, ok := v.(Da) assert.True(t, "ok", ok) assert.Equal(t, "da", da, Da{S: "hello"}) return nil }) })) assert.True(t, "found1", found1) found2 := false assert.NoError(t, db.View(func(tx Tx) error { return tx.ForEachGob(k[:len(k)-1], func(_ Bucket, k bytesp.Slice, v interface{}) error { found2 = true da, ok := v.(Da) assert.True(t, "ok", ok) assert.Equal(t, "da", da, Da{S: "hello"}) return nil }) })) assert.True(t, "found2", found2) // Testing Bucket.PutGob, Bucket.GobValue, Bucket.ForEachGob bk := [][]byte{[]byte("bbb")} assert.NoErrorOrDie(t, db.Update(func(tx Tx) error { b, err := tx.CreateBucketIfNotExists(bk) assert.NoErrorOrDie(t, err) return b.PutGob(k, &Da{S: "world"}) })) found3 := false assert.NoError(t, db.View(func(tx Tx) error { return tx.Bucket(bk, func(b Bucket) error { return b.GobValue(k, func(v interface{}) error { found3 = true da, ok := v.(Da) assert.True(t, "ok", ok) assert.Equal(t, "da", da, Da{S: "world"}) return nil }) }) })) assert.True(t, "found3", found3) found4 := false assert.NoError(t, db.View(func(tx Tx) error { return tx.Bucket(bk, func(b Bucket) error { return b.ForEachGob(k[:len(k)-1], func(k bytesp.Slice, v interface{}) error { found4 = true da, ok := v.(Da) assert.True(t, "ok", ok) assert.Equal(t, "da", da, Da{S: "world"}) return nil }) }) })) assert.True(t, "found4", found4) }