How to use Put method of run Package

Best Keploy code snippet using run.Put

bitcask_test.go

Source:bitcask_test.go

...58	t.Run("Open", func(t *testing.T) {59		db, err = Open(testdir)60		assert.NoError(err)61	})62	t.Run("Put", func(t *testing.T) {63		err = db.Put([]byte([]byte("foo")), []byte("bar"))64		assert.NoError(err)65	})66	t.Run("Get", func(t *testing.T) {67		val, err := db.Get([]byte("foo"))68		assert.NoError(err)69		assert.Equal([]byte("bar"), val)70	})71	t.Run("Len", func(t *testing.T) {72		assert.Equal(1, db.Len())73	})74	t.Run("Has", func(t *testing.T) {75		assert.True(db.Has([]byte("foo")))76	})77	t.Run("Keys", func(t *testing.T) {78		keys := make([][]byte, 0)79		for key := range db.Keys() {80			keys = append(keys, key)81		}82		assert.Equal([][]byte{[]byte("foo")}, keys)83	})84	t.Run("Fold", func(t *testing.T) {85		var (86			keys   [][]byte87			values [][]byte88		)89		err := db.Fold(func(key []byte) error {90			value, err := db.Get(key)91			if err != nil {92				return err93			}94			keys = append(keys, key)95			values = append(values, value)96			return nil97		})98		assert.NoError(err)99		assert.Equal([][]byte{[]byte("foo")}, keys)100		assert.Equal([][]byte{[]byte("bar")}, values)101	})102	t.Run("Delete", func(t *testing.T) {103		err := db.Delete([]byte("foo"))104		assert.NoError(err)105		_, err = db.Get([]byte("foo"))106		assert.Error(err)107		assert.Equal(ErrKeyNotFound, err)108	})109	t.Run("Sync", func(t *testing.T) {110		err = db.Sync()111		assert.NoError(err)112	})113	t.Run("Close", func(t *testing.T) {114		err = db.Close()115		assert.NoError(err)116	})117}118func TestDeleteAll(t *testing.T) {119	assert := assert.New(t)120	testdir, _ := ioutil.TempDir("", "bitcask")121	db, _ := Open(testdir)122	_ = db.Put([]byte("foo"), []byte("foo"))123	_ = db.Put([]byte("bar"), []byte("bar"))124	_ = db.Put([]byte("baz"), []byte("baz"))125	assert.Equal(3, db.Len())126	err := db.DeleteAll()127	assert.NoError(err)128	assert.Equal(0, db.Len())129	_, err = db.Get([]byte("foo"))130	assert.Equal(ErrKeyNotFound, err)131	_, err = db.Get([]byte("bar"))132	assert.Equal(ErrKeyNotFound, err)133	_, err = db.Get([]byte("baz"))134	assert.Equal(ErrKeyNotFound, err)135}136func TestReopen1(t *testing.T) {137	assert := assert.New(t)138	for i := 0; i < 10; i++ {139		testdir, _ := ioutil.TempDir("", "bitcask")140		db, _ := Open(testdir, WithMaxDatafileSize(1))141		_ = db.Put([]byte("foo"), []byte("bar"))142		_ = db.Put([]byte("foo"), []byte("bar1"))143		_ = db.Put([]byte("foo"), []byte("bar2"))144		_ = db.Put([]byte("foo"), []byte("bar3"))145		_ = db.Put([]byte("foo"), []byte("bar4"))146		_ = db.Put([]byte("foo"), []byte("bar5"))147		_ = db.Reopen()148		val, _ := db.Get([]byte("foo"))149		assert.Equal("bar5", string(val))150	}151}152func TestReopen(t *testing.T) {153	assert := assert.New(t)154	testdir, err := ioutil.TempDir("", "bitcask")155	assert.NoError(err)156	t.Run("Reopen", func(t *testing.T) {157		var (158			db  *Bitcask159			err error160		)161		t.Run("Open", func(t *testing.T) {162			db, err = Open(testdir)163			assert.NoError(err)164		})165		t.Run("Put", func(t *testing.T) {166			err = db.Put([]byte("foo"), []byte("bar"))167			assert.NoError(err)168		})169		t.Run("Get", func(t *testing.T) {170			val, err := db.Get([]byte("foo"))171			assert.NoError(err)172			assert.Equal([]byte("bar"), val)173		})174		t.Run("Reopen", func(t *testing.T) {175			err = db.Reopen()176			assert.NoError(err)177		})178		t.Run("GetAfterReopen", func(t *testing.T) {179			val, err := db.Get([]byte("foo"))180			assert.NoError(err)181			assert.Equal([]byte("bar"), val)182		})183		t.Run("PutAfterReopen", func(t *testing.T) {184			err = db.Put([]byte("zzz"), []byte("foo"))185			assert.NoError(err)186		})187		t.Run("GetAfterReopenAndPut", func(t *testing.T) {188			val, err := db.Get([]byte("zzz"))189			assert.NoError(err)190			assert.Equal([]byte("foo"), val)191		})192		t.Run("Close", func(t *testing.T) {193			err = db.Close()194			assert.NoError(err)195		})196	})197}198func TestDeletedKeys(t *testing.T) {199	assert := assert.New(t)200	testdir, err := ioutil.TempDir("", "bitcask")201	assert.NoError(err)202	t.Run("Setup", func(t *testing.T) {203		var (204			db  *Bitcask205			err error206		)207		t.Run("Open", func(t *testing.T) {208			db, err = Open(testdir)209			assert.NoError(err)210		})211		t.Run("Put", func(t *testing.T) {212			err = db.Put([]byte("foo"), []byte("bar"))213			assert.NoError(err)214		})215		t.Run("Get", func(t *testing.T) {216			val, err := db.Get([]byte("foo"))217			assert.NoError(err)218			assert.Equal([]byte("bar"), val)219		})220		t.Run("Delete", func(t *testing.T) {221			err := db.Delete([]byte("foo"))222			assert.NoError(err)223			_, err = db.Get([]byte("foo"))224			assert.Error(err)225			assert.Equal(ErrKeyNotFound, err)226		})227		t.Run("Sync", func(t *testing.T) {228			err = db.Sync()229			assert.NoError(err)230		})231		t.Run("Close", func(t *testing.T) {232			err = db.Close()233			assert.NoError(err)234		})235	})236	t.Run("Reopen", func(t *testing.T) {237		var (238			db  *Bitcask239			err error240		)241		t.Run("Open", func(t *testing.T) {242			db, err = Open(testdir)243			assert.NoError(err)244		})245		t.Run("Get", func(t *testing.T) {246			_, err = db.Get([]byte("foo"))247			assert.Error(err)248			assert.Equal(ErrKeyNotFound, err)249		})250		t.Run("Close", func(t *testing.T) {251			err = db.Close()252			assert.NoError(err)253		})254	})255}256func TestConfigErrors(t *testing.T) {257	assert := assert.New(t)258	t.Run("CorruptConfig", func(t *testing.T) {259		testdir, err := ioutil.TempDir("", "bitcask")260		assert.NoError(err)261		defer os.RemoveAll(testdir)262		db, err := Open(testdir)263		assert.NoError(err)264		assert.NoError(db.Close())265		assert.NoError(ioutil.WriteFile(filepath.Join(testdir, "config.json"), []byte("foo bar baz"), 0600))266		_, err = Open(testdir)267		assert.Error(err)268	})269	t.Run("BadConfigPath", func(t *testing.T) {270		testdir, err := ioutil.TempDir("", "bitcask")271		assert.NoError(err)272		defer os.RemoveAll(testdir)273		assert.NoError(os.Mkdir(filepath.Join(testdir, "config.json"), 0700))274		_, err = Open(testdir)275		assert.Error(err)276	})277}278func TestReIndex(t *testing.T) {279	assert := assert.New(t)280	testdir, err := ioutil.TempDir("", "bitcask")281	assert.NoError(err)282	t.Run("Setup", func(t *testing.T) {283		var (284			db  *Bitcask285			err error286		)287		t.Run("Open", func(t *testing.T) {288			db, err = Open(testdir)289			assert.NoError(err)290		})291		t.Run("Put", func(t *testing.T) {292			err = db.Put([]byte("foo"), []byte("bar"))293			assert.NoError(err)294		})295		t.Run("Get", func(t *testing.T) {296			val, err := db.Get([]byte("foo"))297			assert.NoError(err)298			assert.Equal([]byte("bar"), val)299		})300		t.Run("Sync", func(t *testing.T) {301			err = db.Sync()302			assert.NoError(err)303		})304		t.Run("Close", func(t *testing.T) {305			err = db.Close()306			assert.NoError(err)307		})308		t.Run("DeleteIndex", func(t *testing.T) {309			err := os.Remove(filepath.Join(testdir, "index"))310			assert.NoError(err)311		})312	})313	t.Run("Reopen", func(t *testing.T) {314		var (315			db  *Bitcask316			err error317		)318		t.Run("Open", func(t *testing.T) {319			db, err = Open(testdir)320			assert.NoError(err)321		})322		t.Run("Get", func(t *testing.T) {323			val, err := db.Get([]byte("foo"))324			assert.NoError(err)325			assert.Equal([]byte("bar"), val)326		})327		t.Run("Close", func(t *testing.T) {328			err = db.Close()329			assert.NoError(err)330		})331	})332}333func TestReIndexDeletedKeys(t *testing.T) {334	assert := assert.New(t)335	testdir, err := ioutil.TempDir("", "bitcask")336	assert.NoError(err)337	t.Run("Setup", func(t *testing.T) {338		var (339			db  *Bitcask340			err error341		)342		t.Run("Open", func(t *testing.T) {343			db, err = Open(testdir)344			assert.NoError(err)345		})346		t.Run("Put", func(t *testing.T) {347			err = db.Put([]byte("foo"), []byte("bar"))348			assert.NoError(err)349		})350		t.Run("Get", func(t *testing.T) {351			val, err := db.Get([]byte("foo"))352			assert.NoError(err)353			assert.Equal([]byte("bar"), val)354		})355		t.Run("Delete", func(t *testing.T) {356			err := db.Delete([]byte("foo"))357			assert.NoError(err)358			_, err = db.Get([]byte("foo"))359			assert.Error(err)360			assert.Equal(ErrKeyNotFound, err)361		})362		t.Run("Sync", func(t *testing.T) {363			err = db.Sync()364			assert.NoError(err)365		})366		t.Run("Close", func(t *testing.T) {367			err = db.Close()368			assert.NoError(err)369		})370		t.Run("DeleteIndex", func(t *testing.T) {371			err := os.Remove(filepath.Join(testdir, "index"))372			assert.NoError(err)373		})374	})375	t.Run("Reopen", func(t *testing.T) {376		var (377			db  *Bitcask378			err error379		)380		t.Run("Open", func(t *testing.T) {381			db, err = Open(testdir)382			assert.NoError(err)383		})384		t.Run("Get", func(t *testing.T) {385			_, err := db.Get([]byte("foo"))386			assert.Error(err)387			assert.Equal(ErrKeyNotFound, err)388		})389		t.Run("Close", func(t *testing.T) {390			err = db.Close()391			assert.NoError(err)392		})393	})394}395func TestSync(t *testing.T) {396	assert := assert.New(t)397	testdir, err := ioutil.TempDir("", "bitcask")398	assert.NoError(err)399	var db *Bitcask400	t.Run("Open", func(t *testing.T) {401		db, err = Open(testdir, WithSync(true))402		assert.NoError(err)403	})404	t.Run("Put", func(t *testing.T) {405		key := []byte(strings.Repeat(" ", 17))406		value := []byte("foobar")407		err = db.Put(key, value)408	})409}410func TestMaxKeySize(t *testing.T) {411	assert := assert.New(t)412	testdir, err := ioutil.TempDir("", "bitcask")413	assert.NoError(err)414	var db *Bitcask415	t.Run("Open", func(t *testing.T) {416		db, err = Open(testdir, WithMaxKeySize(16))417		assert.NoError(err)418	})419	t.Run("Put", func(t *testing.T) {420		key := []byte(strings.Repeat(" ", 17))421		value := []byte("foobar")422		err = db.Put(key, value)423		assert.Error(err)424		assert.Equal(ErrKeyTooLarge, err)425	})426}427func TestMaxValueSize(t *testing.T) {428	assert := assert.New(t)429	testdir, err := ioutil.TempDir("", "bitcask")430	assert.NoError(err)431	var db *Bitcask432	t.Run("Open", func(t *testing.T) {433		db, err = Open(testdir, WithMaxValueSize(16))434		assert.NoError(err)435	})436	t.Run("Put", func(t *testing.T) {437		key := []byte("foo")438		value := []byte(strings.Repeat(" ", 17))439		err = db.Put(key, value)440		assert.Error(err)441		assert.Equal(ErrValueTooLarge, err)442	})443}444func TestStats(t *testing.T) {445	var (446		db  *Bitcask447		err error448	)449	assert := assert.New(t)450	testdir, err := ioutil.TempDir("", "bitcask")451	assert.NoError(err)452	t.Run("Setup", func(t *testing.T) {453		t.Run("Open", func(t *testing.T) {454			db, err = Open(testdir)455			assert.NoError(err)456		})457		t.Run("Put", func(t *testing.T) {458			err := db.Put([]byte("foo"), []byte("bar"))459			assert.NoError(err)460		})461		t.Run("Get", func(t *testing.T) {462			val, err := db.Get([]byte("foo"))463			assert.NoError(err)464			assert.Equal([]byte("bar"), val)465		})466		t.Run("Stats", func(t *testing.T) {467			stats, err := db.Stats()468			assert.NoError(err)469			assert.Equal(stats.Datafiles, 0)470			assert.Equal(stats.Keys, 1)471		})472		t.Run("Sync", func(t *testing.T) {473			err = db.Sync()474			assert.NoError(err)475		})476		t.Run("Close", func(t *testing.T) {477			err = db.Close()478			assert.NoError(err)479		})480	})481}482func TestStatsError(t *testing.T) {483	var (484		db  *Bitcask485		err error486	)487	assert := assert.New(t)488	testdir, err := ioutil.TempDir("", "bitcask")489	assert.NoError(err)490	t.Run("Setup", func(t *testing.T) {491		t.Run("Open", func(t *testing.T) {492			db, err = Open(testdir)493			assert.NoError(err)494		})495		t.Run("Put", func(t *testing.T) {496			err := db.Put([]byte("foo"), []byte("bar"))497			assert.NoError(err)498		})499		t.Run("Get", func(t *testing.T) {500			val, err := db.Get([]byte("foo"))501			assert.NoError(err)502			assert.Equal([]byte("bar"), val)503		})504		t.Run("Stats", func(t *testing.T) {505			stats, err := db.Stats()506			assert.NoError(err)507			assert.Equal(stats.Datafiles, 0)508			assert.Equal(stats.Keys, 1)509		})510	})511	t.Run("Test", func(t *testing.T) {512		skipIfWindows(t)513		t.Run("FabricatedDestruction", func(t *testing.T) {514			// This would never happen in reality :D515			// Or would it? :)516			err = os.RemoveAll(testdir)517			assert.NoError(err)518		})519		t.Run("Stats", func(t *testing.T) {520			_, err := db.Stats()521			assert.Error(err)522		})523	})524}525func TestMaxDatafileSize(t *testing.T) {526	var (527		db  *Bitcask528		err error529	)530	assert := assert.New(t)531	testdir, err := ioutil.TempDir("", "bitcask")532	assert.NoError(err)533	defer os.RemoveAll(testdir)534	t.Run("Setup", func(t *testing.T) {535		t.Run("Open", func(t *testing.T) {536			db, err = Open(testdir, WithMaxDatafileSize(32))537			assert.NoError(err)538		})539		t.Run("Put", func(t *testing.T) {540			err := db.Put([]byte("foo"), []byte("bar"))541			assert.NoError(err)542		})543	})544	t.Run("Put", func(t *testing.T) {545		for i := 0; i < 10; i++ {546			err := db.Put([]byte(fmt.Sprintf("key_%d", i)), []byte("bar"))547			assert.NoError(err)548		}549	})550	t.Run("Sync", func(t *testing.T) {551		err = db.Sync()552		assert.NoError(err)553	})554	t.Run("Get", func(t *testing.T) {555		val, err := db.Get([]byte("foo"))556		assert.NoError(err)557		assert.Equal([]byte("bar"), val)558		for i := 0; i < 10; i++ {559			val, err = db.Get([]byte(fmt.Sprintf("key_%d", i)))560			assert.NoError(err)561			assert.Equal([]byte("bar"), val)562		}563	})564	t.Run("Close", func(t *testing.T) {565		err = db.Close()566		assert.NoError(err)567	})568}569func TestMerge(t *testing.T) {570	var (571		db  *Bitcask572		err error573	)574	assert := assert.New(t)575	testdir, err := ioutil.TempDir("", "bitcask")576	assert.NoError(err)577	t.Run("Setup", func(t *testing.T) {578		t.Run("Open", func(t *testing.T) {579			db, err = Open(testdir, WithMaxDatafileSize(32))580			assert.NoError(err)581		})582		t.Run("Put", func(t *testing.T) {583			err := db.Put([]byte("foo"), []byte("bar"))584			assert.NoError(err)585		})586		s1, err := db.Stats()587		assert.NoError(err)588		assert.Equal(0, s1.Datafiles)589		assert.Equal(1, s1.Keys)590		t.Run("Put", func(t *testing.T) {591			for i := 0; i < 10; i++ {592				err := db.Put([]byte("foo"), []byte("bar"))593				assert.NoError(err)594			}595		})596		s2, err := db.Stats()597		assert.NoError(err)598		assert.Equal(5, s2.Datafiles)599		assert.Equal(1, s2.Keys)600		assert.True(s2.Size > s1.Size)601		t.Run("Merge", func(t *testing.T) {602			err := db.Merge()603			assert.NoError(err)604		})605		s3, err := db.Stats()606		assert.NoError(err)607		assert.Equal(1, s3.Datafiles)608		assert.Equal(1, s3.Keys)609		assert.True(s3.Size > s1.Size)610		assert.True(s3.Size < s2.Size)611		t.Run("Sync", func(t *testing.T) {612			err = db.Sync()613			assert.NoError(err)614		})615		t.Run("Close", func(t *testing.T) {616			err = db.Close()617			assert.NoError(err)618		})619	})620}621func TestGetErrors(t *testing.T) {622	assert := assert.New(t)623	t.Run("ReadError", func(t *testing.T) {624		testdir, err := ioutil.TempDir("", "bitcask")625		assert.NoError(err)626		defer os.RemoveAll(testdir)627		db, err := Open(testdir, WithMaxDatafileSize(32))628		assert.NoError(err)629		err = db.Put([]byte("foo"), []byte("bar"))630		assert.NoError(err)631		mockDatafile := new(mocks.Datafile)632		mockDatafile.On("FileID").Return(0)633		mockDatafile.On("ReadAt", int64(0), int64(22)).Return(634			internal.Entry{},635			ErrMockError,636		)637		db.curr = mockDatafile638		_, err = db.Get([]byte("foo"))639		assert.Error(err)640		assert.Equal(ErrMockError, err)641	})642	t.Run("ChecksumError", func(t *testing.T) {643		testdir, err := ioutil.TempDir("", "bitcask")644		assert.NoError(err)645		defer os.RemoveAll(testdir)646		db, err := Open(testdir, WithMaxDatafileSize(32))647		assert.NoError(err)648		err = db.Put([]byte("foo"), []byte("bar"))649		assert.NoError(err)650		mockDatafile := new(mocks.Datafile)651		mockDatafile.On("FileID").Return(0)652		mockDatafile.On("ReadAt", int64(0), int64(22)).Return(653			internal.Entry{654				Checksum: 0x0,655				Key:      []byte("foo"),656				Offset:   0,657				Value:    []byte("bar"),658			},659			nil,660		)661		db.curr = mockDatafile662		_, err = db.Get([]byte("foo"))663		assert.Error(err)664		assert.Equal(ErrChecksumFailed, err)665	})666}667func TestPutErrors(t *testing.T) {668	assert := assert.New(t)669	t.Run("WriteError", func(t *testing.T) {670		testdir, err := ioutil.TempDir("", "bitcask")671		assert.NoError(err)672		db, err := Open(testdir)673		assert.NoError(err)674		mockDatafile := new(mocks.Datafile)675		mockDatafile.On("Size").Return(int64(0))676		mockDatafile.On(677			"Write",678			internal.Entry{679				Checksum: 0x76ff8caa,680				Key:      []byte("foo"),681				Offset:   0,682				Value:    []byte("bar"),683			},684		).Return(int64(0), int64(0), ErrMockError)685		db.curr = mockDatafile686		err = db.Put([]byte("foo"), []byte("bar"))687		assert.Error(err)688		assert.Equal(ErrMockError, err)689	})690	t.Run("SyncError", func(t *testing.T) {691		testdir, err := ioutil.TempDir("", "bitcask")692		assert.NoError(err)693		db, err := Open(testdir, WithSync(true))694		assert.NoError(err)695		mockDatafile := new(mocks.Datafile)696		mockDatafile.On("Size").Return(int64(0))697		mockDatafile.On(698			"Write",699			internal.Entry{700				Checksum: 0x78240498,701				Key:      []byte("bar"),702				Offset:   0,703				Value:    []byte("baz"),704			},705		).Return(int64(0), int64(0), nil)706		mockDatafile.On("Sync").Return(ErrMockError)707		db.curr = mockDatafile708		err = db.Put([]byte("bar"), []byte("baz"))709		assert.Error(err)710		assert.Equal(ErrMockError, err)711	})712}713func TestOpenErrors(t *testing.T) {714	assert := assert.New(t)715	t.Run("BadPath", func(t *testing.T) {716		testdir, err := ioutil.TempDir("", "bitcask")717		assert.NoError(err)718		defer os.RemoveAll(testdir)719		assert.NoError(ioutil.WriteFile(filepath.Join(testdir, "foo"), []byte("foo"), 0600))720		_, err = Open(filepath.Join(testdir, "foo", "tmp.db"))721		assert.Error(err)722	})723	t.Run("BadOption", func(t *testing.T) {724		testdir, err := ioutil.TempDir("", "bitcask")725		assert.NoError(err)726		defer os.RemoveAll(testdir)727		withBogusOption := func() Option {728			return func(cfg *config.Config) error {729				return errors.New("mocked error")730			}731		}732		_, err = Open(testdir, withBogusOption())733		assert.Error(err)734	})735	t.Run("LoadDatafilesError", func(t *testing.T) {736		testdir, err := ioutil.TempDir("", "bitcask")737		assert.NoError(err)738		defer os.RemoveAll(testdir)739		db, err := Open(testdir)740		assert.NoError(err)741		err = db.Put([]byte("foo"), []byte("bar"))742		assert.NoError(err)743		err = db.Close()744		assert.NoError(err)745		// Simulate some horrible that happened to the datafiles!746		err = os.Rename(filepath.Join(testdir, "000000000.data"), filepath.Join(testdir, "000000000xxx.data"))747		assert.NoError(err)748		_, err = Open(testdir)749		assert.Error(err)750		assert.Equal("strconv.ParseInt: parsing \"000000000xxx\": invalid syntax", err.Error())751	})752}753func TestCloseErrors(t *testing.T) {754	assert := assert.New(t)755	testdir, err := ioutil.TempDir("", "bitcask")756	assert.NoError(err)757	defer os.RemoveAll(testdir)758	t.Run("CloseIndexError", func(t *testing.T) {759		db, err := Open(testdir, WithMaxDatafileSize(32))760		assert.NoError(err)761		mockIndexer := new(mocks.Indexer)762		mockIndexer.On("Save", db.trie, filepath.Join(db.path, "index")).Return(ErrMockError)763		db.indexer = mockIndexer764		err = db.Close()765		assert.Error(err)766		assert.Equal(ErrMockError, err)767	})768	t.Run("CloseDatafilesError", func(t *testing.T) {769		db, err := Open(testdir, WithMaxDatafileSize(32))770		assert.NoError(err)771		mockDatafile := new(mocks.Datafile)772		mockDatafile.On("Close").Return(ErrMockError)773		db.datafiles[0] = mockDatafile774		err = db.Close()775		assert.Error(err)776		assert.Equal(ErrMockError, err)777	})778	t.Run("CloseActiveDatafileError", func(t *testing.T) {779		db, err := Open(testdir, WithMaxDatafileSize(32))780		assert.NoError(err)781		mockDatafile := new(mocks.Datafile)782		mockDatafile.On("Close").Return(ErrMockError)783		db.curr = mockDatafile784		err = db.Close()785		assert.Error(err)786		assert.Equal(ErrMockError, err)787	})788}789func TestDeleteErrors(t *testing.T) {790	assert := assert.New(t)791	t.Run("WriteError", func(t *testing.T) {792		testdir, err := ioutil.TempDir("", "bitcask")793		assert.NoError(err)794		defer os.RemoveAll(testdir)795		db, err := Open(testdir, WithMaxDatafileSize(32))796		assert.NoError(err)797		err = db.Put([]byte("foo"), []byte("bar"))798		assert.NoError(err)799		mockDatafile := new(mocks.Datafile)800		mockDatafile.On("Size").Return(int64(0))801		mockDatafile.On(802			"Write",803			internal.Entry{804				Checksum: 0x0,805				Key:      []byte("foo"),806				Offset:   0,807				Value:    []byte{},808			},809		).Return(int64(0), int64(0), ErrMockError)810		db.curr = mockDatafile811		err = db.Delete([]byte("foo"))812		assert.Error(err)813	})814}815func TestMergeErrors(t *testing.T) {816	assert := assert.New(t)817	t.Run("RemoveDatabaseDirectory", func(t *testing.T) {818		skipIfWindows(t)819		testdir, err := ioutil.TempDir("", "bitcask")820		assert.NoError(err)821		defer os.RemoveAll(testdir)822		db, err := Open(testdir, WithMaxDatafileSize(32))823		assert.NoError(err)824		assert.NoError(os.RemoveAll(testdir))825		err = db.Merge()826		assert.Error(err)827	})828	t.Run("EmptyCloseError", func(t *testing.T) {829		testdir, err := ioutil.TempDir("", "bitcask")830		assert.NoError(err)831		defer os.RemoveAll(testdir)832		db, err := Open(testdir)833		assert.NoError(err)834		mockDatafile := new(mocks.Datafile)835		mockDatafile.On("Close").Return(ErrMockError)836		db.curr = mockDatafile837		err = db.Merge()838		assert.Error(err)839		assert.Equal(ErrMockError, err)840	})841	t.Run("ReadError", func(t *testing.T) {842		testdir, err := ioutil.TempDir("", "bitcask")843		assert.NoError(err)844		defer os.RemoveAll(testdir)845		db, err := Open(testdir)846		assert.NoError(err)847		assert.NoError(db.Put([]byte("foo"), []byte("bar")))848		mockDatafile := new(mocks.Datafile)849		mockDatafile.On("FileID").Return(0)850		mockDatafile.On("ReadAt", int64(0), int64(22)).Return(851			internal.Entry{},852			ErrMockError,853		)854		db.curr = mockDatafile855		err = db.Merge()856		assert.Error(err)857		assert.Equal(ErrMockError, err)858	})859}860func TestConcurrent(t *testing.T) {861	var (862		db  *Bitcask863		err error864	)865	assert := assert.New(t)866	testdir, err := ioutil.TempDir("", "bitcask")867	assert.NoError(err)868	t.Run("Setup", func(t *testing.T) {869		t.Run("Open", func(t *testing.T) {870			db, err = Open(testdir)871			assert.NoError(err)872		})873		t.Run("Put", func(t *testing.T) {874			err = db.Put([]byte("foo"), []byte("bar"))875			assert.NoError(err)876		})877	})878	t.Run("Concurrent", func(t *testing.T) {879		t.Run("Put", func(t *testing.T) {880			f := func(wg *sync.WaitGroup, x int) {881				defer func() {882					wg.Done()883				}()884				for i := 0; i <= 100; i++ {885					if i%x == 0 {886						key := []byte(fmt.Sprintf("k%d", i))887						value := []byte(fmt.Sprintf("v%d", i))888						err := db.Put(key, value)889						assert.NoError(err)890					}891				}892			}893			wg := &sync.WaitGroup{}894			go f(wg, 2)895			go f(wg, 3)896			go f(wg, 5)897			wg.Add(3)898			wg.Wait()899		})900		t.Run("Get", func(t *testing.T) {901			f := func(wg *sync.WaitGroup, N int) {902				defer func() {903					wg.Done()904				}()905				for i := 0; i <= N; i++ {906					value, err := db.Get([]byte("foo"))907					assert.NoError(err)908					assert.Equal([]byte("bar"), value)909				}910			}911			wg := &sync.WaitGroup{}912			go f(wg, 100)913			go f(wg, 100)914			go f(wg, 100)915			wg.Add(3)916			wg.Wait()917		})918		t.Run("Close", func(t *testing.T) {919			err = db.Close()920			assert.NoError(err)921		})922	})923}924func TestScan(t *testing.T) {925	assert := assert.New(t)926	testdir, err := ioutil.TempDir("", "bitcask")927	assert.NoError(err)928	var db *Bitcask929	t.Run("Setup", func(t *testing.T) {930		t.Run("Open", func(t *testing.T) {931			db, err = Open(testdir)932			assert.NoError(err)933		})934		t.Run("Put", func(t *testing.T) {935			var items = map[string][]byte{936				"1":     []byte("1"),937				"2":     []byte("2"),938				"3":     []byte("3"),939				"food":  []byte("pizza"),940				"foo":   []byte([]byte("foo")),941				"fooz":  []byte("fooz ball"),942				"hello": []byte("world"),943			}944			for k, v := range items {945				err = db.Put([]byte(k), v)946				assert.NoError(err)947			}948		})949	})950	t.Run("Scan", func(t *testing.T) {951		var (952			vals     [][]byte953			expected = [][]byte{954				[]byte("foo"),955				[]byte("fooz ball"),956				[]byte("pizza"),957			}958		)959		err = db.Scan([]byte("fo"), func(key []byte) error {960			val, err := db.Get(key)961			assert.NoError(err)962			vals = append(vals, val)963			return nil964		})965		vals = SortByteArrays(vals)966		assert.Equal(expected, vals)967	})968	t.Run("ScanErrors", func(t *testing.T) {969		err = db.Scan([]byte("fo"), func(key []byte) error {970			return ErrMockError971		})972		assert.Error(err)973		assert.Equal(ErrMockError, err)974	})975}976func TestLocking(t *testing.T) {977	assert := assert.New(t)978	testdir, err := ioutil.TempDir("", "bitcask")979	assert.NoError(err)980	db, err := Open(testdir)981	assert.NoError(err)982	defer db.Close()983	_, err = Open(testdir)984	assert.Error(err)985	assert.Equal(ErrDatabaseLocked, err)986}987type benchmarkTestCase struct {988	name string989	size int990}991func BenchmarkGet(b *testing.B) {992	currentDir, err := os.Getwd()993	if err != nil {994		b.Fatal(err)995	}996	testdir, err := ioutil.TempDir(currentDir, "bitcask_bench")997	if err != nil {998		b.Fatal(err)999	}1000	defer os.RemoveAll(testdir)1001	tests := []benchmarkTestCase{1002		{"128B", 128},1003		{"256B", 256},1004		{"512B", 512},1005		{"1K", 1024},1006		{"2K", 2048},1007		{"4K", 4096},1008		{"8K", 8192},1009		{"16K", 16384},1010		{"32K", 32768},1011	}1012	for _, tt := range tests {1013		b.Run(tt.name, func(b *testing.B) {1014			b.SetBytes(int64(tt.size))1015			key := []byte("foo")1016			value := []byte(strings.Repeat(" ", tt.size))1017			options := []Option{1018				WithMaxKeySize(uint32(len(key))),1019				WithMaxValueSize(uint64(tt.size)),1020			}1021			db, err := Open(testdir, options...)1022			if err != nil {1023				b.Fatal(err)1024			}1025			err = db.Put(key, value)1026			if err != nil {1027				b.Fatal(err)1028			}1029			b.ResetTimer()1030			for i := 0; i < b.N; i++ {1031				val, err := db.Get(key)1032				if err != nil {1033					b.Fatal(err)1034				}1035				if !bytes.Equal(val, value) {1036					b.Errorf("unexpected value")1037				}1038			}1039			b.StopTimer()1040			db.Close()1041		})1042	}1043}1044func BenchmarkPut(b *testing.B) {1045	currentDir, err := os.Getwd()1046	if err != nil {1047		b.Fatal(err)1048	}1049	tests := []benchmarkTestCase{1050		{"128B", 128},1051		{"256B", 256},1052		{"1K", 1024},1053		{"2K", 2048},1054		{"4K", 4096},1055		{"8K", 8192},1056		{"16K", 16384},1057		{"32K", 32768},1058	}1059	variants := map[string][]Option{1060		"NoSync": {1061			WithSync(false),1062		},1063		"Sync": {1064			WithSync(true),1065		},1066	}1067	for name, options := range variants {1068		testdir, err := ioutil.TempDir(currentDir, "bitcask_bench")1069		if err != nil {1070			b.Fatal(err)1071		}1072		defer os.RemoveAll(testdir)1073		db, err := Open(testdir, options...)1074		if err != nil {1075			b.Fatal(err)1076		}1077		defer db.Close()1078		for _, tt := range tests {1079			b.Run(tt.name+name, func(b *testing.B) {1080				b.SetBytes(int64(tt.size))1081				key := []byte("foo")1082				value := []byte(strings.Repeat(" ", tt.size))1083				b.ResetTimer()1084				for i := 0; i < b.N; i++ {1085					err := db.Put(key, value)1086					if err != nil {1087						b.Fatal(err)1088					}1089				}1090			})1091		}1092	}1093}1094func BenchmarkScan(b *testing.B) {1095	currentDir, err := os.Getwd()1096	if err != nil {1097		b.Fatal(err)1098	}1099	testdir, err := ioutil.TempDir(currentDir, "bitcask_bench")1100	if err != nil {1101		b.Fatal(err)1102	}1103	defer os.RemoveAll(testdir)1104	db, err := Open(testdir)1105	if err != nil {1106		b.Fatal(err)1107	}1108	defer db.Close()1109	var items = map[string][]byte{1110		"1":     []byte("1"),1111		"2":     []byte("2"),1112		"3":     []byte("3"),1113		"food":  []byte("pizza"),1114		"foo":   []byte([]byte("foo")),1115		"fooz":  []byte("fooz ball"),1116		"hello": []byte("world"),1117	}1118	for k, v := range items {1119		err := db.Put([]byte(k), v)1120		if err != nil {1121			b.Fatal(err)1122		}1123	}1124	var expected = [][]byte{[]byte("foo"), []byte("food"), []byte("fooz")}1125	b.ResetTimer()1126	for i := 0; i < b.N; i++ {1127		var keys [][]byte1128		err = db.Scan([]byte("fo"), func(key []byte) error {1129			keys = append(keys, key)1130			return nil1131		})1132		if err != nil {1133			b.Fatal(err)...

fragment.go

Source:fragment.go

...10	Unknowns []Atom11	AtomPos12}13func (a MovieFrag) Marshal(b []byte) (n int) {14	pio.PutU32BE(b[4:], uint32(MOOF))15	n += a.marshal(b[8:]) + 816	pio.PutU32BE(b[0:], uint32(n))17	return18}19func (a MovieFrag) marshal(b []byte) (n int) {20	if a.Header != nil {21		n += a.Header.Marshal(b[n:])22	}23	for _, atom := range a.Tracks {24		n += atom.Marshal(b[n:])25	}26	for _, atom := range a.Unknowns {27		n += atom.Marshal(b[n:])28	}29	return30}31func (a MovieFrag) Len() (n int) {32	n += 833	if a.Header != nil {34		n += a.Header.Len()35	}36	for _, atom := range a.Tracks {37		n += atom.Len()38	}39	for _, atom := range a.Unknowns {40		n += atom.Len()41	}42	return43}44func (a *MovieFrag) Unmarshal(b []byte, offset int) (n int, err error) {45	(&a.AtomPos).setPos(offset, len(b))46	n += 847	for n+8 < len(b) {48		tag := Tag(pio.U32BE(b[n+4:]))49		size := int(pio.U32BE(b[n:]))50		if len(b) < n+size {51			err = parseErr("TagSizeInvalid", n+offset, err)52			return53		}54		switch tag {55		case MFHD:56			{57				atom := &MovieFragHeader{}58				if _, err = atom.Unmarshal(b[n:n+size], offset+n); err != nil {59					err = parseErr("mfhd", n+offset, err)60					return61				}62				a.Header = atom63			}64		case TRAF:65			{66				atom := &TrackFrag{}67				if _, err = atom.Unmarshal(b[n:n+size], offset+n); err != nil {68					err = parseErr("traf", n+offset, err)69					return70				}71				a.Tracks = append(a.Tracks, atom)72			}73		default:74			{75				atom := &Dummy{Tag_: tag, Data: b[n : n+size]}76				if _, err = atom.Unmarshal(b[n:n+size], offset+n); err != nil {77					err = parseErr("", n+offset, err)78					return79				}80				a.Unknowns = append(a.Unknowns, atom)81			}82		}83		n += size84	}85	return86}87func (a MovieFrag) Children() (r []Atom) {88	if a.Header != nil {89		r = append(r, a.Header)90	}91	for _, atom := range a.Tracks {92		r = append(r, atom)93	}94	r = append(r, a.Unknowns...)95	return96}97func (a MovieFrag) Tag() Tag {98	return MOOF99}100const MFHD = Tag(0x6d666864)101type MovieFragHeader struct {102	Version uint8103	Flags   uint32104	Seqnum  uint32105	AtomPos106}107func (a MovieFragHeader) Marshal(b []byte) (n int) {108	pio.PutU32BE(b[4:], uint32(MFHD))109	n += a.marshal(b[8:]) + 8110	pio.PutU32BE(b[0:], uint32(n))111	return112}113func (a MovieFragHeader) marshal(b []byte) (n int) {114	pio.PutU8(b[n:], a.Version)115	n += 1116	pio.PutU24BE(b[n:], a.Flags)117	n += 3118	pio.PutU32BE(b[n:], a.Seqnum)119	n += 4120	return121}122func (a MovieFragHeader) Len() (n int) {123	n += 8124	n += 1125	n += 3126	n += 4127	return128}129func (a *MovieFragHeader) Unmarshal(b []byte, offset int) (n int, err error) {130	(&a.AtomPos).setPos(offset, len(b))131	n += 8132	if len(b) < n+1 {133		err = parseErr("Version", n+offset, err)134		return135	}136	a.Version = pio.U8(b[n:])137	n += 1138	if len(b) < n+3 {139		err = parseErr("Flags", n+offset, err)140		return141	}142	a.Flags = pio.U24BE(b[n:])143	n += 3144	if len(b) < n+4 {145		err = parseErr("Seqnum", n+offset, err)146		return147	}148	a.Seqnum = pio.U32BE(b[n:])149	n += 4150	return151}152func (a MovieFragHeader) Children() (r []Atom) {153	return154}155func (a MovieFragHeader) Tag() Tag {156	return MFHD157}158// TRUN is the atom type for TrackFragRun159const TRUN = Tag(0x7472756e)160// TrackFragRun atom161type TrackFragRun struct {162	Version          uint8163	Flags            TrackRunFlags164	DataOffset       uint32165	FirstSampleFlags SampleFlags166	Entries          []TrackFragRunEntry167	AtomPos168}169// TrackRunFlags is the type of TrackFragRun's Flags170type TrackRunFlags uint32171// Defined flags for TrackFragRun172const (173	TrackRunDataOffset       TrackRunFlags = 0x01174	TrackRunFirstSampleFlags TrackRunFlags = 0x04175	TrackRunSampleDuration   TrackRunFlags = 0x100176	TrackRunSampleSize       TrackRunFlags = 0x200177	TrackRunSampleFlags      TrackRunFlags = 0x400178	TrackRunSampleCTS        TrackRunFlags = 0x800179)180func (a TrackFragRun) Marshal(b []byte) (n int) {181	pio.PutU32BE(b[4:], uint32(TRUN))182	n += a.marshal(b[8:]) + 8183	pio.PutU32BE(b[0:], uint32(n))184	return185}186func (a TrackFragRun) marshal(b []byte) (n int) {187	pio.PutU8(b[n:], a.Version)188	n += 1189	pio.PutU24BE(b[n:], uint32(a.Flags))190	n += 3191	pio.PutU32BE(b[n:], uint32(len(a.Entries)))192	n += 4193	if a.Flags&TrackRunDataOffset != 0 {194		{195			pio.PutU32BE(b[n:], a.DataOffset)196			n += 4197		}198	}199	if a.Flags&TrackRunFirstSampleFlags != 0 {200		{201			pio.PutU32BE(b[n:], uint32(a.FirstSampleFlags))202			n += 4203		}204	}205	for _, entry := range a.Entries {206		if a.Flags&TrackRunSampleDuration != 0 {207			pio.PutU32BE(b[n:], entry.Duration)208			n += 4209		}210		if a.Flags&TrackRunSampleSize != 0 {211			pio.PutU32BE(b[n:], entry.Size)212			n += 4213		}214		if a.Flags&TrackRunSampleFlags != 0 {215			pio.PutU32BE(b[n:], uint32(entry.Flags))216			n += 4217		}218		if a.Flags&TrackRunSampleCTS != 0 {219			if a.Version > 0 {220				pio.PutI32BE(b[:n], int32(entry.CTS))221			} else {222				pio.PutU32BE(b[n:], uint32(entry.CTS))223			}224			n += 4225		}226	}227	return228}229func (a TrackFragRun) Len() (n int) {230	n += 8231	n += 1232	n += 3233	n += 4234	if a.Flags&TrackRunDataOffset != 0 {235		{236			n += 4237		}238	}239	if a.Flags&TrackRunFirstSampleFlags != 0 {240		{241			n += 4242		}243	}244	for range a.Entries {245		if a.Flags&TrackRunSampleDuration != 0 {246			n += 4247		}248		if a.Flags&TrackRunSampleSize != 0 {249			n += 4250		}251		if a.Flags&TrackRunSampleFlags != 0 {252			n += 4253		}254		if a.Flags&TrackRunSampleCTS != 0 {255			n += 4256		}257	}258	return259}260func (a *TrackFragRun) Unmarshal(b []byte, offset int) (n int, err error) {261	(&a.AtomPos).setPos(offset, len(b))262	n += 8263	if len(b) < n+1 {264		err = parseErr("Version", n+offset, err)265		return266	}267	a.Version = pio.U8(b[n:])268	n += 1269	if len(b) < n+3 {270		err = parseErr("Flags", n+offset, err)271		return272	}273	a.Flags = TrackRunFlags(pio.U24BE(b[n:]))274	n += 3275	var _len_Entries uint32276	_len_Entries = pio.U32BE(b[n:])277	n += 4278	a.Entries = make([]TrackFragRunEntry, _len_Entries)279	if a.Flags&TrackRunDataOffset != 0 {280		{281			if len(b) < n+4 {282				err = parseErr("DataOffset", n+offset, err)283				return284			}285			a.DataOffset = pio.U32BE(b[n:])286			n += 4287		}288	}289	if a.Flags&TrackRunFirstSampleFlags != 0 {290		{291			if len(b) < n+4 {292				err = parseErr("FirstSampleFlags", n+offset, err)293				return294			}295			a.FirstSampleFlags = SampleFlags(pio.U32BE(b[n:]))296			n += 4297		}298	}299	for i := 0; i < int(_len_Entries); i++ {300		entry := &a.Entries[i]301		if a.Flags&TrackRunSampleDuration != 0 {302			entry.Duration = pio.U32BE(b[n:])303			n += 4304		}305		if a.Flags&TrackRunSampleSize != 0 {306			entry.Size = pio.U32BE(b[n:])307			n += 4308		}309		if a.Flags&TrackRunSampleFlags != 0 {310			entry.Flags = SampleFlags(pio.U32BE(b[n:]))311			n += 4312		}313		if a.Flags&TrackRunSampleCTS != 0 {314			if a.Version > 0 {315				entry.CTS = int32(pio.I32BE(b[n:]))316			} else {317				entry.CTS = int32(pio.U32BE(b[n:]))318			}319			n += 4320		}321	}322	return323}324func (a TrackFragRun) Children() (r []Atom) {325	return326}327type TrackFragRunEntry struct {328	Duration uint32329	Size     uint32330	Flags    SampleFlags331	CTS      int32332}333func (a TrackFragRun) Tag() Tag {334	return TRUN335}336const TFDT = Tag(0x74666474)337type TrackFragDecodeTime struct {338	Version uint8339	Flags   uint32340	Time    uint64341	AtomPos342}343func (a TrackFragDecodeTime) Marshal(b []byte) (n int) {344	pio.PutU32BE(b[4:], uint32(TFDT))345	n += a.marshal(b[8:]) + 8346	pio.PutU32BE(b[0:], uint32(n))347	return348}349func (a TrackFragDecodeTime) marshal(b []byte) (n int) {350	pio.PutU8(b[n:], a.Version)351	n += 1352	pio.PutU24BE(b[n:], a.Flags)353	n += 3354	if a.Version != 0 {355		pio.PutU64BE(b[n:], a.Time)356		n += 8357	} else {358		pio.PutU32BE(b[n:], uint32(a.Time))359		n += 4360	}361	return362}363func (a TrackFragDecodeTime) Len() (n int) {364	n += 8365	n += 1366	n += 3367	if a.Version != 0 {368		n += 8369	} else {370		n += 4371	}372	return373}374func (a *TrackFragDecodeTime) Unmarshal(b []byte, offset int) (n int, err error) {375	(&a.AtomPos).setPos(offset, len(b))376	n += 8377	if len(b) < n+1 {378		err = parseErr("Version", n+offset, err)379		return380	}381	a.Version = pio.U8(b[n:])382	n += 1383	if len(b) < n+3 {384		err = parseErr("Flags", n+offset, err)385		return386	}387	a.Flags = pio.U24BE(b[n:])388	n += 3389	if a.Version != 0 {390		a.Time = pio.U64BE(b[n:])391		n += 8392	} else {393		a.Time = uint64(pio.U32BE(b[n:]))394		n += 4395	}396	return397}398func (a TrackFragDecodeTime) Children() (r []Atom) {399	return400}401func (a TrackFragDecodeTime) Tag() Tag {402	return TFDT403}404const TRAF = Tag(0x74726166)405type TrackFrag struct {406	Header     *TrackFragHeader407	DecodeTime *TrackFragDecodeTime408	Run        *TrackFragRun409	Unknowns   []Atom410	AtomPos411}412func (a TrackFrag) Marshal(b []byte) (n int) {413	pio.PutU32BE(b[4:], uint32(TRAF))414	n += a.marshal(b[8:]) + 8415	pio.PutU32BE(b[0:], uint32(n))416	return417}418func (a TrackFrag) marshal(b []byte) (n int) {419	if a.Header != nil {420		n += a.Header.Marshal(b[n:])421	}422	if a.DecodeTime != nil {423		n += a.DecodeTime.Marshal(b[n:])424	}425	if a.Run != nil {426		n += a.Run.Marshal(b[n:])427	}428	for _, atom := range a.Unknowns {429		n += atom.Marshal(b[n:])430	}431	return432}433func (a TrackFrag) Len() (n int) {434	n += 8435	if a.Header != nil {436		n += a.Header.Len()437	}438	if a.DecodeTime != nil {439		n += a.DecodeTime.Len()440	}441	if a.Run != nil {442		n += a.Run.Len()443	}444	for _, atom := range a.Unknowns {445		n += atom.Len()446	}447	return448}449func (a *TrackFrag) Unmarshal(b []byte, offset int) (n int, err error) {450	(&a.AtomPos).setPos(offset, len(b))451	n += 8452	for n+8 < len(b) {453		tag := Tag(pio.U32BE(b[n+4:]))454		size := int(pio.U32BE(b[n:]))455		if len(b) < n+size {456			err = parseErr("TagSizeInvalid", n+offset, err)457			return458		}459		switch tag {460		case TFHD:461			{462				atom := &TrackFragHeader{}463				if _, err = atom.Unmarshal(b[n:n+size], offset+n); err != nil {464					err = parseErr("tfhd", n+offset, err)465					return466				}467				a.Header = atom468			}469		case TFDT:470			{471				atom := &TrackFragDecodeTime{}472				if _, err = atom.Unmarshal(b[n:n+size], offset+n); err != nil {473					err = parseErr("tfdt", n+offset, err)474					return475				}476				a.DecodeTime = atom477			}478		case TRUN:479			{480				atom := &TrackFragRun{}481				if _, err = atom.Unmarshal(b[n:n+size], offset+n); err != nil {482					err = parseErr("trun", n+offset, err)483					return484				}485				a.Run = atom486			}487		default:488			{489				atom := &Dummy{Tag_: tag, Data: b[n : n+size]}490				if _, err = atom.Unmarshal(b[n:n+size], offset+n); err != nil {491					err = parseErr("", n+offset, err)492					return493				}494				a.Unknowns = append(a.Unknowns, atom)495			}496		}497		n += size498	}499	return500}501func (a TrackFrag) Children() (r []Atom) {502	if a.Header != nil {503		r = append(r, a.Header)504	}505	if a.DecodeTime != nil {506		r = append(r, a.DecodeTime)507	}508	if a.Run != nil {509		r = append(r, a.Run)510	}511	r = append(r, a.Unknowns...)512	return513}514func (a TrackFrag) Tag() Tag {515	return TRAF516}517func (a TrackFragRun) String() string {518	return fmt.Sprintf("dataoffset=%d", a.DataOffset)519}520// TFHD is the atom type for TrackFragHeader521const TFHD = Tag(0x74666864)522// TrackFragHeader atom523type TrackFragHeader struct {524	Version         uint8525	Flags           TrackFragFlags526	TrackID         uint32527	BaseDataOffset  uint64528	StsdID          uint32529	DefaultDuration uint32530	DefaultSize     uint32531	DefaultFlags    SampleFlags532	AtomPos533}534// TrackFragFlags is the type of TrackFragHeader's Flags535type TrackFragFlags uint32536// Defined flags for TrackFragHeader537const (538	TrackFragBaseDataOffset    TrackFragFlags = 0x01539	TrackFragStsdID            TrackFragFlags = 0x02540	TrackFragDefaultDuration   TrackFragFlags = 0x08541	TrackFragDefaultSize       TrackFragFlags = 0x10542	TrackFragDefaultFlags      TrackFragFlags = 0x20543	TrackFragDurationIsEmpty   TrackFragFlags = 0x010000544	TrackFragDefaultBaseIsMOOF TrackFragFlags = 0x020000545)546func (a TrackFragHeader) Marshal(b []byte) (n int) {547	pio.PutU32BE(b[4:], uint32(TFHD))548	n += a.marshal(b[8:]) + 8549	pio.PutU32BE(b[0:], uint32(n))550	return551}552func (a TrackFragHeader) marshal(b []byte) (n int) {553	pio.PutU8(b[n:], a.Version)554	n += 1555	pio.PutU24BE(b[n:], uint32(a.Flags))556	n += 3557	pio.PutU32BE(b[n:], a.TrackID)558	n += 4559	if a.Flags&TrackFragBaseDataOffset != 0 {560		{561			pio.PutU64BE(b[n:], a.BaseDataOffset)562			n += 8563		}564	}565	if a.Flags&TrackFragStsdID != 0 {566		{567			pio.PutU32BE(b[n:], a.StsdID)568			n += 4569		}570	}571	if a.Flags&TrackFragDefaultDuration != 0 {572		{573			pio.PutU32BE(b[n:], a.DefaultDuration)574			n += 4575		}576	}577	if a.Flags&TrackFragDefaultSize != 0 {578		{579			pio.PutU32BE(b[n:], a.DefaultSize)580			n += 4581		}582	}583	if a.Flags&TrackFragDefaultFlags != 0 {584		{585			pio.PutU32BE(b[n:], uint32(a.DefaultFlags))586			n += 4587		}588	}589	return590}591func (a TrackFragHeader) Len() (n int) {592	n += 8593	n += 1594	n += 3595	n += 4596	if a.Flags&TrackFragBaseDataOffset != 0 {597		{598			n += 8599		}...

rleplus_writer.go

Source:rleplus_writer.go

...3	"encoding/binary"4)5func EncodeRuns(rit RunIterator, buf []byte) ([]byte, error) {6	bv := writeBitvec(buf)7	bv.Put(0, 2)8	first := true9	varBuf := make([]byte, binary.MaxVarintLen64)10	for rit.HasNext() {11		run, err := rit.NextRun()12		if err != nil {13			return nil, err14		}15		if first {16			if run.Val {17				bv.Put(1, 1)18			} else {19				bv.Put(0, 1)20			}21			first = false22		}23		switch {24		case run.Len == 1:25			bv.Put(1, 1)26		case run.Len < 16:27			bv.Put(2, 2)28			bv.Put(byte(run.Len), 4)29		case run.Len >= 16:30			bv.Put(0, 2)31			numBytes := binary.PutUvarint(varBuf, run.Len)32			for i := 0; i < numBytes; i++ {33				bv.Put(varBuf[i], 8)34			}35		}36	}37	if first {38		bv.Put(0, 1)39	}40	return bv.Out(), nil41}

Put

Using AI Code Generation

1run.Put(1, "abc");2run.Put(2, "def");3run.Put(3, "ghi");4run.Put(4, "jkl");5run.Put(5, "mno");6run.Put(6, "pqr");7run.Put(7, "stu");8run.Put(8, "vwx");9run.Put(9, "yz");10run.Put(10, "123");11System.out.println(run.Get(1));12System.out.println(run.Get(2));13System.out.println(run.Get(3));14System.out.println(run.Get(4));15System.out.println(run.Get(5));16System.out.println(run.Get(6));17System.out.println(run.Get(7));18System.out.println(run.Get(8));19System.out.println(run.Get(9));20System.out.println(run.Get(10));21run.Delete(1);22run.Delete(2);23run.Delete(3);24run.Delete(4);25run.Delete(5);26run.Delete(6);27run.Delete(7);28run.Delete(8);29run.Delete(9);30run.Delete(10);31System.out.println(run.Get(1));32System.out.println(run.Get(2));33System.out.println(run.Get(3));34System.out.println(run.Get(4));35System.out.println(run.Get(5));36System.out.println(run.Get(6));37System.out.println(run.Get(7));38System.out.println(run.Get(8));39System.out.println(run.Get(9));40System.out.println(run.Get(10));41}42}

Put

Using AI Code Generation

1run.Put("Key1","Value1")2run.Put("Key2","Value2")3run.Put("Key3","Value3")4run.Get("Key1")5run.Get("Key2")6run.Get("Key3")7run.Delete("Key1")8run.Delete("Key2")9run.Delete("Key3")10run.Update("Key1","Value1")11run.Update("Key2","Value2")12run.Update("Key3","Value3")13run.Get("Key1")14run.Get("Key2")15run.Get("Key3")16run.List()

Put

Using AI Code Generation

1import (2func main() {3	fmt.Println("Hello, playground")4}5import (6func main() {7	fmt.Println("Hello, playground")8}9import (10func main() {11	fmt.Println("Hello, playground")12}13import (14func main() {15	fmt.Println("Hello, playground")16}17import (18func main() {19	fmt.Println("Hello, playground")20}21import (22func main() {23	fmt.Println("Hello, playground")24}25import (26func main() {27	fmt.Println("Hello, playground")28}29import (30func main() {31	fmt.Println("Hello, playground")32}33import (34func main() {35	fmt.Println("Hello, playground")36}37import (38func main() {39	fmt.Println("Hello, playground")40}41import (42func main() {43	fmt.Println("Hello, playground")44}45import (46func main() {47	fmt.Println("Hello, playground")48}49import (50func main() {51	fmt.Println("Hello, playground")52}53import

Put

Using AI Code Generation

1import "fmt"2type run struct {3}4func (r *run) Put(v int) {5}6func main() {7    r := run{}8    r.Put(5)9    fmt.Println(r.value)10}11import "fmt"12type run struct {13}14func (r *run) Put(v int) {15}16func main() {17    r.Put(5)18    fmt.Println(r.value)19}20import "fmt"21type run struct {22}23func (r *run) Put(v int) {24}25func main() {26    r.Put(5)27    fmt.Println(r.value)28}29import "fmt"30type run struct {31}32func (r *run) Put(v int) {33}34func main() {35    r := &run{}36    r.Put(5)37    fmt.Println(r.value)38}39import "fmt"40type run struct {41}42func (r *run) Put(v int) {43}44func main() {45    r.Put(5)46    fmt.Println(r.value)47}

Put

Using AI Code Generation

1import (2func main() {3    cmd := exec.Command("ls")4    err := cmd.Start()5    if err != nil {6        log.Fatal(err)7    }8    time.Sleep(1 * time.Second)9    err = cmd.Process.Kill()10    if err != nil {11        log.Fatal("failed to kill: ", err)12    }13}

Put

Using AI Code Generation

1import (2func main() {3    runner := run.New()4    runner.Put("hello")5    fmt.Println(runner.Get())6}7import (8func main() {9    runner := run.New()10    fmt.Println(runner.Get())11}12In the above code, we have defined two packages, one is 1.go and another is 2.go. In 1.go, we have used Put() method of run class and in 2.go, we have used Get() method of run class. Now, if you run the above code, it will give you the following error:

Put

Using AI Code Generation

1import (2func main() {3	fmt.Println("Hello, playground")4	runtime.GOMAXPROCS(3)5	run := &run{}6	go run.Put(10)7	go run.Put(20)8	go run.Put(30)9	go run.Put(40)10	go run.Put(50)11	go run.Put(60)12	go run.Put(70)13	go run.Put(80)14	go run.Put(90)15	go run.Put(100)16	go run.Put(110)17	go run.Put(120)18	go run.Put(130)19	go run.Put(140)20	go run.Put(150)21	go run.Put(160)22	go run.Put(170)23	go run.Put(180)24	go run.Put(190)25	go run.Put(200)26	go run.Put(210)27	go run.Put(220)28	go run.Put(230)29	go run.Put(240)30	go run.Put(250)31	go run.Put(260)32	go run.Put(270)33	go run.Put(280)34	go run.Put(290)35	go run.Put(300)36	time.Sleep(time.Second * 10)37}38import (39func main() {40	fmt.Println("Hello, playground")

Put

Using AI Code Generation

1type Run struct {2}3func (r *Run) Put() {4}5func (r *Run) Get() {6}7import (8func main() {9    r := new(run.Run)10    r.Put()11}12import (13func main() {14    r := new(run.Run)15    r.Get()16}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.