func TestParallel(t *testing.T) { defer leaktest.AfterTest(t)() if testutils.Stress() { t.Skip() } glob := string(*paralleltestdata) paths, err := filepath.Glob(glob) if err != nil { t.Fatal(err) } if len(paths) == 0 { t.Fatalf("No testfiles found (glob: %s)", glob) } total := 0 for _, path := range paths { t.Run(filepath.Base(path), func(t *testing.T) { pt := parallelTest{T: t, ctx: context.Background()} pt.run(path) total++ }) } log.Infof(context.Background(), "%d parallel tests passed", total) }
func TestLogic(t *testing.T) { defer leaktest.AfterTest(t)() if testutils.Stress() { t.Skip() } var globs []string if *bigtest { const logicTestPath = "../../sqllogictest" if _, err := os.Stat(logicTestPath); os.IsNotExist(err) { fullPath, err := filepath.Abs(logicTestPath) if err != nil { t.Fatal(err) } t.Fatalf("unable to find sqllogictest repo: %s\n"+ "git clone https://github.com/cockroachdb/sqllogictest %s", logicTestPath, fullPath) return } globs = []string{ logicTestPath + "/test/index/between/*/*.test", logicTestPath + "/test/index/commute/*/*.test", logicTestPath + "/test/index/delete/*/*.test", logicTestPath + "/test/index/in/*/*.test", logicTestPath + "/test/index/orderby/*/*.test", logicTestPath + "/test/index/orderby_nosort/*/*.test", // TODO(pmattis): We don't support aggregate functions. // logicTestPath + "/test/random/expr/*.test", // TODO(pmattis): We don't support tables without primary keys. // logicTestPath + "/test/select*.test", // TODO(pmattis): We don't support views. // logicTestPath + "/test/index/view/*/*.test", // TODO(pmattis): We don't support joins. // [uses joins] logicTestPath + "/test/index/random/*/*.test", // [uses joins] logicTestPath + "/test/random/aggregates/*.test", // [uses joins] logicTestPath + "/test/random/groupby/*.test", // [uses joins] logicTestPath + "/test/random/select/*.test", } } else { globs = []string{*logictestdata} } var paths []string for _, g := range globs { match, err := filepath.Glob(g) if err != nil { t.Fatal(err) } paths = append(paths, match...) } if len(paths) == 0 { t.Fatalf("No testfiles found (globs: %v)", globs) } total := 0 totalFail := 0 totalUnsupported := 0 lastProgress := timeutil.Now() l := logicTest{ t: t, verbose: testing.Verbose() || log.V(1), perErrorSummary: make(map[string][]string), } if *printErrorSummary { defer l.printErrorSummary() } for _, path := range paths { t.Run(path, func(t *testing.T) { // the `t` given to this anonymous function may be different // from the t above, so re-bind it to `l` for the duration of // the test. l.t = t defer l.close() l.setup() if err := l.processTestFile(path); err != nil { t.Error(err) } }) total += l.progress totalFail += l.failures totalUnsupported += l.unsupported now := timeutil.Now() if now.Sub(lastProgress) >= 2*time.Second { lastProgress = now fmt.Printf("--- total progress: %d statements/queries\n", total) } } unsupportedMsg := "" if totalUnsupported > 0 { unsupportedMsg = fmt.Sprintf(", ignored %d unsupported queries", totalUnsupported) } fmt.Printf("--- total: %d tests, %d failures%s\n", total, totalFail, unsupportedMsg) }
func TestConcurrentBatch(t *testing.T) { defer leaktest.AfterTest(t)() if testutils.Stress() { t.Skip() } dir, err := ioutil.TempDir("", "TestConcurrentBatch") if err != nil { t.Fatal(err) } defer func() { if err := os.RemoveAll(dir); err != nil { t.Fatal(err) } }() db, err := NewRocksDB(roachpb.Attributes{}, dir, RocksDBCache{}, 0, DefaultMaxOpenFiles) if err != nil { t.Fatalf("could not create new rocksdb db instance at %s: %v", dir, err) } defer db.Close() // Prepare 16 4 MB batches containing non-overlapping contents. var batches []Batch for i := 0; i < 16; i++ { batch := db.NewBatch() for j := 0; true; j++ { key := encoding.EncodeUvarintAscending([]byte("bar"), uint64(i)) key = encoding.EncodeUvarintAscending(key, uint64(j)) if err := batch.Put(MakeMVCCMetadataKey(key), nil); err != nil { t.Fatal(err) } if len(batch.Repr()) >= 4<<20 { break } } batches = append(batches, batch) } errChan := make(chan error, len(batches)) // Concurrently write all the batches. for _, batch := range batches { go func(batch Batch) { errChan <- batch.Commit() }(batch) } // While the batch writes are in progress, try to write another key. time.Sleep(100 * time.Millisecond) remainingBatches := len(batches) for i := 0; remainingBatches > 0; i++ { select { case err := <-errChan: if err != nil { t.Fatal(err) } remainingBatches-- default: } // This write can get delayed excessively if we hit the max memtable count // or the L0 stop writes threshold. start := timeutil.Now() key := encoding.EncodeUvarintAscending([]byte("foo"), uint64(i)) if err := db.Put(MakeMVCCMetadataKey(key), nil); err != nil { t.Fatal(err) } if elapsed := timeutil.Since(start); elapsed >= 10*time.Second { t.Fatalf("write took %0.1fs\n", elapsed.Seconds()) } } }