feat(bindingtester): implement last instructions

Author: PierreZ

foundationdb-bindingtester/src/main.rs

@@ -1835,7 +1835,7 @@ impl StackMachine {
                     }
                 };
 
-                let directory_subspace = match directory
+                match directory
                     .create_or_open(
                         txn,
                         (*path.get(0).unwrap().to_owned()).to_vec(),
@@ -1844,19 +1844,17 @@ impl StackMachine {
                     )
                     .await
                 {
-                    Ok(s) => s,
-                    Err(e) => {
-                        panic!("could not call directory.create: {:?}", e);
+                    Ok(directory_subspace) => {
+                        debug!(
+                            "pushing created_or_opened {:?} at index {}",
+                            &directory_subspace,
+                            self.directory_stack.len()
+                        );
+                        self.directory_stack
+                            .push(DirectoryStackItem::DirectorySubspace(directory_subspace));
                     }
+                    Err(e) => self.push_directory_err(&instr.code, number, e),
                 };
-
-                debug!(
-                    "pushing created_or_opened {:?} at index {}",
-                    &directory_subspace,
-                    self.directory_stack.len()
-                );
-                self.directory_stack
-                    .push(DirectoryStackItem::DirectorySubspace(directory_subspace));
             }
 
             // Pop the top item off the stack as [index]. Set the current directory list
@@ -2003,10 +2001,12 @@ impl StackMachine {
                 };
 
                 let paths = paths.get(0).expect("could not retrieve a path");
-                directory
-                    .remove(txn, paths.to_owned())
-                    .await
-                    .expect("could not delete");
+                match directory.remove(txn, paths.to_owned()).await {
+                    Ok(_) => {}
+                    Err(e) => {
+                        self.push_directory_err(&instr.code, number, e);
+                    }
+                }
             }
 
             // Use the current directory for this operation.
@@ -2177,13 +2177,36 @@ impl StackMachine {
             //
             // Pop 1 item off the stack as [key]. Check if the current directory contains
             // the specified key. Push 1 if it does and 0 if it doesn't.
-            DirectoryContains => unimplemented!(),
+            DirectoryContains => {
+                let raw_prefix = self.pop_bytes().await;
+                let b = self
+                    .get_current_directory_subspace()
+                    .unwrap()
+                    .subspace(&())
+                    .is_start_of(&raw_prefix);
+                self.push(number, Element::Bool(b));
+            }
 
             // Use the current directory for this operation.
             //
             // Pop 1 tuple off the stack as [tuple]. Open the subspace of the current
             // directory specified by tuple and push it onto the directory list.
-            DirectoryOpenSubspace => unimplemented!(),
+            DirectoryOpenSubspace => {
+                debug!("directory_open_subspace stack: {:?}", self.stack);
+                let n: usize = self.pop_usize().await;
+                debug!("DirectoryRange {}", n);
+                let mut buf = Vec::new();
+                for _ in 0..n {
+                    let element: Element = self.pop_element().await;
+                    debug!(" - {:?}", element);
+                    buf.push(element);
+                }
+
+                let tuple = Element::Tuple(buf);
+                self.directory_stack.push(DirectoryStackItem::Subspace(
+                    self.subspace_with_current(&tuple).unwrap(),
+                ));
+            }
 
             // Use the current directory for this operation.
             //
@@ -2269,7 +2292,26 @@ impl StackMachine {
             // subspace and store the result as [prefix]. Throw an error if the popped
             // array does not start with prefix. Otherwise, remove the prefix from the
             // popped array and push the result onto the stack.
-            DirectoryStripPrefix => unimplemented!(),
+            DirectoryStripPrefix => {
+                debug!("directory_strip_prefix stack: {:?}", self.stack);
+                let raw_prefix = self.pop_bytes().await;
+                let subspace_bytes_length =
+                    self.get_current_directory_subspace().unwrap().bytes().len();
+                if raw_prefix.len() != subspace_bytes_length {
+                    self.push_directory_err(
+                        &instr.code,
+                        number,
+                        DirectoryError::Version(String::from(
+                            "String does not start with raw prefix",
+                        )),
+                    );
+                } else {
+                    self.push(
+                        number,
+                        Element::Bytes(Bytes::from(raw_prefix[subspace_bytes_length..].to_owned())),
+                    );
+                }
+            }
         }
 
         if is_db && pending {

foundationdb/src/directory/directory_layer.rs

@@ -218,7 +218,6 @@ impl Directory for DirectoryLayer {
         trx: &Transaction,
         path: Vec<String>,
     ) -> Result<Vec<String>, DirectoryError> {
-        dbg!(&path);
         let node = self
             .find_or_create_node(trx, path.to_owned(), false, None)
             .await?;
@@ -245,7 +244,6 @@ impl DirectoryLayer {
         allow_create: bool,
         allow_open: bool,
     ) -> Result<DirectorySubspace, DirectoryError> {
-        dbg!(&path, &prefix, &layer, allow_create, allow_open);
         self.check_version(trx, allow_create).await?;
 
         if prefix.is_some() && !self.allow_manual_prefix {

foundationdb/src/directory/directory_subspace.rs

@@ -112,8 +112,6 @@ impl Directory for DirectorySubspace {
             return Err(DirectoryError::CannotMoveBetweenPartition);
         }
 
-        dbg!(&new_path, &self.path);
-
         if compare_slice_string(&new_path[..partition_length], &self.path) != Ordering::Equal {
             Err(DirectoryError::CannotMoveBetweenPartition)
         } else {
@@ -157,7 +155,6 @@ impl Directory for DirectorySubspace {
         trx: &Transaction,
         path: Vec<String>,
     ) -> Result<Vec<String>, DirectoryError> {
-        dbg!(&path);
         self.directory
             .list(
                 trx,

foundationdb/src/directory/node.rs

@@ -40,7 +40,6 @@ impl Node {
     /// `check_layer` is checking the layer, throwing `IncompatibleLayer` when
     /// the provided layer does not match the one provided.
     pub(crate) fn check_layer(&self, layer: Vec<u8>) -> Result<(), DirectoryError> {
-        dbg!(&self.layer, &layer);
         match &self.layer {
             None => Err(DirectoryError::IncompatibleLayer),
             Some(layer_bytes) => {