closure-test.rs

fn setup<F>(f: F)
where F: Fn(
    // &mut Service::<'_, '_, tests::MockRng, tests::InternalStorage<'_>, tests::ExternalStorage<'_>, tests::VolatileStorage<'_>>,
    &mut Client<'_, &mut service::Service<'_, '_, tests::MockRng, tests::InternalStorage<'_>, tests::ExternalStorage<'_>, tests::VolatileStorage<'_>>>
) {

    // whole lotta setup goin' on ;)

    let mut request_queue = heapless::spsc::Queue(heapless::i::Queue::u8());
    let mut reply_queue = heapless::spsc::Queue(heapless::i::Queue::u8());
    let (service_endpoint, client_endpoint) = pipe::new_endpoints(&mut request_queue, &mut reply_queue, "fido2");
    let rng = MockRng::new();

    let mut internal_ram = InternalRam::default();
    let mut internal_storage = InternalStorage::new(&mut internal_ram);
    Filesystem::format(&mut internal_storage).expect("could not format internal storage");
    let mut internal_fs_alloc = Filesystem::allocate();
    let ifs = FilesystemWith::mount(&mut internal_fs_alloc, &mut internal_storage)
        .expect("could not mount internal storage");

    let mut external_ram = ExternalRam::default();
    let mut external_storage = ExternalStorage::new(&mut external_ram);
    Filesystem::format(&mut external_storage).expect("could not format external storage");
    let mut external_fs_alloc = Filesystem::allocate();
    let efs = FilesystemWith::mount(&mut external_fs_alloc, &mut external_storage)
        .expect("could not mount external storage");

    let mut volatile_ram = VolatileRam::default();
    let mut volatile_storage = VolatileStorage::new(&mut volatile_ram);
    Filesystem::format(&mut volatile_storage).expect("could not format volatile storage");
    let mut volatile_fs_alloc = Filesystem::allocate();
    let vfs = FilesystemWith::mount(&mut volatile_fs_alloc, &mut volatile_storage)
        .expect("could not mount volatile storage");

    let mut service = Service::new(rng, ifs, efs, vfs).expect("service init worked");
    assert!(service.add_endpoint(service_endpoint).is_ok());

    // let mut raw_client = client::RawClient::new(client_endpoint);
    // f(&mut service, &mut client);

    let syscaller = &mut service;
    let mut client = Client::new(client_endpoint, syscaller);
    f(&mut client);
}

#[test]
fn sign_ed25519() {
    setup(|client| {
        let mut future = client.generate_ed25519_private_key(StorageLocation::Internal).expect("no client error");
        println!("submitted gen ed25519");
        let reply = block!(future);
        let private_key = reply.expect("no errors, never").key;
        println!("got a private key {:?}", &private_key);