initial import of main veilid core

veilid-core/src/tests/native/mod.rs

@@ -0,0 +1,195 @@
+//! Test suite for Native
+#![cfg(not(target_arch = "wasm32"))]
+
+mod test_async_peek_stream;
+
+use crate::tests::common::*;
+use crate::xx::*;
+
+#[cfg(all(target_os = "android", feature = "android_tests"))]
+use jni::{objects::JClass, objects::JObject, JNIEnv};
+
+#[cfg(all(target_os = "android", feature = "android_tests"))]
+#[no_mangle]
+#[allow(non_snake_case)]
+pub extern "system" fn Java_com_veilid_veilidcore_veilidcore_1android_1tests_MainActivity_run_1tests(
+    env: JNIEnv,
+    _class: JClass,
+    ctx: JObject,
+) {
+    crate::intf::utils::android::veilid_core_setup_android(env, ctx, "veilid_core", Level::Trace);
+    run_all_tests();
+}
+
+#[cfg(all(target_os = "ios", feature = "ios_tests"))]
+#[no_mangle]
+pub extern "C" fn run_veilid_core_tests() {
+    let log_path: std::path::PathBuf = [
+        std::env::var("HOME").unwrap().as_str(),
+        "Documents",
+        "veilid-core.log",
+    ]
+    .iter()
+    .collect();
+    crate::intf::utils::ios::veilid_core_setup_ios(
+        "veilid-core",
+        Some(Level::Trace),
+        Some((Level::Trace, log_path.as_path())),
+    );
+    run_all_tests();
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+#[allow(dead_code)]
+pub fn run_all_tests() {
+    info!("TEST: exec_test_host_interface");
+    exec_test_host_interface();
+    info!("TEST: exec_test_dht_key");
+    exec_test_dht_key();
+    info!("TEST: exec_test_veilid_core");
+    exec_test_veilid_core();
+    info!("TEST: exec_test_veilid_config");
+    exec_test_veilid_config();
+    info!("TEST: exec_test_async_peek_stream");
+    exec_test_async_peek_stream();
+    info!("TEST: exec_test_connection_table");
+    exec_test_connection_table();
+    info!("TEST: exec_test_table_store");
+    exec_test_table_store();
+    info!("TEST: exec_test_crypto");
+    exec_test_crypto();
+    info!("TEST: exec_test_envelope_receipt");
+    exec_test_envelope_receipt();
+
+    info!("Finished unit tests");
+}
+
+fn exec_test_host_interface() {
+    async_std::task::block_on(async {
+        test_host_interface::test_all().await;
+    });
+}
+fn exec_test_dht_key() {
+    async_std::task::block_on(async {
+        test_dht_key::test_all().await;
+    });
+}
+fn exec_test_veilid_core() {
+    async_std::task::block_on(async {
+        test_veilid_core::test_all().await;
+    });
+}
+fn exec_test_veilid_config() {
+    async_std::task::block_on(async {
+        test_veilid_config::test_all().await;
+    })
+}
+fn exec_test_async_peek_stream() {
+    async_std::task::block_on(async {
+        test_async_peek_stream::test_all().await;
+    })
+}
+fn exec_test_connection_table() {
+    async_std::task::block_on(async {
+        test_connection_table::test_all().await;
+    })
+}
+fn exec_test_table_store() {
+    async_std::task::block_on(async {
+        test_table_store::test_all().await;
+    })
+}
+fn exec_test_crypto() {
+    async_std::task::block_on(async {
+        test_crypto::test_all().await;
+    })
+}
+fn exec_test_envelope_receipt() {
+    async_std::task::block_on(async {
+        test_envelope_receipt::test_all().await;
+    })
+}
+///////////////////////////////////////////////////////////////////////////
+cfg_if! {
+    if #[cfg(test)] {
+        use serial_test::serial;
+        use simplelog::*;
+        use std::sync::Once;
+
+        static SETUP_ONCE: Once = Once::new();
+
+        pub fn setup() -> () {
+            SETUP_ONCE.call_once(|| {
+                let mut cb = ConfigBuilder::new();
+                cb.add_filter_ignore_str("async_std");
+                cb.add_filter_ignore_str("async_io");
+                cb.add_filter_ignore_str("polling");
+                TestLogger::init(LevelFilter::Trace, cb.build()).unwrap();
+            });
+        }
+
+        #[test]
+        #[serial]
+        fn run_test_host_interface() {
+            setup();
+            exec_test_host_interface();
+        }
+
+        #[test]
+        #[serial]
+        fn run_test_dht_key() {
+            setup();
+            exec_test_dht_key();
+        }
+
+        #[test]
+        #[serial]
+        fn run_test_veilid_core() {
+            setup();
+            exec_test_veilid_core();
+        }
+
+        #[test]
+        #[serial]
+        fn run_test_veilid_config() {
+            setup();
+            exec_test_veilid_config();
+        }
+
+        #[test]
+        #[serial]
+        fn run_test_async_peek_stream() {
+            setup();
+            exec_test_async_peek_stream();
+        }
+
+        #[test]
+        #[serial]
+        fn run_test_connection_table() {
+            setup();
+            exec_test_connection_table();
+        }
+
+        #[test]
+        #[serial]
+        fn run_test_table_store() {
+            setup();
+            exec_test_table_store();
+        }
+
+        #[test]
+        #[serial]
+        fn run_test_crypto() {
+            setup();
+            exec_test_crypto();
+        }
+
+        #[test]
+        #[serial]
+        fn run_test_envelope_receipt() {
+            setup();
+            exec_test_envelope_receipt();
+        }
+    }
+}

veilid-core/src/tests/native/test_async_peek_stream.rs

@@ -0,0 +1,280 @@
+use crate::intf::utils::async_peek_stream::*;
+use crate::xx::*;
+use async_std::io;
+use async_std::net::{TcpListener, TcpStream};
+use async_std::prelude::*;
+use async_std::task;
+use std::time::Duration;
+
+static MESSAGE: &[u8; 62] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+
+async fn make_tcp_loopback() -> Result<(TcpStream, TcpStream), io::Error> {
+    let listener = TcpListener::bind("127.0.0.1:0").await?;
+    let local_addr = listener.local_addr()?;
+
+    let accept_future = async {
+        let (accepted_stream, peer_address) = listener.accept().await?;
+        trace!("connection from {}", peer_address);
+        accepted_stream.set_nodelay(true)?;
+        Result::<TcpStream, io::Error>::Ok(accepted_stream)
+    };
+    let connect_future = async {
+        task::sleep(Duration::from_secs(1)).await;
+        let connected_stream = TcpStream::connect(local_addr).await?;
+        connected_stream.set_nodelay(true)?;
+        Result::<TcpStream, io::Error>::Ok(connected_stream)
+    };
+
+    Ok(accept_future.try_join(connect_future).await?)
+}
+
+async fn make_async_peek_stream_loopback() -> (AsyncPeekStream, AsyncPeekStream) {
+    let (acc, conn) = make_tcp_loopback().await.unwrap();
+    let aps_a = AsyncPeekStream::new(acc);
+    let aps_c = AsyncPeekStream::new(conn);
+
+    (aps_a, aps_c)
+}
+
+async fn make_tcpstream_loopback() -> (TcpStream, TcpStream) {
+    make_tcp_loopback().await.unwrap()
+}
+
+pub async fn test_nothing() {
+    info!("test_nothing");
+    let (mut a, mut c) = make_tcpstream_loopback().await;
+    let outbuf = MESSAGE.to_vec();
+
+    a.write_all(&outbuf).await.unwrap();
+
+    let mut inbuf: Vec<u8> = Vec::new();
+    inbuf.resize(outbuf.len(), 0u8);
+    c.read_exact(&mut inbuf).await.unwrap();
+
+    assert_eq!(inbuf, outbuf);
+}
+
+pub async fn test_no_peek() {
+    info!("test_no_peek");
+    let (mut a, mut c) = make_async_peek_stream_loopback().await;
+
+    let outbuf = MESSAGE.to_vec();
+
+    a.write_all(&outbuf).await.unwrap();
+
+    let mut inbuf: Vec<u8> = Vec::new();
+    inbuf.resize(outbuf.len(), 0u8);
+    c.read_exact(&mut inbuf).await.unwrap();
+
+    assert_eq!(inbuf, outbuf);
+}
+
+pub async fn test_peek_all_read() {
+    info!("test_peek_all_read");
+
+    let (mut a, mut c) = make_async_peek_stream_loopback().await;
+    // write everything
+    let outbuf = MESSAGE.to_vec();
+    a.write_all(&outbuf).await.unwrap();
+
+    // peek everything
+    let mut peekbuf1: Vec<u8> = Vec::new();
+    peekbuf1.resize(outbuf.len(), 0u8);
+    let peeksize1 = c.peek(&mut peekbuf1).await.unwrap();
+
+    assert_eq!(peeksize1, peekbuf1.len());
+    // read everything
+    let mut inbuf: Vec<u8> = Vec::new();
+    inbuf.resize(outbuf.len(), 0u8);
+    c.read_exact(&mut inbuf).await.unwrap();
+
+    assert_eq!(inbuf, outbuf);
+    assert_eq!(peekbuf1, outbuf);
+}
+
+pub async fn test_peek_some_read() {
+    info!("test_peek_some_read");
+
+    let (mut a, mut c) = make_async_peek_stream_loopback().await;
+
+    // write everything
+    let outbuf = MESSAGE.to_vec();
+    a.write_all(&outbuf).await.unwrap();
+
+    // peek partially
+    let mut peekbuf1: Vec<u8> = Vec::new();
+    peekbuf1.resize(outbuf.len() / 2, 0u8);
+    let peeksize1 = c.peek(&mut peekbuf1).await.unwrap();
+    assert_eq!(peeksize1, peekbuf1.len());
+    // read everything
+    let mut inbuf: Vec<u8> = Vec::new();
+    inbuf.resize(outbuf.len(), 0u8);
+    c.read_exact(&mut inbuf).await.unwrap();
+
+    assert_eq!(inbuf, outbuf);
+    assert_eq!(peekbuf1, outbuf[0..peeksize1].to_vec());
+}
+
+pub async fn test_peek_some_peek_some_read() {
+    info!("test_peek_some_peek_some_read");
+
+    let (mut a, mut c) = make_async_peek_stream_loopback().await;
+
+    // write everything
+    let outbuf = MESSAGE.to_vec();
+    a.write_all(&outbuf).await.unwrap();
+
+    // peek partially
+    let mut peekbuf1: Vec<u8> = Vec::new();
+    peekbuf1.resize(outbuf.len() / 4, 0u8);
+    let peeksize1 = c.peek(&mut peekbuf1).await.unwrap();
+    assert_eq!(peeksize1, peekbuf1.len());
+
+    // peek partially
+    let mut peekbuf2: Vec<u8> = Vec::new();
+    peekbuf2.resize(peeksize1 + 1, 0u8);
+    let peeksize2 = c.peek(&mut peekbuf2).await.unwrap();
+    assert_eq!(peeksize2, peekbuf2.len());
+
+    // read everything
+    let mut inbuf: Vec<u8> = Vec::new();
+    inbuf.resize(outbuf.len(), 0u8);
+    c.read_exact(&mut inbuf).await.unwrap();
+
+    assert_eq!(inbuf, outbuf);
+    assert_eq!(peekbuf1, outbuf[0..peeksize1].to_vec());
+    assert_eq!(peekbuf2, outbuf[0..peeksize2].to_vec());
+}
+
+pub async fn test_peek_some_read_peek_some_read() {
+    info!("test_peek_some_read_peek_some_read");
+
+    let (mut a, mut c) = make_async_peek_stream_loopback().await;
+
+    // write everything
+    let outbuf = MESSAGE.to_vec();
+    a.write_all(&outbuf).await.unwrap();
+
+    // peek partially
+    let mut peekbuf1: Vec<u8> = Vec::new();
+    peekbuf1.resize(outbuf.len() / 4, 0u8);
+    let peeksize1 = c.peek(&mut peekbuf1).await.unwrap();
+    assert_eq!(peeksize1, peekbuf1.len());
+
+    // read partially
+    let mut inbuf1: Vec<u8> = Vec::new();
+    inbuf1.resize(peeksize1 - 1, 0u8);
+    c.read_exact(&mut inbuf1).await.unwrap();
+
+    // peek partially
+    let mut peekbuf2: Vec<u8> = Vec::new();
+    peekbuf2.resize(2, 0u8);
+    let peeksize2 = c.peek(&mut peekbuf2).await.unwrap();
+    assert_eq!(peeksize2, peekbuf2.len());
+
+    // read partially
+    let mut inbuf2: Vec<u8> = Vec::new();
+    inbuf2.resize(2, 0u8);
+    c.read_exact(&mut inbuf2).await.unwrap();
+
+    assert_eq!(peekbuf1, outbuf[0..peeksize1].to_vec());
+    assert_eq!(inbuf1, outbuf[0..peeksize1 - 1].to_vec());
+    assert_eq!(peekbuf2, outbuf[peeksize1 - 1..peeksize1 + 1].to_vec());
+    assert_eq!(inbuf2, peekbuf2);
+}
+
+pub async fn test_peek_some_read_peek_all_read() {
+    info!("test_peek_some_read_peek_all_read");
+
+    let (mut a, mut c) = make_async_peek_stream_loopback().await;
+
+    // write everything
+    let outbuf = MESSAGE.to_vec();
+    a.write_all(&outbuf).await.unwrap();
+
+    // peek partially
+    let mut peekbuf1: Vec<u8> = Vec::new();
+    peekbuf1.resize(outbuf.len() / 4, 0u8);
+    let peeksize1 = c.peek(&mut peekbuf1).await.unwrap();
+    assert_eq!(peeksize1, peekbuf1.len());
+
+    // read partially
+    let mut inbuf1: Vec<u8> = Vec::new();
+    inbuf1.resize(peeksize1 + 1, 0u8);
+    c.read_exact(&mut inbuf1).await.unwrap();
+
+    // peek past end
+    let mut peekbuf2: Vec<u8> = Vec::new();
+    peekbuf2.resize(outbuf.len(), 0u8);
+    let peeksize2 = c.peek(&mut peekbuf2).await.unwrap();
+    assert_eq!(peeksize2, outbuf.len() - (peeksize1 + 1));
+
+    // read remaining
+    let mut inbuf2: Vec<u8> = Vec::new();
+    inbuf2.resize(peeksize2, 0u8);
+    c.read_exact(&mut inbuf2).await.unwrap();
+
+    assert_eq!(peekbuf1, outbuf[0..peeksize1].to_vec());
+    assert_eq!(inbuf1, outbuf[0..peeksize1 + 1].to_vec());
+    assert_eq!(
+        peekbuf2[0..peeksize2].to_vec(),
+        outbuf[peeksize1 + 1..outbuf.len()].to_vec()
+    );
+    assert_eq!(inbuf2, peekbuf2[0..peeksize2].to_vec());
+}
+
+pub async fn test_peek_some_read_peek_some_read_all_read() {
+    info!("test_peek_some_read_peek_some_read_peek_all_read");
+
+    let (mut a, mut c) = make_async_peek_stream_loopback().await;
+
+    // write everything
+    let outbuf = MESSAGE.to_vec();
+    a.write_all(&outbuf).await.unwrap();
+
+    // peek partially
+    let mut peekbuf1: Vec<u8> = Vec::new();
+    peekbuf1.resize(outbuf.len() / 4, 0u8);
+    let peeksize1 = c.peek(&mut peekbuf1).await.unwrap();
+    assert_eq!(peeksize1, peekbuf1.len());
+
+    // read partially
+    let mut inbuf1: Vec<u8> = Vec::new();
+    inbuf1.resize(peeksize1 - 1, 0u8);
+    c.read_exact(&mut inbuf1).await.unwrap();
+
+    // peek partially
+    let mut peekbuf2: Vec<u8> = Vec::new();
+    peekbuf2.resize(2, 0u8);
+    let peeksize2 = c.peek(&mut peekbuf2).await.unwrap();
+    assert_eq!(peeksize2, peekbuf2.len());
+    // read partially
+    let mut inbuf2: Vec<u8> = Vec::new();
+    inbuf2.resize(1, 0u8);
+    c.read_exact(&mut inbuf2).await.unwrap();
+
+    // read remaining
+    let mut inbuf3: Vec<u8> = Vec::new();
+    inbuf3.resize(outbuf.len() - peeksize1, 0u8);
+    c.read_exact(&mut inbuf3).await.unwrap();
+
+    assert_eq!(peekbuf1, outbuf[0..peeksize1].to_vec());
+    assert_eq!(inbuf1, outbuf[0..peeksize1 - 1].to_vec());
+    assert_eq!(
+        peekbuf2[0..peeksize2].to_vec(),
+        outbuf[peeksize1 - 1..peeksize1 + 1].to_vec()
+    );
+    assert_eq!(inbuf2, peekbuf2[0..1].to_vec());
+    assert_eq!(inbuf3, outbuf[peeksize1..outbuf.len()].to_vec());
+}
+
+pub async fn test_all() {
+    test_nothing().await;
+    test_no_peek().await;
+    test_peek_all_read().await;
+    test_peek_some_read().await;
+    test_peek_some_peek_some_read().await;
+    test_peek_some_read_peek_some_read().await;
+    test_peek_some_read_peek_all_read().await;
+    test_peek_some_read_peek_some_read_all_read().await;
+}