Fix errors

Cargo.toml

@@ -16,20 +16,20 @@ maintenance = { status = "experimental" }
 
 [dependencies]
 futures-io = { version = "0.3", optional = true }
-futures-util = { version = "0.3", optional = true }
+futures-util = { version = "0.3", optional = true, features = ["io"] }
 libc = "0.2"
 log = "0.4"
 
 [dev-dependencies]
 async-std = "1.2"
-env_logger = "0.7"
+env_logger = "0.11"
 futures= "0.3"
 structopt = "0.3"
 
 [build-dependencies]
 cc = "1.0"
-rand = "0.6"
-bindgen = "0.52"
+rand = "0.8"
+bindgen = "0.69"
 pkg-config = { version = "0.3", optional = true }
 
 [features]

build.rs

@@ -60,9 +60,9 @@ fn main() {
         }
         let bindings = builder
             .header("xdelta3/xdelta3/xdelta3.h")
-            .parse_callbacks(Box::new(bindgen::CargoCallbacks))
-            .whitelist_function("xd3_.*")
-            .whitelist_type("xd3_.*")
+            .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+            .allowlist_function("xd3_.*")
+            .allowlist_type("xd3_.*")
             .rustified_enum("xd3_.*")
             .generate()
             .expect("Unable to generate bindings");

src/lib.rs

@@ -128,3 +128,50 @@ pub fn decode(input: &[u8], src: &[u8]) -> Option<Vec<u8>> {
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn roundtrip() {
+        let input = b"Hello, world! Hello, world!";
+        let src = b"Hello, world!";
+
+        let patch = encode(input, src).unwrap();
+        let output = decode(&patch, src).unwrap();
+
+        assert_eq!(output.as_slice(), input);
+    }
+
+    #[test]
+    fn roundtrip_process() {
+        use std::io::*;
+        use stream::*;
+
+        let src = b"Hello, world!".to_vec();
+        let input = b"Hello, world! Hello, world!".to_vec();
+
+        let mut patch = Vec::new();
+        process(
+            Xd3Config::new(),
+            ProcessMode::Encode,
+            input.as_slice(),
+            src.as_slice(),
+            &mut patch,
+        )
+        .unwrap();
+
+        let mut output = Vec::new();
+        process(
+            Xd3Config::new(),
+            ProcessMode::Decode,
+            patch.as_slice(),
+            src.as_slice(),
+            &mut output,
+        )
+        .unwrap();
+
+        assert_eq!(output, input);
+    }
+}

src/rw.rs

@@ -0,0 +1,53 @@
+/*
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+struct Xdelta3Reader<R1, R2> {
+    input: R1,
+    state: ProcessState<R2>,
+    mode: Mode,
+}
+
+impl<R1, R2> AsyncRead for Xdelta3Reader<R1, R2>
+where
+    R1: Unpin + AsyncRead,
+    R2: Unpin + AsyncRead,
+{
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut [u8],
+    ) -> Poll<Result<usize>> {
+        use binding::xd3_rvalues::*;
+
+        let mode = self.as_ref().mode;
+        let state = &mut self.as_mut().state;
+
+        loop {
+            match state.step(mode) {
+                XD3_INPUT => {
+                    if state.eof {
+                        break;
+                    }
+                    // state.read_input(&mut input).await?;
+                }
+                XD3_OUTPUT => {
+                    // state.write_output(&mut output).await?;
+                }
+                XD3_GETSRCBLK => {
+                    // state.src_buf.getblk().await;
+                }
+                XD3_GOTHEADER | XD3_WINSTART | XD3_WINFINISH => {
+                    // do nothing
+                }
+                XD3_TOOFARBACK | XD3_INTERNAL | XD3_INVALID | XD3_INVALID_INPUT | XD3_NOSECOND
+                | XD3_UNIMPLEMENTED => {
+                    return Poll::Ready(Err(std::io::Error::new(std::io::ErrorKind::Other)));
+                }
+            }
+        }
+
+        unimplemented!();
+    }
+}
+*/