Merge branch 'master' into sas-verification

matrix_sdk/examples/get_profiles.rs

@@ -1,5 +1,4 @@
-use std::convert::TryFrom;
+use std::{convert::TryFrom, env, process::exit};
-use std::{env, process::exit};
 
 use url::Url;
 

matrix_sdk/src/client.rs

@@ -15,19 +15,23 @@
 
 #[cfg(feature = "encryption")]
 use std::collections::BTreeMap;
-use std::collections::HashMap;
+use std::{
-use std::convert::{TryFrom, TryInto};
+    collections::HashMap,
-use std::fmt::{self, Debug};
+    convert::{TryFrom, TryInto},
-use std::path::Path;
+    fmt::{self, Debug},
-use std::result::Result as StdResult;
+    path::Path,
-use std::sync::Arc;
+    result::Result as StdResult,
+    sync::Arc,
+};
 
-use matrix_sdk_common::identifiers::ServerName;
+use matrix_sdk_common::{
-use matrix_sdk_common::instant::{Duration, Instant};
+    identifiers::ServerName,
-use matrix_sdk_common::js_int::UInt;
+    instant::{Duration, Instant},
-use matrix_sdk_common::locks::RwLock;
+    js_int::UInt,
-use matrix_sdk_common::presence::PresenceState;
+    locks::RwLock,
-use matrix_sdk_common::uuid::Uuid;
+    presence::PresenceState,
+    uuid::Uuid,
+};
 
 use futures_timer::Delay as sleep;
 use std::future::Future;
@@ -38,22 +42,18 @@ use tracing::{error, info, instrument};
 use reqwest::header::{HeaderValue, InvalidHeaderValue};
 use url::Url;
 
-use crate::events::room::message::MessageEventContent;
+use crate::{
-use crate::events::EventType;
+    events::{room::message::MessageEventContent, EventType},
-use crate::identifiers::{EventId, RoomId, RoomIdOrAliasId, UserId};
+    identifiers::{EventId, RoomId, RoomIdOrAliasId, UserId},
-use crate::Endpoint;
+    Endpoint,
+};
 
 #[cfg(feature = "encryption")]
 use crate::identifiers::DeviceId;
 
-#[cfg(feature = "encryption")]
-use crate::Sas;
-
-use crate::api;
-use crate::http_client::HttpClient;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::VERSION;
-use crate::{EventEmitter, Result};
+use crate::{api, http_client::HttpClient, sas::Sas, EventEmitter, Result};
 use matrix_sdk_base::{BaseClient, BaseClientConfig, Room, Session, StateStore};
 
 const DEFAULT_SYNC_TIMEOUT: Duration = Duration::from_secs(30);
@@ -271,27 +271,27 @@ impl SyncSettings {
     }
 }
 
-use api::r0::account::register;
-use api::r0::directory::get_public_rooms;
-use api::r0::directory::get_public_rooms_filtered;
 #[cfg(feature = "encryption")]
 use api::r0::keys::{claim_keys, get_keys, upload_keys, KeyAlgorithm};
-use api::r0::membership::{
+#[cfg(feature = "encryption")]
+use api::r0::to_device::send_event_to_device;
+use api::r0::{
+    account::register,
+    directory::{get_public_rooms, get_public_rooms_filtered},
+    membership::{
         ban_user, forget_room,
         invite_user::{self, InvitationRecipient},
         join_room_by_id, join_room_by_id_or_alias, kick_user, leave_room, Invite3pid,
+    },
+    message::{create_message_event, get_message_events},
+    read_marker::set_read_marker,
+    receipt::create_receipt,
+    room::create_room,
+    session::login,
+    sync::sync_events,
+    typing::create_typing_event,
+    uiaa::UiaaResponse,
 };
-use api::r0::message::create_message_event;
-use api::r0::message::get_message_events;
-use api::r0::read_marker::set_read_marker;
-use api::r0::receipt::create_receipt;
-use api::r0::room::create_room;
-use api::r0::session::login;
-use api::r0::sync::sync_events;
-#[cfg(feature = "encryption")]
-use api::r0::to_device::send_event_to_device;
-use api::r0::typing::create_typing_event;
-use api::r0::uiaa::UiaaResponse;
 
 impl Client {
     /// Creates a new client for making HTTP requests to the given homeserver.
@@ -315,10 +315,10 @@ impl Client {
         homeserver_url: U,
         config: ClientConfig,
     ) -> Result<Self> {
-        #[allow(clippy::match_wild_err_arm)]
+        let homeserver = if let Ok(u) = homeserver_url.try_into() {
-        let homeserver: Url = match homeserver_url.try_into() {
+            u
-            Ok(u) => u,
+        } else {
-            Err(_e) => panic!("Error parsing homeserver url"),
+            panic!("Error parsing homeserver url")
         };
 
         let http_client = reqwest::Client::builder();
@@ -1473,23 +1473,27 @@ mod test {
         get_public_rooms_filtered::{self, Filter},
         invite_user, kick_user, leave_room,
         register::RegistrationKind,
-        set_read_marker, Invite3pid, MessageEventContent,
+        set_read_marker, Client, ClientConfig, Invite3pid, MessageEventContent, Session,
+        SyncSettings, Url,
     };
-    use super::{Client, ClientConfig, Session, SyncSettings, Url};
     use crate::events::room::message::TextMessageEventContent;
 
-    use crate::identifiers::{EventId, RoomId, RoomIdOrAliasId, UserId};
+    use crate::{
-    use crate::{RegistrationBuilder, RoomListFilterBuilder};
+        identifiers::{EventId, RoomId, RoomIdOrAliasId, UserId},
+        RegistrationBuilder, RoomListFilterBuilder,
+    };
 
     use matrix_sdk_base::JsonStore;
     use matrix_sdk_test::{test_json, EventBuilder, EventsJson};
     use mockito::{mock, Matcher};
     use tempfile::tempdir;
 
-    use std::convert::{TryFrom, TryInto};
+    use std::{
-    use std::path::Path;
+        convert::{TryFrom, TryInto},
-    use std::str::FromStr;
+        path::Path,
-    use std::time::Duration;
+        str::FromStr,
+        time::Duration,
+    };
 
     #[tokio::test]
     async fn test_join_leave_room() {
@@ -2395,6 +2399,26 @@ mod test {
         assert!(logged_in, "Clint should be logged in");
     }
 
+    #[tokio::test]
+    async fn login_with_device() {
+        let homeserver = Url::from_str(&mockito::server_url()).unwrap();
+
+        let _m = mock("POST", "/_matrix/client/r0/login")
+            .with_status(200)
+            .with_body(test_json::LOGIN.to_string())
+            .create();
+
+        let client = Client::new(homeserver).unwrap();
+
+        client
+            .login("example", "wordpass", None, None)
+            .await
+            .unwrap();
+
+        let logged_in = client.logged_in().await;
+        assert!(logged_in, "Clint should be logged in");
+    }
+
     #[tokio::test]
     async fn sync() {
         let homeserver = Url::from_str(&mockito::server_url()).unwrap();

matrix_sdk/src/error.rs

@@ -14,18 +14,17 @@
 
 //! Error conditions.
 
+use matrix_sdk_base::Error as MatrixError;
+use matrix_sdk_common::{
+    api::{r0::uiaa::UiaaResponse as UiaaError, Error as RumaClientError},
+    FromHttpResponseError as RumaResponseError, IntoHttpError as RumaIntoHttpError,
+};
 use reqwest::Error as ReqwestError;
 use serde_json::Error as JsonError;
 use thiserror::Error;
 
 #[cfg(feature = "encryption")]
 use matrix_sdk_base::CryptoStoreError;
-use matrix_sdk_base::Error as MatrixError;
-
-use crate::api::r0::uiaa::UiaaResponse as UiaaError;
-use crate::api::Error as RumaClientError;
-use crate::FromHttpResponseError as RumaResponseError;
-use crate::IntoHttpError as RumaIntoHttpError;
 
 /// Result type of the rust-sdk.
 pub type Result<T> = std::result::Result<T, Error>;

matrix_sdk/src/http_client.rs

@@ -12,8 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::convert::TryFrom;
+use std::{convert::TryFrom, sync::Arc};
-use std::sync::Arc;
 
 use http::{Method as HttpMethod, Response as HttpResponse};
 use reqwest::{header::AUTHORIZATION, Client, Response};

matrix_sdk/src/lib.rs

@@ -36,24 +36,23 @@
     unused_qualifications
 )]
 
-pub use matrix_sdk_base::Error as BaseError;
 #[cfg(not(target_arch = "wasm32"))]
 pub use matrix_sdk_base::JsonStore;
-pub use matrix_sdk_base::{CustomOrRawEvent, EventEmitter, Room, Session, SyncRoom};
+pub use matrix_sdk_base::{
-#[cfg(feature = "messages")]
+    CustomOrRawEvent, Error as BaseError, EventEmitter, Room, RoomState, Session, StateStore,
-pub use matrix_sdk_base::{MessageQueue, PossiblyRedactedExt};
+    SyncRoom,
-pub use matrix_sdk_base::{RoomState, StateStore};
+};
-pub use matrix_sdk_common::*;
-pub use reqwest::header::InvalidHeaderValue;
-
 #[cfg(feature = "encryption")]
 pub use matrix_sdk_base::{Device, TrustState};
+#[cfg(feature = "messages")]
+pub use matrix_sdk_base::{MessageQueue, PossiblyRedactedExt};
+pub use matrix_sdk_common::*;
+pub use reqwest::header::InvalidHeaderValue;
 
 mod client;
 mod error;
 mod http_client;
 mod request_builder;
-#[cfg(feature = "encryption")]
 mod sas;
 
 pub use client::{Client, ClientConfig, SyncSettings};

matrix_sdk/src/request_builder.rs

@@ -454,10 +454,13 @@ mod test {
     use std::collections::BTreeMap;
 
     use super::*;
-    use crate::api::r0::filter::{LazyLoadOptions, RoomEventFilter};
+    use crate::{
-    use crate::events::room::power_levels::NotificationPowerLevels;
+        api::r0::filter::{LazyLoadOptions, RoomEventFilter},
-    use crate::js_int::Int;
+        events::room::power_levels::NotificationPowerLevels,
-    use crate::{identifiers::RoomId, Client, Session};
+        identifiers::RoomId,
+        js_int::Int,
+        Client, Session,
+    };
 
     use matrix_sdk_test::test_json;
     use mockito::{mock, Matcher};

matrix_sdk_base/src/client.rs

@@ -13,58 +13,59 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashMap;
 #[cfg(feature = "encryption")]
 use std::collections::{BTreeMap, HashSet};
-use std::fmt;
+use std::{
-use std::path::{Path, PathBuf};
+    collections::HashMap,
-use std::sync::Arc;
+    fmt,
-use zeroize::Zeroizing;
+    ops::Deref,
-
+    path::{Path, PathBuf},
-use std::result::Result as StdResult;
+    result::Result as StdResult,
-
+    sync::Arc,
-use crate::api::r0 as api;
-use crate::error::Result;
-use crate::events::presence::PresenceEvent;
-// `NonRoomEvent` is what it is aliased as
-use crate::event_emitter::CustomOrRawEvent;
-use crate::events::ignored_user_list::IgnoredUserListEvent;
-use crate::events::push_rules::PushRulesEvent;
-use crate::events::room::member::MemberEventContent;
-use crate::identifiers::{RoomId, UserId};
-use crate::models::Room;
-use crate::push::Ruleset;
-use crate::session::Session;
-use crate::state::{AllRooms, ClientState, StateStore};
-use crate::EventEmitter;
-use matrix_sdk_common::events::{
-    AnyBasicEvent, AnyStrippedStateEvent, AnySyncEphemeralRoomEvent, AnySyncMessageEvent,
-    AnySyncRoomEvent, AnySyncStateEvent,
 };
-use matrix_sdk_common::Raw;
 
 #[cfg(feature = "encryption")]
 use matrix_sdk_common::locks::Mutex;
-use matrix_sdk_common::locks::RwLock;
+use matrix_sdk_common::{
-use std::ops::Deref;
+    api::r0 as api,
-
+    events::{
+        ignored_user_list::IgnoredUserListEvent, push_rules::PushRulesEvent,
+        room::member::MemberEventContent, AnyBasicEvent, AnyStrippedStateEvent,
+        AnySyncEphemeralRoomEvent, AnySyncMessageEvent, AnySyncRoomEvent, AnySyncStateEvent,
+    },
+    identifiers::{RoomId, UserId},
+    locks::RwLock,
+    push::Ruleset,
+    Raw,
+};
 #[cfg(feature = "encryption")]
-use crate::api::r0::keys::{
+use matrix_sdk_common::{
+    api::r0::keys::{
         claim_keys::Response as KeysClaimResponse, get_keys::Response as KeysQueryResponse,
         upload_keys::Response as KeysUploadResponse, DeviceKeys, KeyAlgorithm,
-};
+    },
-#[cfg(feature = "encryption")]
+    api::r0::to_device::send_event_to_device::Request as ToDeviceRequest,
-use crate::api::r0::to_device::send_event_to_device::Request as ToDeviceRequest;
+    events::room::{
-#[cfg(feature = "encryption")]
-use crate::events::room::{
         encrypted::EncryptedEventContent, message::MessageEventContent as MsgEventContent,
+    },
+    identifiers::DeviceId,
 };
 #[cfg(feature = "encryption")]
-use crate::identifiers::DeviceId;
-#[cfg(not(target_arch = "wasm32"))]
-use crate::JsonStore;
-#[cfg(feature = "encryption")]
 use matrix_sdk_crypto::{CryptoStore, OlmError, OlmMachine, OneTimeKeys, Sas};
+use zeroize::Zeroizing;
+
+#[cfg(not(target_arch = "wasm32"))]
+use crate::JsonStore;
+
+use crate::{
+    error::Result,
+    event_emitter::CustomOrRawEvent,
+    events::presence::PresenceEvent,
+    models::Room,
+    session::Session,
+    state::{AllRooms, ClientState, StateStore},
+    EventEmitter,
+};
 
 pub type Token = String;
 
@@ -1867,10 +1868,12 @@ impl BaseClient {
 
 #[cfg(test)]
 mod test {
-    use crate::identifiers::{RoomId, UserId};
     #[cfg(feature = "messages")]
     use crate::{events::AnySyncRoomEvent, identifiers::EventId, BaseClientConfig, JsonStore, Raw};
-    use crate::{BaseClient, Session};
+    use crate::{
+        identifiers::{RoomId, UserId},
+        BaseClient, Session,
+    };
     use matrix_sdk_common_macros::async_trait;
     use matrix_sdk_test::{async_test, test_json, EventBuilder, EventsJson};
     use serde_json::json;
@@ -2033,11 +2036,13 @@ mod test {
         use super::*;
 
         use crate::{EventEmitter, SyncRoom};
-        use matrix_sdk_common::events::{
+        use matrix_sdk_common::{
+            events::{
                 room::member::{MemberEventContent, MembershipChange},
                 SyncStateEvent,
+            },
+            locks::RwLock,
         };
-        use matrix_sdk_common::locks::RwLock;
         use std::sync::{
             atomic::{AtomicBool, Ordering},
             Arc,
@@ -2289,8 +2294,7 @@ mod test {
         use super::*;
 
         use crate::{EventEmitter, SyncRoom};
-        use matrix_sdk_common::api::r0::sync::sync_events;
+        use matrix_sdk_common::{api::r0::sync::sync_events, locks::RwLock};
-        use matrix_sdk_common::locks::RwLock;
         use std::sync::{
             atomic::{AtomicBool, Ordering},
             Arc,

matrix_sdk_base/src/event_emitter/mod.rs

@@ -17,7 +17,8 @@ use std::sync::Arc;
 use matrix_sdk_common::locks::RwLock;
 use serde_json::value::RawValue as RawJsonValue;
 
-use crate::events::{
+use crate::{
+    events::{
         custom::CustomEventContent,
         fully_read::FullyReadEventContent,
         ignored_user_list::IgnoredUserListEventContent,
@@ -38,8 +39,9 @@ use crate::events::{
         },
         typing::TypingEventContent,
         BasicEvent, StrippedStateEvent, SyncEphemeralRoomEvent, SyncMessageEvent, SyncStateEvent,
+    },
+    Room, RoomState,
 };
-use crate::{Room, RoomState};
 use matrix_sdk_common_macros::async_trait;
 
 /// Type alias for `RoomState` enum when passed to `EventEmitter` methods.
@@ -471,8 +473,7 @@ mod test {
         }
     }
 
-    use crate::identifiers::UserId;
+    use crate::{identifiers::UserId, BaseClient, Session};
-    use crate::{BaseClient, Session};
 
     use std::convert::TryFrom;
 

matrix_sdk_base/src/lib.rs

@@ -35,7 +35,10 @@
     unused_qualifications
 )]
 
-pub use crate::{error::Error, error::Result, session::Session};
+pub use crate::{
+    error::{Error, Result},
+    session::Session,
+};
 pub use matrix_sdk_common::*;
 
 mod client;

matrix_sdk_base/src/models/message.rs

@@ -5,11 +5,12 @@
 
 use std::{time::SystemTime, vec::IntoIter};
 
-use matrix_sdk_common::identifiers::{EventId, UserId};
+use matrix_sdk_common::{
+    events::AnyPossiblyRedactedSyncMessageEvent,
+    identifiers::{EventId, UserId},
+};
 use serde::{de, ser, Serialize};
 
-use crate::events::AnyPossiblyRedactedSyncMessageEvent;
-
 /// Exposes some of the field access methods found in the event held by
 /// `AnyPossiblyRedacted*` enums.
 ///
@@ -160,8 +161,7 @@ pub(crate) mod ser_deser {
 
 #[cfg(test)]
 mod test {
-    use std::collections::HashMap;
+    use std::{collections::HashMap, convert::TryFrom};
-    use std::convert::TryFrom;
 
     use matrix_sdk_common::{
         events::{AnyPossiblyRedactedSyncMessageEvent, AnySyncMessageEvent},

matrix_sdk_base/src/models/room.rs

@@ -13,19 +13,20 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::{BTreeMap, HashMap, HashSet};
-use std::convert::TryFrom;
 #[cfg(feature = "messages")]
 use std::ops::DerefMut;
-
+use std::{
-use serde::{Deserialize, Serialize};
+    collections::{BTreeMap, HashMap, HashSet},
-use tracing::{debug, error, trace};
+    convert::TryFrom,
+};
 
 #[cfg(feature = "messages")]
-use super::message::MessageQueue;
+use matrix_sdk_common::events::{
-use super::RoomMember;
+    room::redaction::SyncRedactionEvent, AnyPossiblyRedactedSyncMessageEvent, AnySyncMessageEvent,
-use crate::api::r0::sync::sync_events::{RoomSummary, UnreadNotificationsCount};
+};
-use crate::events::{
+use matrix_sdk_common::{
+    api::r0::sync::sync_events::{RoomSummary, UnreadNotificationsCount},
+    events::{
         presence::{PresenceEvent, PresenceEventContent},
         room::{
             aliases::AliasesEventContent,
@@ -38,16 +39,16 @@ use crate::events::{
         },
         Algorithm, AnyStrippedStateEvent, AnySyncRoomEvent, AnySyncStateEvent, EventType,
         StrippedStateEvent, SyncStateEvent,
+    },
+    identifiers::{RoomAliasId, RoomId, UserId},
+    js_int::{int, uint, Int, UInt},
 };
+use serde::{Deserialize, Serialize};
+use tracing::{debug, error, trace};
 
 #[cfg(feature = "messages")]
-use crate::events::{
+use super::message::MessageQueue;
-    room::redaction::SyncRedactionEvent, AnyPossiblyRedactedSyncMessageEvent, AnySyncMessageEvent,
+use super::RoomMember;
-};
-
-use crate::identifiers::{RoomAliasId, RoomId, UserId};
-
-use crate::js_int::{int, uint, Int, UInt};
 
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 /// `RoomName` allows the calculation of a text room name.
@@ -670,8 +671,7 @@ impl Room {
     #[cfg(feature = "messages")]
     #[cfg_attr(docsrs, doc(cfg(feature = "messages")))]
     pub fn handle_redaction(&mut self, redacted_event: &SyncRedactionEvent) -> bool {
-        use crate::identifiers::RoomVersionId;
+        use crate::{identifiers::RoomVersionId, models::message::PossiblyRedactedExt};
-        use crate::models::message::PossiblyRedactedExt;
 
         if let Some(mut msg) = self
             .messages
@@ -1080,9 +1080,11 @@ impl Describe for MembershipChange {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::events::{room::encryption::EncryptionEventContent, Unsigned};
+    use crate::{
-    use crate::identifiers::{EventId, UserId};
+        events::{room::encryption::EncryptionEventContent, Unsigned},
-    use crate::{BaseClient, Raw, Session};
+        identifiers::{EventId, UserId},
+        BaseClient, Raw, Session,
+    };
     use matrix_sdk_test::{async_test, sync_response, EventBuilder, EventsJson, SyncResponseFile};
 
     use std::time::SystemTime;
@@ -1090,8 +1092,7 @@ mod test {
     #[cfg(target_arch = "wasm32")]
     use wasm_bindgen_test::*;
 
-    use std::convert::TryFrom;
+    use std::{convert::TryFrom, ops::Deref};
-    use std::ops::Deref;
 
     async fn get_client() -> BaseClient {
         let session = Session {

matrix_sdk_base/src/models/room_member.rs

@@ -154,8 +154,10 @@ impl RoomMember {
 mod test {
     use matrix_sdk_test::{async_test, EventBuilder, EventsJson};
 
-    use crate::identifiers::{RoomId, UserId};
+    use crate::{
-    use crate::{BaseClient, Session};
+        identifiers::{RoomId, UserId},
+        BaseClient, Session,
+    };
 
     use crate::js_int::int;
 

matrix_sdk_base/src/session.rs

@@ -15,7 +15,7 @@
 
 //! User sessions.
 
-use crate::identifiers::{DeviceId, UserId};
+use matrix_sdk_common::identifiers::{DeviceId, UserId};
 
 /// A user session, containing an access token and information about the
 /// associated user account.

matrix_sdk_base/src/state/json_store.rs

@@ -1,16 +1,15 @@
-use std::collections::HashMap;
+use std::{
-use std::fmt;
+    collections::HashMap,
-use std::fs;
+    fmt, fs,
-use std::path::{Path, PathBuf};
+    path::{Path, PathBuf},
-use std::sync::{
+    sync::{
         atomic::{AtomicBool, Ordering},
         Arc,
+    },
 };
 
-use matrix_sdk_common::identifiers::RoomId;
+use matrix_sdk_common::{identifiers::RoomId, locks::RwLock};
-use matrix_sdk_common::locks::RwLock;
+use tokio::{fs as async_fs, io::AsyncWriteExt};
-use tokio::fs as async_fs;
-use tokio::io::AsyncWriteExt;
 
 use super::{AllRooms, ClientState, StateStore};
 use crate::{Error, Result, Room, RoomState, Session};
@@ -218,14 +217,15 @@ impl StateStore for JsonStore {
 mod test {
     use super::*;
 
-    use std::convert::TryFrom;
+    use std::{convert::TryFrom, path::PathBuf};
-    use std::path::PathBuf;
 
     use tempfile::tempdir;
 
-    use crate::identifiers::{RoomId, UserId};
+    use crate::{
-    use crate::push::Ruleset;
+        identifiers::{RoomId, UserId},
-    use crate::{BaseClient, BaseClientConfig, Session};
+        push::Ruleset,
+        BaseClient, BaseClientConfig, Session,
+    };
 
     use matrix_sdk_test::{sync_response, SyncResponseFile};
 

matrix_sdk_base/src/state/mod.rs

@@ -15,6 +15,10 @@
 
 use std::collections::HashMap;
 
+use matrix_sdk_common::{
+    identifiers::{RoomId, UserId},
+    push::Ruleset,
+};
 use serde::{Deserialize, Serialize};
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -22,10 +26,10 @@ mod json_store;
 #[cfg(not(target_arch = "wasm32"))]
 pub use json_store::JsonStore;
 
-use crate::client::{BaseClient, Token};
+use crate::{
-use crate::identifiers::{RoomId, UserId};
+    client::{BaseClient, Token},
-use crate::push::Ruleset;
+    Result, Room, RoomState, Session,
-use crate::{Result, Room, RoomState, Session};
+};
 
 #[cfg(not(target_arch = "wasm32"))]
 use matrix_sdk_common_macros::send_sync;
@@ -117,8 +121,7 @@ pub trait StateStore {
 mod test {
     use super::*;
 
-    use std::collections::HashMap;
+    use std::{collections::HashMap, convert::TryFrom};
-    use std::convert::TryFrom;
 
     use crate::identifiers::RoomId;
 

matrix_sdk_common/src/lib.rs

@@ -1,6 +1,5 @@
 pub use instant;
 pub use js_int;
-
 pub use ruma::{
     api::{
         client as api,

matrix_sdk_crypto/src/device.rs

@@ -12,22 +12,27 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::BTreeMap;
+use std::{
-use std::convert::TryFrom;
+    collections::BTreeMap,
-use std::sync::atomic::{AtomicBool, Ordering};
+    convert::TryFrom,
-use std::sync::Arc;
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+};
 
 use atomic::Atomic;
+use matrix_sdk_common::{
+    api::r0::keys::{AlgorithmAndDeviceId, DeviceKeys, KeyAlgorithm, SignedKey},
+    events::Algorithm,
+    identifiers::{DeviceId, UserId},
+};
 use serde_json::{json, Value};
 
 #[cfg(test)]
 use super::{Account, OlmMachine};
-use matrix_sdk_common::api::r0::keys::{AlgorithmAndDeviceId, DeviceKeys, KeyAlgorithm, SignedKey};
-use matrix_sdk_common::events::Algorithm;
-use matrix_sdk_common::identifiers::{DeviceId, UserId};
 
-use crate::error::SignatureError;
+use crate::{error::SignatureError, verify_json};
-use crate::verify_json;
 
 /// A device represents a E2EE capable client of an user.
 #[derive(Debug, Clone)]
@@ -243,8 +248,10 @@ pub(crate) mod test {
     use std::convert::TryFrom;
 
     use crate::device::{Device, TrustState};
-    use matrix_sdk_common::api::r0::keys::{DeviceKeys, KeyAlgorithm};
+    use matrix_sdk_common::{
-    use matrix_sdk_common::identifiers::UserId;
+        api::r0::keys::{DeviceKeys, KeyAlgorithm},
+        identifiers::UserId,
+    };
 
     fn device_keys() -> DeviceKeys {
         let device_keys = json!({

matrix_sdk_crypto/src/lib.rs

@@ -45,8 +45,10 @@ pub use store::{CryptoStore, CryptoStoreError};
 pub use verification::Sas;
 
 use error::SignatureError;
-use matrix_sdk_common::api::r0::keys::{AlgorithmAndDeviceId, KeyAlgorithm};
+use matrix_sdk_common::{
-use matrix_sdk_common::identifiers::UserId;
+    api::r0::keys::{AlgorithmAndDeviceId, KeyAlgorithm},
+    identifiers::UserId,
+};
 use olm_rs::utility::OlmUtility;
 use serde_json::Value;
 

matrix_sdk_crypto/src/machine.rs

@@ -12,45 +12,53 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::{BTreeMap, HashMap, HashSet};
-use std::convert::{TryFrom, TryInto};
-use std::mem;
 #[cfg(feature = "sqlite-cryptostore")]
 use std::path::Path;
-use std::result::Result as StdResult;
+use std::{
-use std::sync::Arc;
+    collections::{BTreeMap, HashMap, HashSet},
-
+    convert::{TryFrom, TryInto},
-use super::error::{EventError, MegolmError, MegolmResult, OlmError, OlmResult};
+    mem,
-use super::olm::{
+    result::Result as StdResult,
-    Account, GroupSessionKey, IdentityKeys, InboundGroupSession, OlmMessage, OutboundGroupSession,
+    sync::Arc,
 };
-use super::store::memorystore::MemoryStore;
-#[cfg(feature = "sqlite-cryptostore")]
-use super::store::sqlite::SqliteStore;
-use super::{device::Device, store::Result as StoreResult, CryptoStore};
-use crate::verification::{Sas, VerificationMachine};
 
-use matrix_sdk_common::events::{
-    forwarded_room_key::ForwardedRoomKeyEventContent, room::encrypted::EncryptedEventContent,
-    room::message::MessageEventContent, room_key::RoomKeyEventContent,
-    room_key_request::RoomKeyRequestEventContent, Algorithm, AnySyncRoomEvent, AnyToDeviceEvent,
-    EventType, SyncMessageEvent, ToDeviceEvent,
-};
-use matrix_sdk_common::identifiers::{DeviceId, RoomId, UserId};
-use matrix_sdk_common::locks::RwLock;
-use matrix_sdk_common::uuid::Uuid;
-use matrix_sdk_common::{api, Raw};
-
-use api::r0::keys;
 use api::r0::{
+    keys,
     keys::{AlgorithmAndDeviceId, DeviceKeys, KeyAlgorithm, OneTimeKey},
     sync::sync_events::Response as SyncResponse,
     to_device::{send_event_to_device::Request as ToDeviceRequest, DeviceIdOrAllDevices},
 };
-
+use matrix_sdk_common::{
+    api,
+    events::{
+        forwarded_room_key::ForwardedRoomKeyEventContent,
+        room::{encrypted::EncryptedEventContent, message::MessageEventContent},
+        room_key::RoomKeyEventContent,
+        room_key_request::RoomKeyRequestEventContent,
+        Algorithm, AnySyncRoomEvent, AnyToDeviceEvent, EventType, SyncMessageEvent, ToDeviceEvent,
+    },
+    identifiers::{DeviceId, RoomId, UserId},
+    locks::RwLock,
+    uuid::Uuid,
+    Raw,
+};
 use serde_json::Value;
 use tracing::{debug, error, info, instrument, trace, warn};
 
+#[cfg(feature = "sqlite-cryptostore")]
+use super::store::sqlite::SqliteStore;
+use super::{
+    device::Device,
+    error::{EventError, MegolmError, MegolmResult, OlmError, OlmResult},
+    olm::{
+        Account, GroupSessionKey, IdentityKeys, InboundGroupSession, OlmMessage,
+        OutboundGroupSession,
+    },
+    store::{memorystore::MemoryStore, Result as StoreResult},
+    verification::{Sas, VerificationMachine},
+    CryptoStore,
+};
+
 /// A map from the algorithm and device id to a one-time key.
 ///
 /// These keys need to be periodically uploaded to the server.
@@ -1262,30 +1270,33 @@ mod test {
     static USER_ID: &str = "@bob:example.org";
 
     use matrix_sdk_common::js_int::uint;
-    use std::collections::BTreeMap;
+    use std::{
-    use std::convert::TryFrom;
+        collections::BTreeMap,
-    use std::convert::TryInto;
+        convert::{TryFrom, TryInto},
-    use std::time::SystemTime;
+        time::SystemTime,
+    };
 
     use http::Response;
     use serde_json::json;
 
-    use crate::machine::{OlmMachine, OneTimeKeys};
+    use crate::{
-    use crate::{verify_json, Device};
+        machine::{OlmMachine, OneTimeKeys},
-
+        verify_json, Device,
-    use matrix_sdk_common::api::r0::{
-        keys, to_device::send_event_to_device::Request as ToDeviceRequest,
     };
-    use matrix_sdk_common::events::{
+
+    use matrix_sdk_common::{
+        api::r0::{keys, to_device::send_event_to_device::Request as ToDeviceRequest},
+        events::{
             room::{
                 encrypted::EncryptedEventContent,
                 message::{MessageEventContent, TextMessageEventContent},
             },
             AnySyncMessageEvent, AnySyncRoomEvent, AnyToDeviceEvent, EventType, SyncMessageEvent,
             ToDeviceEvent, Unsigned,
+        },
+        identifiers::{DeviceId, EventId, RoomId, UserId},
+        Raw,
     };
-    use matrix_sdk_common::identifiers::{DeviceId, EventId, RoomId, UserId};
-    use matrix_sdk_common::Raw;
     use matrix_sdk_test::test_json;
 
     fn alice_id() -> UserId {

matrix_sdk_crypto/src/memory_stores.rs

@@ -12,15 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
-use std::sync::Arc;
 
 use dashmap::{DashMap, ReadOnlyView};
-use matrix_sdk_common::locks::Mutex;
+use matrix_sdk_common::{
+    identifiers::{DeviceId, RoomId, UserId},
+    locks::Mutex,
+};
 
-use super::device::Device;
+use super::{
-use super::olm::{InboundGroupSession, Session};
+    device::Device,
-use matrix_sdk_common::identifiers::{DeviceId, RoomId, UserId};
+    olm::{InboundGroupSession, Session},
+};
 
 /// In-memory store for Olm Sessions.
 #[derive(Debug, Default)]
@@ -211,10 +214,11 @@ impl DeviceStore {
 mod test {
     use std::convert::TryFrom;
 
-    use crate::device::test::get_device;
+    use crate::{
-    use crate::memory_stores::{DeviceStore, GroupSessionStore, SessionStore};
+        device::test::get_device,
-    use crate::olm::test::get_account_and_session;
+        memory_stores::{DeviceStore, GroupSessionStore, SessionStore},
-    use crate::olm::InboundGroupSession;
+        olm::{test::get_account_and_session, InboundGroupSession},
+    };
     use matrix_sdk_common::identifiers::RoomId;
 
     #[tokio::test]

matrix_sdk_crypto/src/olm/account.rs

@@ -12,36 +12,38 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use matrix_sdk_common::instant::Instant;
+use std::{
-use std::convert::TryFrom;
+    collections::BTreeMap,
-use std::convert::TryInto;
+    convert::{TryFrom, TryInto},
-use std::fmt;
+    fmt,
-use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
+    sync::{
-use std::sync::Arc;
+        atomic::{AtomicBool, AtomicI64, Ordering},
-
+        Arc,
-use matrix_sdk_common::locks::Mutex;
+    },
-use serde_json::{json, Value};
-use std::collections::BTreeMap;
-
-pub use olm_rs::account::IdentityKeys;
-use olm_rs::account::{OlmAccount, OneTimeKeys};
-use olm_rs::errors::{OlmAccountError, OlmSessionError};
-use olm_rs::PicklingMode;
-
-use crate::device::Device;
-use crate::error::SessionCreationError;
-pub use olm_rs::{
-    session::{OlmMessage, PreKeyMessage},
-    utility::OlmUtility,
 };
 
 use matrix_sdk_common::{
     api::r0::keys::{AlgorithmAndDeviceId, DeviceKeys, KeyAlgorithm, OneTimeKey, SignedKey},
     events::Algorithm,
     identifiers::{DeviceId, RoomId, UserId},
+    instant::Instant,
+    locks::Mutex,
+};
+use olm_rs::{
+    account::{OlmAccount, OneTimeKeys},
+    errors::{OlmAccountError, OlmSessionError},
+    PicklingMode,
+};
+use serde_json::{json, Value};
+
+pub use olm_rs::{
+    account::IdentityKeys,
+    session::{OlmMessage, PreKeyMessage},
+    utility::OlmUtility,
 };
 
 use super::{InboundGroupSession, OutboundGroupSession, Session};
+use crate::{device::Device, error::SessionCreationError};
 
 /// Account holding identity keys for which sessions can be created.
 ///

matrix_sdk_crypto/src/olm/group_sessions.rs

@@ -12,27 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use matrix_sdk_common::instant::Instant;
+use std::{
-use std::convert::TryInto;
+    convert::TryInto,
-use std::fmt;
+    fmt,
-use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+    sync::{
-use std::sync::Arc;
+        atomic::{AtomicBool, AtomicUsize, Ordering},
-
+        Arc,
-use matrix_sdk_common::locks::Mutex;
+    },
-use serde::Serialize;
-use serde_json::{json, Value};
-use zeroize::Zeroize;
-
-pub use olm_rs::account::IdentityKeys;
-use olm_rs::errors::OlmGroupSessionError;
-use olm_rs::inbound_group_session::OlmInboundGroupSession;
-use olm_rs::outbound_group_session::OlmOutboundGroupSession;
-use olm_rs::PicklingMode;
-
-use crate::error::{EventError, MegolmResult};
-pub use olm_rs::{
-    session::{OlmMessage, PreKeyMessage},
-    utility::OlmUtility,
 };
 
 use matrix_sdk_common::{
@@ -41,8 +27,25 @@ use matrix_sdk_common::{
         Algorithm, AnySyncRoomEvent, EventType, SyncMessageEvent,
     },
     identifiers::{DeviceId, RoomId},
+    instant::Instant,
+    locks::Mutex,
     Raw,
 };
+use olm_rs::{
+    errors::OlmGroupSessionError, inbound_group_session::OlmInboundGroupSession,
+    outbound_group_session::OlmOutboundGroupSession, PicklingMode,
+};
+use serde::Serialize;
+use serde_json::{json, Value};
+use zeroize::Zeroize;
+
+pub use olm_rs::{
+    account::IdentityKeys,
+    session::{OlmMessage, PreKeyMessage},
+    utility::OlmUtility,
+};
+
+use crate::error::{EventError, MegolmResult};
 
 /// The private session key of a group session.
 /// Can be used to create a new inbound group session.

matrix_sdk_crypto/src/olm/mod.rs

@@ -23,11 +23,12 @@ pub use session::{OlmMessage, Session};
 #[cfg(test)]
 pub(crate) mod test {
     use crate::olm::{Account, InboundGroupSession, Session};
-    use matrix_sdk_common::api::r0::keys::SignedKey;
+    use matrix_sdk_common::{
-    use matrix_sdk_common::identifiers::{DeviceId, RoomId, UserId};
+        api::r0::keys::SignedKey,
+        identifiers::{DeviceId, RoomId, UserId},
+    };
     use olm_rs::session::OlmMessage;
-    use std::collections::BTreeMap;
+    use std::{collections::BTreeMap, convert::TryFrom};
-    use std::convert::TryFrom;
 
     fn alice_id() -> UserId {
         UserId::try_from("@alice:example.org").unwrap()

matrix_sdk_crypto/src/olm/session.rs

@@ -12,24 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, fmt, sync::Arc};
-use std::fmt;
-use std::sync::Arc;
-
-use olm_rs::errors::OlmSessionError;
-use olm_rs::session::OlmSession;
-use olm_rs::PicklingMode;
-
-use serde_json::{json, Value};
-
-pub use olm_rs::{
-    session::{OlmMessage, PreKeyMessage},
-    utility::OlmUtility,
-};
-
-use super::IdentityKeys;
-use crate::error::{EventError, OlmResult};
-use crate::Device;
 
 use matrix_sdk_common::{
     api::r0::keys::KeyAlgorithm,
@@ -41,6 +24,19 @@ use matrix_sdk_common::{
     instant::Instant,
     locks::Mutex,
 };
+use olm_rs::{errors::OlmSessionError, session::OlmSession, PicklingMode};
+use serde_json::{json, Value};
+
+use super::IdentityKeys;
+use crate::{
+    error::{EventError, OlmResult},
+    Device,
+};
+
+pub use olm_rs::{
+    session::{OlmMessage, PreKeyMessage},
+    utility::OlmUtility,
+};
 
 /// Cryptographic session that enables secure communication between two
 /// `Account`s

matrix_sdk_crypto/src/store/memorystore.rs

@@ -12,17 +12,19 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashSet;
+use std::{collections::HashSet, sync::Arc};
-use std::sync::Arc;
 
 use async_trait::async_trait;
-use matrix_sdk_common::locks::Mutex;
+use matrix_sdk_common::{
+    identifiers::{DeviceId, RoomId, UserId},
+    locks::Mutex,
+};
 
 use super::{Account, CryptoStore, InboundGroupSession, Result, Session};
-use crate::device::Device;
+use crate::{
-use crate::memory_stores::{DeviceStore, GroupSessionStore, SessionStore, UserDevices};
+    device::Device,
-use matrix_sdk_common::identifiers::{DeviceId, RoomId, UserId};
+    memory_stores::{DeviceStore, GroupSessionStore, SessionStore, UserDevices},
-
+};
 #[derive(Debug)]
 pub struct MemoryStore {
     sessions: SessionStore,
@@ -126,11 +128,11 @@ impl CryptoStore for MemoryStore {
 mod test {
     use std::convert::TryFrom;
 
-    use crate::device::test::get_device;
+    use crate::{
-    use crate::olm::test::get_account_and_session;
+        device::test::get_device,
-    use crate::olm::InboundGroupSession;
+        olm::{test::get_account_and_session, InboundGroupSession},
-    use crate::store::memorystore::MemoryStore;
+        store::{memorystore::MemoryStore, CryptoStore},
-    use crate::store::CryptoStore;
+    };
     use matrix_sdk_common::identifiers::RoomId;
 
     #[tokio::test]

matrix_sdk_crypto/src/store/mod.rs

@@ -12,23 +12,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use core::fmt::Debug;
+use std::{collections::HashSet, io::Error as IoError, sync::Arc};
-use std::collections::HashSet;
-use std::io::Error as IoError;
-use std::sync::Arc;
-use url::ParseError;
 
 use async_trait::async_trait;
-use matrix_sdk_common::locks::Mutex;
+use core::fmt::Debug;
-use serde_json::Error as SerdeError;
+use matrix_sdk_common::{
-use thiserror::Error;
+    identifiers::{DeviceId, RoomId, UserId},
-
+    locks::Mutex,
-use super::device::Device;
+};
-use super::memory_stores::UserDevices;
-use super::olm::{Account, InboundGroupSession, Session};
-use matrix_sdk_common::identifiers::{DeviceId, RoomId, UserId};
 use matrix_sdk_common_macros::send_sync;
 use olm_rs::errors::{OlmAccountError, OlmGroupSessionError, OlmSessionError};
+use serde_json::Error as SerdeError;
+use thiserror::Error;
+use url::ParseError;
+
+use super::{
+    device::Device,
+    memory_stores::UserDevices,
+    olm::{Account, InboundGroupSession, Session},
+};
 
 pub mod memorystore;
 

matrix_sdk_crypto/src/store/sqlite.rs

@@ -12,27 +12,33 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use matrix_sdk_common::instant::{Duration, Instant};
+use std::{
-use std::collections::{BTreeMap, HashSet};
+    collections::{BTreeMap, HashSet},
-use std::convert::TryFrom;
+    convert::TryFrom,
-use std::path::{Path, PathBuf};
+    path::{Path, PathBuf},
-use std::result::Result as StdResult;
+    result::Result as StdResult,
-use std::sync::Arc;
+    sync::Arc,
-use url::Url;
+};
 
 use async_trait::async_trait;
-use matrix_sdk_common::locks::Mutex;
+use matrix_sdk_common::{
+    api::r0::keys::{AlgorithmAndDeviceId, KeyAlgorithm},
+    events::Algorithm,
+    identifiers::{DeviceId, RoomId, UserId},
+    instant::{Duration, Instant},
+    locks::Mutex,
+};
 use olm_rs::PicklingMode;
 use sqlx::{query, query_as, sqlite::SqliteQueryAs, Connect, Executor, SqliteConnection};
+use url::Url;
 use zeroize::Zeroizing;
 
 use super::{CryptoStore, CryptoStoreError, Result};
-use crate::device::{Device, TrustState};
+use crate::{
-use crate::memory_stores::{DeviceStore, GroupSessionStore, SessionStore, UserDevices};
+    device::{Device, TrustState},
-use crate::{Account, IdentityKeys, InboundGroupSession, Session};
+    memory_stores::{DeviceStore, GroupSessionStore, SessionStore, UserDevices},
-use matrix_sdk_common::api::r0::keys::{AlgorithmAndDeviceId, KeyAlgorithm};
+    Account, IdentityKeys, InboundGroupSession, Session,
-use matrix_sdk_common::events::Algorithm;
+};
-use matrix_sdk_common::identifiers::{DeviceId, RoomId, UserId};
 
 /// SQLite based implementation of a `CryptoStore`.
 pub struct SqliteStore {
@@ -887,10 +893,11 @@ impl std::fmt::Debug for SqliteStore {
 
 #[cfg(test)]
 mod test {
-    use crate::device::test::get_device;
+    use crate::{device::test::get_device, olm::GroupSessionKey};
-    use crate::olm::GroupSessionKey;
+    use matrix_sdk_common::{
-    use matrix_sdk_common::api::r0::keys::SignedKey;
+        api::r0::keys::SignedKey,
-    use matrix_sdk_common::identifiers::{DeviceId, UserId};
+        identifiers::{DeviceId, UserId},
+    };
     use olm_rs::outbound_group_session::OlmOutboundGroupSession;
     use std::collections::BTreeMap;
     use tempfile::tempdir;

matrix_sdk_crypto/src/verification/machine.rs

@@ -160,8 +160,7 @@ impl VerificationMachine {
 #[cfg(test)]
 mod test {
 
-    use std::convert::TryFrom;
+    use std::{convert::TryFrom, sync::Arc};
-    use std::sync::Arc;
 
     use matrix_sdk_common::{
         events::AnyToDeviceEventContent,
@@ -170,8 +169,11 @@ mod test {
     };
 
     use super::{Sas, VerificationMachine};
-    use crate::verification::test::{get_content_from_request, wrap_any_to_device_content};
+    use crate::{
-    use crate::{store::memorystore::MemoryStore, Account, CryptoStore, Device};
+        store::memorystore::MemoryStore,
+        verification::test::{get_content_from_request, wrap_any_to_device_content},
+        Account, CryptoStore, Device,
+    };
 
     fn alice_id() -> UserId {
         UserId::try_from("@alice:example.org").unwrap()

matrix_sdk_crypto/src/verification/sas/helpers.rs

@@ -1,5 +1,4 @@
-use std::collections::BTreeMap;
+use std::{collections::BTreeMap, convert::TryInto};
-use std::convert::TryInto;
 
 use olm_rs::sas::OlmSas;
 

matrix_sdk_crypto/src/verification/sas/mod.rs

@@ -491,12 +491,13 @@ impl InnerSas {
 
 #[cfg(test)]
 mod test {
-    use std::convert::TryFrom;
+    use std::{convert::TryFrom, sync::Arc};
-    use std::sync::Arc;
 
-    use matrix_sdk_common::events::{EventContent, ToDeviceEvent};
+    use matrix_sdk_common::{
-    use matrix_sdk_common::identifiers::{DeviceId, UserId};
+        events::{EventContent, ToDeviceEvent},
-    use matrix_sdk_common::locks::RwLock;
+        identifiers::{DeviceId, UserId},
+        locks::RwLock,
+    };
 
     use crate::{
         store::memorystore::MemoryStore,

matrix_sdk_crypto/src/verification/sas/sas_state.rs

@@ -744,8 +744,10 @@ mod test {
     use std::convert::TryFrom;
 
     use crate::{Account, Device};
-    use matrix_sdk_common::events::{EventContent, ToDeviceEvent};
+    use matrix_sdk_common::{
-    use matrix_sdk_common::identifiers::{DeviceId, UserId};
+        events::{EventContent, ToDeviceEvent},
+        identifiers::{DeviceId, UserId},
+    };
 
     use super::{Accepted, Created, SasState, Started};
 

matrix_sdk_test/src/lib.rs

@@ -1,15 +1,15 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, convert::TryFrom, panic};
-use std::convert::TryFrom;
-use std::panic;
 
 use http::Response;
 
-use matrix_sdk_common::api::r0::sync::sync_events::Response as SyncResponse;
+use matrix_sdk_common::{
-use matrix_sdk_common::events::{
+    api::r0::sync::sync_events::Response as SyncResponse,
+    events::{
         presence::PresenceEvent, AnyBasicEvent, AnySyncEphemeralRoomEvent, AnySyncRoomEvent,
         AnySyncStateEvent,
+    },
+    identifiers::RoomId,
 };
-use matrix_sdk_common::identifiers::RoomId;
 use serde_json::Value as JsonValue;
 
 pub use matrix_sdk_test_macros::async_test;