NextGraph
/
rust-rocksdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #228 from iSynaptic/drop_after_tests

Browse Source 
Renaming DBName to DBPath
master
Jordan Terrell 6 years ago committed by GitHub
parent 83a4a28f74 16183467ef
commit 60dbdc92dc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 234 additions and 189 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 48
      tests/test_column_family.rs
  2. 14
      tests/test_iterator.rs
  3. 10
      tests/test_multithreaded.rs
  4. 230
      tests/test_raw_iterator.rs
  5. 15
      tests/test_rocksdb_options.rs
  6. 65
      tests/test_slice_transform.rs
  7. 41
      tests/util/mod.rs

48
tests/test_column_family.rs
Unescape View File

@ -13,22 +13,24 @@
// limitations under the License. // limitations under the License.
// //
extern crate rocksdb; extern crate rocksdb;
mod util;
use rocksdb::{DB, MergeOperands, Options, ColumnFamilyDescriptor}; use rocksdb::{DB, MergeOperands, Options, ColumnFamilyDescriptor};
use util::DBPath;
#[test] #[test]
pub fn test_column_family() { pub fn test_column_family() {
let path = "_rust_rocksdb_cftest"; let n = DBPath::new("_rust_rocksdb_cftest");
// should be able to create column families // should be able to create column families
{ {
let mut opts = Options::default(); let mut opts = Options::default();
opts.create_if_missing(true); opts.create_if_missing(true);
opts.set_merge_operator("test operator", test_provided_merge, None); opts.set_merge_operator("test operator", test_provided_merge, None);
let mut db = DB::open(&opts, path).unwrap(); let mut db = DB::open(&opts, &n).unwrap();
let opts = Options::default(); let opts = Options::default();
match db.create_cf("cf1", &opts) { match db.create_cf("cf1", &opts) {
Ok(_) => println!("cf1 created successfully"), Ok(_db) => println!("cf1 created successfully"),
Err(e) => { Err(e) => {
panic!("could not create column family: {}", e); panic!("could not create column family: {}", e);
} }
@ -39,8 +41,8 @@ pub fn test_column_family() {
{ {
let mut opts = Options::default(); let mut opts = Options::default();
opts.set_merge_operator("test operator", test_provided_merge, None); opts.set_merge_operator("test operator", test_provided_merge, None);
match DB::open(&opts, path) { match DB::open(&opts, &n) {
Ok(_) => { Ok(_db) => {
panic!("should not have opened DB successfully without \ panic!("should not have opened DB successfully without \
specifying column specifying column
families") families")
@ -57,8 +59,8 @@ pub fn test_column_family() {
{ {
let mut opts = Options::default(); let mut opts = Options::default();
opts.set_merge_operator("test operator", test_provided_merge, None); opts.set_merge_operator("test operator", test_provided_merge, None);
match DB::open_cf(&opts, path, &["cf1"]) { match DB::open_cf(&opts, &n, &["cf1"]) {
Ok(_) => println!("successfully opened db with column family"), Ok(_db) => println!("successfully opened db with column family"),
Err(e) => panic!("failed to open db with column family: {}", e), Err(e) => panic!("failed to open db with column family: {}", e),
} }
} }
@ -66,7 +68,7 @@ pub fn test_column_family() {
// should be able to list a cf // should be able to list a cf
{ {
let opts = Options::default(); let opts = Options::default();
let vec = DB::list_cf(&opts, path); let vec = DB::list_cf(&opts, &n);
match vec { match vec {
Ok(vec) => assert_eq!(vec, vec!["default", "cf1"]), Ok(vec) => assert_eq!(vec, vec!["default", "cf1"]),
Err(e) => panic!("failed to drop column family: {}", e), Err(e) => panic!("failed to drop column family: {}", e),
@ -81,19 +83,17 @@ pub fn test_column_family() {
} }
// should b able to drop a cf // should b able to drop a cf
{ {
let mut db = DB::open_cf(&Options::default(), path, &["cf1"]).unwrap(); let mut db = DB::open_cf(&Options::default(), &n, &["cf1"]).unwrap();
match db.drop_cf("cf1") { match db.drop_cf("cf1") {
Ok(_) => println!("cf1 successfully dropped."), Ok(_) => println!("cf1 successfully dropped."),
Err(e) => panic!("failed to drop column family: {}", e), Err(e) => panic!("failed to drop column family: {}", e),
} }
} }
assert!(DB::destroy(&Options::default(), path).is_ok());
} }
#[test] #[test]
fn test_create_missing_column_family() { fn test_create_missing_column_family() {
let path = "_rust_rocksdb_missing_cftest"; let n = DBPath::new("_rust_rocksdb_missing_cftest");
// should be able to create new column families when opening a new database // should be able to create new column families when opening a new database
{ {
@ -101,24 +101,22 @@ fn test_create_missing_column_family() {
opts.create_if_missing(true); opts.create_if_missing(true);
opts.create_missing_column_families(true); opts.create_missing_column_families(true);
match DB::open_cf(&opts, path, &["cf1"]) { match DB::open_cf(&opts, &n, &["cf1"]) {
Ok(_) => println!("successfully created new column family"), Ok(_db) => println!("successfully created new column family"),
Err(e) => panic!("failed to create new column family: {}", e), Err(e) => panic!("failed to create new column family: {}", e),
} }
} }
assert!(DB::destroy(&Options::default(), path).is_ok());
} }
#[test] #[test]
#[ignore] #[ignore]
fn test_merge_operator() { fn test_merge_operator() {
let path = "_rust_rocksdb_cftest_merge"; let n = DBPath::new("_rust_rocksdb_cftest_merge");
// TODO should be able to write, read, merge, batch, and iterate over a cf // TODO should be able to write, read, merge, batch, and iterate over a cf
{ {
let mut opts = Options::default(); let mut opts = Options::default();
opts.set_merge_operator("test operator", test_provided_merge, None); opts.set_merge_operator("test operator", test_provided_merge, None);
let db = match DB::open_cf(&opts, path, &["cf1"]) { let db = match DB::open_cf(&opts, &n, &["cf1"]) {
Ok(db) => { Ok(db) => {
println!("successfully opened db with column family"); println!("successfully opened db with column family");
db db
@ -180,7 +178,7 @@ fn test_provided_merge(_: &[u8],
#[test] #[test]
pub fn test_column_family_with_options() { pub fn test_column_family_with_options() {
let path = "_rust_rocksdb_cf_with_optionstest"; let n = DBPath::new("_rust_rocksdb_cf_with_optionstest");
{ {
let mut cfopts = Options::default(); let mut cfopts = Options::default();
cfopts.set_max_write_buffer_number(16); cfopts.set_max_write_buffer_number(16);
@ -191,8 +189,8 @@ pub fn test_column_family_with_options() {
opts.create_missing_column_families(true); opts.create_missing_column_families(true);
let cfs = vec![cf_descriptor]; let cfs = vec![cf_descriptor];
match DB::open_cf_descriptors(&opts, path, cfs) { match DB::open_cf_descriptors(&opts, &n, cfs) {
Ok(_) => println!("created db with column family descriptors succesfully"), Ok(_db) => println!("created db with column family descriptors succesfully"),
Err(e) => { Err(e) => {
panic!("could not create new database with column family descriptors: {}", e); panic!("could not create new database with column family descriptors: {}", e);
} }
@ -207,13 +205,11 @@ pub fn test_column_family_with_options() {
let opts = Options::default(); let opts = Options::default();
let cfs = vec![cf_descriptor]; let cfs = vec![cf_descriptor];
match DB::open_cf_descriptors(&opts, path, cfs) { match DB::open_cf_descriptors(&opts, &n, cfs) {
Ok(_) => println!("succesfully re-opened database with column family descriptorrs"), Ok(_db) => println!("succesfully re-opened database with column family descriptors"),
Err(e) => { Err(e) => {
panic!("unable to re-open database with column family descriptors: {}", e); panic!("unable to re-open database with column family descriptors: {}", e);
} }
} }
} }
}
assert!(DB::destroy(&Options::default(), path).is_ok());
}

14
tests/test_iterator.rs
Unescape View File

@ -13,8 +13,10 @@
// limitations under the License. // limitations under the License.
// //
extern crate rocksdb; extern crate rocksdb;
mod util;
use rocksdb::{DB, Direction, IteratorMode, MemtableFactory, Options}; use rocksdb::{DB, Direction, IteratorMode, MemtableFactory, Options};
use util::DBPath;
fn cba(input: &Box<[u8]>) -> Box<[u8]> { fn cba(input: &Box<[u8]>) -> Box<[u8]> {
input.iter().cloned().collect::<Vec<_>>().into_boxed_slice() input.iter().cloned().collect::<Vec<_>>().into_boxed_slice()
@ -22,7 +24,7 @@ fn cba(input: &Box<[u8]>) -> Box<[u8]> {
#[test] #[test]
pub fn test_iterator() { pub fn test_iterator() {
let path = "_rust_rocksdb_iteratortest"; let n = DBPath::new("_rust_rocksdb_iteratortest");
{ {
let k1: Box<[u8]> = b"k1".to_vec().into_boxed_slice(); let k1: Box<[u8]> = b"k1".to_vec().into_boxed_slice();
let k2: Box<[u8]> = b"k2".to_vec().into_boxed_slice(); let k2: Box<[u8]> = b"k2".to_vec().into_boxed_slice();
@ -32,7 +34,7 @@ pub fn test_iterator() {
let v2: Box<[u8]> = b"v2222".to_vec().into_boxed_slice(); let v2: Box<[u8]> = b"v2222".to_vec().into_boxed_slice();
let v3: Box<[u8]> = b"v3333".to_vec().into_boxed_slice(); let v3: Box<[u8]> = b"v3333".to_vec().into_boxed_slice();
let v4: Box<[u8]> = b"v4444".to_vec().into_boxed_slice(); let v4: Box<[u8]> = b"v4444".to_vec().into_boxed_slice();
let db = DB::open_default(path).unwrap(); let db = DB::open_default(&n).unwrap();
let p = db.put(&*k1, &*v1); let p = db.put(&*k1, &*v1);
assert!(p.is_ok()); assert!(p.is_ok());
let p = db.put(&*k2, &*v2); let p = db.put(&*k2, &*v2);
@ -153,15 +155,13 @@ pub fn test_iterator() {
assert!(!iterator1.valid()); assert!(!iterator1.valid());
} }
} }
let opts = Options::default();
assert!(DB::destroy(&opts, path).is_ok());
} }
fn key(k: &[u8]) -> Box<[u8]> { k.to_vec().into_boxed_slice() } fn key(k: &[u8]) -> Box<[u8]> { k.to_vec().into_boxed_slice() }
#[test] #[test]
pub fn test_prefix_iterator() { pub fn test_prefix_iterator() {
let path = "_rust_rocksdb_prefixiteratortest"; let n = DBPath::new("_rust_rocksdb_prefixiteratortest");
{ {
let a1: Box<[u8]> = key(b"aaa1"); let a1: Box<[u8]> = key(b"aaa1");
let a2: Box<[u8]> = key(b"aaa2"); let a2: Box<[u8]> = key(b"aaa2");
@ -174,7 +174,7 @@ pub fn test_prefix_iterator() {
opts.create_if_missing(true); opts.create_if_missing(true);
opts.set_prefix_extractor(prefix_extractor); opts.set_prefix_extractor(prefix_extractor);
let db = DB::open(&opts, path).unwrap(); let db = DB::open(&opts, &n).unwrap();
assert!(db.put(&*a1, &*a1).is_ok()); assert!(db.put(&*a1, &*a1).is_ok());
assert!(db.put(&*a2, &*a2).is_ok()); assert!(db.put(&*a2, &*a2).is_ok());
@ -193,8 +193,6 @@ pub fn test_prefix_iterator() {
assert_eq!(b_iterator.collect::<Vec<_>>(), expected) assert_eq!(b_iterator.collect::<Vec<_>>(), expected)
} }
} }
let opts = Options::default();
assert!(DB::destroy(&opts, path).is_ok());
} }
#[test] #[test]

10
tests/test_multithreaded.rs
Unescape View File

@ -13,18 +13,21 @@
// limitations under the License. // limitations under the License.
// //
extern crate rocksdb; extern crate rocksdb;
mod util;
use rocksdb::{DB, Options}; use rocksdb::DB;
use std::thread; use std::thread;
use std::sync::Arc; use std::sync::Arc;
use util::DBPath;
const N: usize = 100_000; const N: usize = 100_000;
#[test] #[test]
pub fn test_multithreaded() { pub fn test_multithreaded() {
let path = "_rust_rocksdb_multithreadtest"; let n = DBPath::new("_rust_rocksdb_multithreadtest");
{ {
let db = DB::open_default(path).unwrap(); let db = DB::open_default(&n).unwrap();
let db = Arc::new(db); let db = Arc::new(db);
db.put(b"key", b"value1").unwrap(); db.put(b"key", b"value1").unwrap();
@ -63,5 +66,4 @@ pub fn test_multithreaded() {
j2.join().unwrap(); j2.join().unwrap();
j3.join().unwrap(); j3.join().unwrap();
} }
assert!(DB::destroy(&Options::default(), path).is_ok());
} }

230
tests/test_raw_iterator.rs
Unescape View File

@ -13,142 +13,144 @@
// limitations under the License. // limitations under the License.
// //
extern crate rocksdb; extern crate rocksdb;
mod util;
use rocksdb::DB; use rocksdb::DB;
use util::DBPath;
fn setup_test_db(name: &str) -> DB {
use std::fs::remove_dir_all;
let path = "_rust_rocksdb_rawiteratortest_".to_string() + name;
match remove_dir_all(&path) {
Ok(_) => {}
Err(_) => {} // Don't care if tis fails
}
DB::open_default(path).unwrap()
}
#[test] #[test]
pub fn test_forwards_iteration() { pub fn test_forwards_iteration() {
let db = setup_test_db("forwards_iteration"); let n = DBPath::new("forwards_iteration");
db.put(b"k1", b"v1").unwrap(); {
db.put(b"k2", b"v2").unwrap(); let db = DB::open_default(&n).unwrap();
db.put(b"k3", b"v3").unwrap(); db.put(b"k1", b"v1").unwrap();
db.put(b"k4", b"v4").unwrap(); db.put(b"k2", b"v2").unwrap();
db.put(b"k3", b"v3").unwrap();
let mut iter = db.raw_iterator(); db.put(b"k4", b"v4").unwrap();
iter.seek_to_first();
let mut iter = db.raw_iterator();
assert_eq!(iter.valid(), true); iter.seek_to_first();
assert_eq!(iter.key(), Some(b"k1".to_vec()));
assert_eq!(iter.value(), Some(b"v1".to_vec())); assert_eq!(iter.valid(), true);
assert_eq!(iter.key(), Some(b"k1".to_vec()));
iter.next(); assert_eq!(iter.value(), Some(b"v1".to_vec()));
assert_eq!(iter.valid(), true); iter.next();
assert_eq!(iter.key(), Some(b"k2".to_vec()));
assert_eq!(iter.value(), Some(b"v2".to_vec())); assert_eq!(iter.valid(), true);
assert_eq!(iter.key(), Some(b"k2".to_vec()));
iter.next(); // k3 assert_eq!(iter.value(), Some(b"v2".to_vec()));
iter.next(); // k4
iter.next(); // invalid! iter.next(); // k3
iter.next(); // k4
assert_eq!(iter.valid(), false); iter.next(); // invalid!
assert_eq!(iter.key(), None);
assert_eq!(iter.value(), None); assert_eq!(iter.valid(), false);
assert_eq!(iter.key(), None);
assert_eq!(iter.value(), None);
}
} }
#[test] #[test]
pub fn test_seek_last() { pub fn test_seek_last() {
let db = setup_test_db("backwards_iteration"); let n = DBPath::new("backwards_iteration");
db.put(b"k1", b"v1").unwrap(); {
db.put(b"k2", b"v2").unwrap(); let db = DB::open_default(&n).unwrap();
db.put(b"k3", b"v3").unwrap(); db.put(b"k1", b"v1").unwrap();
db.put(b"k4", b"v4").unwrap(); db.put(b"k2", b"v2").unwrap();
db.put(b"k3", b"v3").unwrap();
let mut iter = db.raw_iterator(); db.put(b"k4", b"v4").unwrap();
iter.seek_to_last();
let mut iter = db.raw_iterator();
assert_eq!(iter.valid(), true); iter.seek_to_last();
assert_eq!(iter.key(), Some(b"k4".to_vec()));
assert_eq!(iter.value(), Some(b"v4".to_vec())); assert_eq!(iter.valid(), true);
assert_eq!(iter.key(), Some(b"k4".to_vec()));
iter.prev(); assert_eq!(iter.value(), Some(b"v4".to_vec()));
assert_eq!(iter.valid(), true); iter.prev();
assert_eq!(iter.key(), Some(b"k3".to_vec()));
assert_eq!(iter.value(), Some(b"v3".to_vec())); assert_eq!(iter.valid(), true);
assert_eq!(iter.key(), Some(b"k3".to_vec()));
iter.prev(); // k2 assert_eq!(iter.value(), Some(b"v3".to_vec()));
iter.prev(); // k1
iter.prev(); // invalid! iter.prev(); // k2
iter.prev(); // k1
assert_eq!(iter.valid(), false); iter.prev(); // invalid!
assert_eq!(iter.key(), None);
assert_eq!(iter.value(), None); assert_eq!(iter.valid(), false);
assert_eq!(iter.key(), None);
assert_eq!(iter.value(), None);
}
} }
#[test] #[test]
pub fn test_seek() { pub fn test_seek() {
let db = setup_test_db("seek"); let n = DBPath::new("seek");
db.put(b"k1", b"v1").unwrap(); {
db.put(b"k2", b"v2").unwrap(); let db = DB::open_default(&n).unwrap();
db.put(b"k4", b"v4").unwrap(); db.put(b"k1", b"v1").unwrap();
db.put(b"k2", b"v2").unwrap();
let mut iter = db.raw_iterator(); db.put(b"k4", b"v4").unwrap();
iter.seek(b"k2");
let mut iter = db.raw_iterator();
assert_eq!(iter.valid(), true); iter.seek(b"k2");
assert_eq!(iter.key(), Some(b"k2".to_vec()));
assert_eq!(iter.value(), Some(b"v2".to_vec())); assert_eq!(iter.valid(), true);
assert_eq!(iter.key(), Some(b"k2".to_vec()));
// Check it gets the next key when the key doesn't exist assert_eq!(iter.value(), Some(b"v2".to_vec()));
iter.seek(b"k3");
// Check it gets the next key when the key doesn't exist
assert_eq!(iter.valid(), true); iter.seek(b"k3");
assert_eq!(iter.key(), Some(b"k4".to_vec()));
assert_eq!(iter.value(), Some(b"v4".to_vec())); assert_eq!(iter.valid(), true);
assert_eq!(iter.key(), Some(b"k4".to_vec()));
assert_eq!(iter.value(), Some(b"v4".to_vec()));
}
} }
#[test] #[test]
pub fn test_seek_to_nonexistant() { pub fn test_seek_to_nonexistant() {
let db = setup_test_db("seek_to_nonexistant"); let n = DBPath::new("seek_to_nonexistant");
db.put(b"k1", b"v1").unwrap(); {
db.put(b"k3", b"v3").unwrap(); let db = DB::open_default(&n).unwrap();
db.put(b"k4", b"v4").unwrap(); db.put(b"k1", b"v1").unwrap();
db.put(b"k3", b"v3").unwrap();
let mut iter = db.raw_iterator(); db.put(b"k4", b"v4").unwrap();
iter.seek(b"k2");
let mut iter = db.raw_iterator();
assert_eq!(iter.valid(), true); iter.seek(b"k2");
assert_eq!(iter.key(), Some(b"k3".to_vec()));
assert_eq!(iter.value(), Some(b"v3".to_vec())); assert_eq!(iter.valid(), true);
assert_eq!(iter.key(), Some(b"k3".to_vec()));
assert_eq!(iter.value(), Some(b"v3".to_vec()));
}
} }
#[test] #[test]
pub fn test_seek_for_prev() { pub fn test_seek_for_prev() {
let db = setup_test_db("seek_for_prev"); let n = DBPath::new("seek_for_prev");
db.put(b"k1", b"v1").unwrap(); {
db.put(b"k2", b"v2").unwrap(); let db = DB::open_default(&n).unwrap();
db.put(b"k4", b"v4").unwrap(); db.put(b"k1", b"v1").unwrap();
db.put(b"k2", b"v2").unwrap();
let mut iter = db.raw_iterator(); db.put(b"k4", b"v4").unwrap();
iter.seek(b"k2");
let mut iter = db.raw_iterator();
assert_eq!(iter.valid(), true); iter.seek(b"k2");
assert_eq!(iter.key(), Some(b"k2".to_vec()));
assert_eq!(iter.value(), Some(b"v2".to_vec())); assert_eq!(iter.valid(), true);
assert_eq!(iter.key(), Some(b"k2".to_vec()));
// Check it gets the previous key when the key doesn't exist assert_eq!(iter.value(), Some(b"v2".to_vec()));
iter.seek_for_prev(b"k3");
// Check it gets the previous key when the key doesn't exist
assert_eq!(iter.valid(), true); iter.seek_for_prev(b"k3");
assert_eq!(iter.key(), Some(b"k2".to_vec()));
assert_eq!(iter.value(), Some(b"v2".to_vec())); assert_eq!(iter.valid(), true);
assert_eq!(iter.key(), Some(b"k2".to_vec()));
assert_eq!(iter.value(), Some(b"v2".to_vec()));
}
} }

15
tests/test_rocksdb_options.rs
Unescape View File

@ -13,15 +13,18 @@
// limitations under the License. // limitations under the License.
// //
extern crate rocksdb; extern crate rocksdb;
mod util;
use rocksdb::{DB, Options}; use rocksdb::{DB, Options};
use util::DBPath;
#[test] #[test]
fn test_set_num_levels() { fn test_set_num_levels() {
let path = "_rust_rocksdb_test_set_num_levels"; let n = DBPath::new("_rust_rocksdb_test_set_num_levels");
let mut opts = Options::default(); {
opts.create_if_missing(true); let mut opts = Options::default();
opts.set_num_levels(2); opts.create_if_missing(true);
let db = DB::open(&opts, path).unwrap(); opts.set_num_levels(2);
drop(db); let _db = DB::open(&opts, &n).unwrap();
}
} }

65
tests/test_slice_transform.rs
Unescape View File

@ -1,48 +1,51 @@
extern crate rocksdb; extern crate rocksdb;
mod util;
use rocksdb::{DB, Options, SliceTransform}; use rocksdb::{DB, Options, SliceTransform};
use util::DBPath;
#[test] #[test]
pub fn test_slice_transform() { pub fn test_slice_transform() {
let n = DBPath::new("_rust_rocksdb_slicetransform_test");
{
let a1: Box<[u8]> = key(b"aaa1");
let a2: Box<[u8]> = key(b"aaa2");
let b1: Box<[u8]> = key(b"bbb1");
let b2: Box<[u8]> = key(b"bbb2");
let path = "_rust_rocksdb_slicetransform_test"; fn first_three(k: &[u8]) -> Vec<u8> {
let a1: Box<[u8]> = key(b"aaa1"); k.iter().take(3).cloned().collect()
let a2: Box<[u8]> = key(b"aaa2"); }
let b1: Box<[u8]> = key(b"bbb1");
let b2: Box<[u8]> = key(b"bbb2");
fn first_three(k: &[u8]) -> Vec<u8> { let prefix_extractor = SliceTransform::create("first_three", first_three, None);
k.iter().take(3).cloned().collect()
}
let prefix_extractor = SliceTransform::create("first_three", first_three, None); let mut opts = Options::default();
opts.create_if_missing(true);
opts.set_prefix_extractor(prefix_extractor);
let mut opts = Options::default(); let db = DB::open(&opts, &n).unwrap();
opts.create_if_missing(true);
opts.set_prefix_extractor(prefix_extractor);
let db = DB::open(&opts, path).unwrap(); assert!(db.put(&*a1, &*a1).is_ok());
assert!(db.put(&*a2, &*a2).is_ok());
assert!(db.put(&*b1, &*b1).is_ok());
assert!(db.put(&*b2, &*b2).is_ok());
assert!(db.put(&*a1, &*a1).is_ok()); fn cba(input: &Box<[u8]>) -> Box<[u8]> {
assert!(db.put(&*a2, &*a2).is_ok()); input.iter().cloned().collect::<Vec<_>>().into_boxed_slice()
assert!(db.put(&*b1, &*b1).is_ok()); }
assert!(db.put(&*b2, &*b2).is_ok());
fn cba(input: &Box<[u8]>) -> Box<[u8]> { fn key(k: &[u8]) -> Box<[u8]> { k.to_vec().into_boxed_slice() }
input.iter().cloned().collect::<Vec<_>>().into_boxed_slice()
}
fn key(k: &[u8]) -> Box<[u8]> { k.to_vec().into_boxed_slice() } {
let expected = vec![(cba(&a1), cba(&a1)), (cba(&a2), cba(&a2))];
let a_iterator = db.prefix_iterator(b"aaa");
assert_eq!(a_iterator.collect::<Vec<_>>(), expected)
}
{ {
let expected = vec![(cba(&a1), cba(&a1)), (cba(&a2), cba(&a2))]; let expected = vec![(cba(&b1), cba(&b1)), (cba(&b2), cba(&b2))];
let a_iterator = db.prefix_iterator(b"aaa"); let b_iterator = db.prefix_iterator(b"bbb");
assert_eq!(a_iterator.collect::<Vec<_>>(), expected) assert_eq!(b_iterator.collect::<Vec<_>>(), expected)
} }
{
let expected = vec![(cba(&b1), cba(&b1)), (cba(&b2), cba(&b2))];
let b_iterator = db.prefix_iterator(b"bbb");
assert_eq!(b_iterator.collect::<Vec<_>>(), expected)
} }
} }

41
tests/util/mod.rs
Unescape View File

@ -0,0 +1,41 @@
extern crate rocksdb;
use std::time::{SystemTime, UNIX_EPOCH};
use std::path::{PathBuf, Path};
use rocksdb::{DB, Options};
/// Ensures that DB::Destroy is called for this database when DBPath is dropped.
pub struct DBPath {
path: PathBuf
}
impl DBPath {
/// Suffixes the given `prefix` with a timestamp to ensure that subsequent test runs don't reuse
/// an old database in case of panics prior to Drop being called.
pub fn new(prefix: &str) -> DBPath {
let current_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
let path = format!(
"{}.{}.{}",
prefix,
current_time.as_secs(),
current_time.subsec_nanos()
);
DBPath { path: PathBuf::from(path) }
}
}
impl Drop for DBPath {
fn drop(&mut self) {
let opts = Options::default();
DB::destroy(&opts, &self.path).unwrap();
}
}
impl AsRef<Path> for DBPath {
fn as_ref(&self) -> &Path {
&self.path
}
}
Write Preview
Loading…
Cancel
Save