Automatically group imports using nightly rustfmt

benches/create_account.rs

@@ -1,6 +1,7 @@
+use std::path::PathBuf;
+
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use deltachat::accounts::Accounts;
-use std::path::PathBuf;
 use tempfile::tempdir;
 
 async fn create_accounts(n: u32) {

benches/get_chat_msgs.rs

@@ -1,7 +1,6 @@
 use std::path::Path;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-
 use deltachat::chat::{self, ChatId};
 use deltachat::chatlist::Chatlist;
 use deltachat::context::Context;

benches/get_chatlist.rs

@@ -1,7 +1,6 @@
 use std::path::Path;
 
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
-
 use deltachat::chatlist::Chatlist;
 use deltachat::context::Context;
 use deltachat::stock_str::StockStrings;

benches/search_msgs.rs

@@ -1,8 +1,9 @@
+use std::path::Path;
+
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use deltachat::context::Context;
 use deltachat::stock_str::StockStrings;
 use deltachat::Events;
-use std::path::Path;
 
 async fn search_benchmark(dbfile: impl AsRef<Path>) {
     let id = 100;

deltachat-ffi/src/lib.rs

@@ -23,13 +23,6 @@ use std::sync::Arc;
 use std::time::{Duration, SystemTime};
 
 use anyhow::Context as _;
-use deltachat::qr_code_generator::get_securejoin_qr_svg;
-use num_traits::{FromPrimitive, ToPrimitive};
-use once_cell::sync::Lazy;
-use rand::Rng;
-use tokio::runtime::Runtime;
-use tokio::sync::RwLock;
-
 use deltachat::chat::{ChatId, ChatVisibility, MuteDuration, ProtectionStatus};
 use deltachat::constants::DC_MSG_ID_LAST_SPECIAL;
 use deltachat::contact::{Contact, ContactId, Origin};
@@ -37,21 +30,28 @@ use deltachat::context::Context;
 use deltachat::ephemeral::Timer as EphemeralTimer;
 use deltachat::key::DcKey;
 use deltachat::message::MsgId;
+use deltachat::qr_code_generator::get_securejoin_qr_svg;
 use deltachat::reaction::{get_msg_reactions, send_reaction, Reactions};
 use deltachat::stock_str::StockMessage;
 use deltachat::stock_str::StockStrings;
 use deltachat::webxdc::StatusUpdateSerial;
 use deltachat::*;
 use deltachat::{accounts::Accounts, log::LogExt};
+use num_traits::{FromPrimitive, ToPrimitive};
+use once_cell::sync::Lazy;
+use rand::Rng;
+use tokio::runtime::Runtime;
+use tokio::sync::RwLock;
 use tokio::task::JoinHandle;
 
 mod dc_array;
 mod lot;
 
 mod string;
-use self::string::*;
 use deltachat::chatlist::Chatlist;
 
+use self::string::*;
+
 // as C lacks a good and portable error handling,
 // in general, the C Interface is forgiving wrt to bad parameters.
 // - objects returned by some functions
@@ -4577,11 +4577,12 @@ pub unsafe extern "C" fn dc_accounts_get_event_emitter(
 
 #[cfg(feature = "jsonrpc")]
 mod jsonrpc {
-    use super::*;
     use deltachat_jsonrpc::api::CommandApi;
     use deltachat_jsonrpc::events::event_to_json_rpc_notification;
     use deltachat_jsonrpc::yerpc::{OutReceiver, RpcClient, RpcSession};
 
+    use super::*;
+
     pub struct dc_jsonrpc_instance_t {
         receiver: OutReceiver,
         handle: RpcSession<CommandApi>,

deltachat-ffi/src/lot.rs

@@ -1,10 +1,12 @@
 //! # Legacy generic return values for C API.
 
+use std::borrow::Cow;
+
+use anyhow::Error;
+
 use crate::message::MessageState;
 use crate::qr::Qr;
 use crate::summary::{Summary, SummaryPrefix};
-use anyhow::Error;
-use std::borrow::Cow;
 
 /// An object containing a set of values.
 /// The meaning of the values is defined by the function returning the object.

deltachat-ffi/src/string.rs

@@ -287,9 +287,10 @@ fn as_path_unicode<'a>(s: *const libc::c_char) -> &'a std::path::Path {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use libc::{free, strcmp};
 
+    use super::*;
+
     #[test]
     fn test_os_str_to_c_string_cwd() {
         let some_dir = std::env::current_dir().unwrap();

deltachat-jsonrpc/src/api/mod.rs

@@ -1,4 +1,9 @@
+use std::collections::BTreeMap;
+use std::sync::Arc;
+use std::{collections::HashMap, str::FromStr};
+
 use anyhow::{anyhow, bail, ensure, Context, Result};
+pub use deltachat::accounts::Accounts;
 use deltachat::{
     chat::{
         self, add_contact_to_chat, forward_msgs, get_chat_media, get_chat_msgs, marknoticed_chat,
@@ -23,21 +28,14 @@ use deltachat::{
     webxdc::StatusUpdateSerial,
 };
 use sanitize_filename::is_sanitized;
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::{collections::HashMap, str::FromStr};
 use tokio::{fs, sync::RwLock};
 use walkdir::WalkDir;
 use yerpc::rpc;
 
-pub use deltachat::accounts::Accounts;
-
 pub mod events;
 pub mod types;
 
-use crate::api::types::chat_list::{get_chat_list_item_by_id, ChatListItemFetchResult};
-use crate::api::types::qr::QrObject;
-
+use num_traits::FromPrimitive;
 use types::account::Account;
 use types::chat::FullChat;
 use types::chat_list::ChatListEntry;
@@ -53,8 +51,8 @@ use self::types::{
         JSONRPCMessageListItem, MessageNotificationInfo, MessageSearchResult, MessageViewtype,
     },
 };
-
-use num_traits::FromPrimitive;
+use crate::api::types::chat_list::{get_chat_list_item_by_id, ChatListItemFetchResult};
+use crate::api::types::qr::QrObject;
 
 #[derive(Clone, Debug)]
 pub struct CommandApi {

deltachat-jsonrpc/src/lib.rs

@@ -4,12 +4,13 @@ pub use yerpc;
 
 #[cfg(test)]
 mod tests {
-    use super::api::{Accounts, CommandApi};
     use async_channel::unbounded;
     use futures::StreamExt;
     use tempfile::TempDir;
     use yerpc::{RpcClient, RpcSession};
 
+    use super::api::{Accounts, CommandApi};
+
     #[tokio::test(flavor = "multi_thread")]
     async fn basic_json_rpc_functionality() -> anyhow::Result<()> {
         let tmp_dir = TempDir::new().unwrap().path().into();

deltachat-jsonrpc/src/webserver.rs

@@ -1,6 +1,7 @@
-use axum::{extract::ws::WebSocketUpgrade, response::Response, routing::get, Extension, Router};
 use std::net::SocketAddr;
 use std::path::PathBuf;
+
+use axum::{extract::ws::WebSocketUpgrade, response::Response, routing::get, Extension, Router};
 use yerpc::axum::handle_ws_rpc;
 use yerpc::{RpcClient, RpcSession};
 

deltachat_derive/src/lib.rs

@@ -1,9 +1,10 @@
 #![recursion_limit = "128"]
 extern crate proc_macro;
 
-use crate::proc_macro::TokenStream;
 use quote::quote;
 
+use crate::proc_macro::TokenStream;
+
 // For now, assume (not check) that these macroses are applied to enum without
 // data.  If this assumption is violated, compiler error will point to
 // generated code, which is not very user-friendly.

examples/simple.rs

@@ -1,5 +1,3 @@
-use tempfile::tempdir;
-
 use deltachat::chat::{self, ChatId};
 use deltachat::chatlist::*;
 use deltachat::config;
@@ -8,6 +6,7 @@ use deltachat::context::*;
 use deltachat::message::Message;
 use deltachat::stock_str::StockStrings;
 use deltachat::{EventType, Events};
+use tempfile::tempdir;
 
 fn cb(event: EventType) {
     match event {

src/accounts.rs

@@ -509,7 +509,6 @@ impl AccountConfig {
 #[cfg(test)]
 mod tests {
     use super::*;
-
     use crate::stock_str::{self, StockMessage};
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]

src/aheader.rs

@@ -2,11 +2,12 @@
 //!
 //! Parse and create [Autocrypt-headers](https://autocrypt.org/en/latest/level1.html#the-autocrypt-header).
 
-use anyhow::{bail, Context as _, Error, Result};
 use std::collections::BTreeMap;
 use std::fmt;
 use std::str::FromStr;
 
+use anyhow::{bail, Context as _, Error, Result};
+
 use crate::key::{DcKey, SignedPublicKey};
 
 /// Possible values for encryption preference

src/authres.rs

@@ -355,7 +355,6 @@ mod tests {
     use tokio::io::AsyncReadExt;
 
     use super::*;
-
     use crate::aheader::EncryptPreference;
     use crate::e2ee;
     use crate::message;

src/blob.rs

@@ -499,17 +499,15 @@ fn encoded_img_exceeds_bytes(
 
 #[cfg(test)]
 mod tests {
-    use fs::File;
-
     use anyhow::Result;
+    use fs::File;
     use image::{GenericImageView, Pixel};
 
+    use super::*;
     use crate::chat::{self, create_group_chat, ProtectionStatus};
     use crate::message::Message;
     use crate::test_utils::{self, TestContext};
 
-    use super::*;
-
     fn check_image_size(path: impl AsRef<Path>, width: u32, height: u32) -> image::DynamicImage {
         tokio::task::block_in_place(move || {
             let img = image::open(path).expect("failed to open image");

src/chat.rs

@@ -3675,12 +3675,10 @@ pub(crate) async fn update_msg_text_and_timestamp(
 #[cfg(test)]
 mod tests {
     use super::*;
-
     use crate::chatlist::{get_archived_cnt, Chatlist};
     use crate::constants::{DC_GCL_ARCHIVED_ONLY, DC_GCL_NO_SPECIALS};
     use crate::contact::{Contact, ContactAddress};
     use crate::receive_imf::receive_imf;
-
     use crate::test_utils::TestContext;
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]

src/chatlist.rs

@@ -365,7 +365,6 @@ pub async fn get_archived_cnt(context: &Context) -> Result<usize> {
 #[cfg(test)]
 mod tests {
     use super::*;
-
     use crate::chat::{create_group_chat, get_chat_contacts, ProtectionStatus};
     use crate::message::Viewtype;
     use crate::receive_imf::receive_imf;

src/config.rs

@@ -440,16 +440,15 @@ fn get_config_keys_string() -> String {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-
     use std::str::FromStr;
     use std::string::ToString;
 
+    use num_traits::FromPrimitive;
+
+    use super::*;
     use crate::constants;
     use crate::test_utils::TestContext;
 
-    use num_traits::FromPrimitive;
-
     #[test]
     fn test_to_string() {
         assert_eq!(Config::MailServer.to_string(), "mail_server");

src/configure.rs

@@ -6,9 +6,12 @@ mod read_url;
 mod server_params;
 
 use anyhow::{bail, ensure, Context as _, Result};
+use auto_mozilla::moz_autoconfigure;
+use auto_outlook::outlk_autodiscover;
 use futures::FutureExt;
 use futures_lite::FutureExt as _;
 use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
+use server_params::{expand_param_vector, ServerParams};
 use tokio::task;
 
 use crate::config::Config;
@@ -28,10 +31,6 @@ use crate::stock_str;
 use crate::tools::{time, EmailAddress};
 use crate::{chat, e2ee, provider};
 
-use auto_mozilla::moz_autoconfigure;
-use auto_outlook::outlk_autodiscover;
-use server_params::{expand_param_vector, ServerParams};
-
 macro_rules! progress {
     ($context:tt, $progress:expr, $comment:expr) => {
         assert!(

src/configure/auto_mozilla.rs

@@ -1,17 +1,16 @@
 //! # Thunderbird's Autoconfiguration implementation
 //!
 //! Documentation: <https://developer.mozilla.org/en-US/docs/Mozilla/Thunderbird/Autoconfiguration>
-use quick_xml::events::{BytesStart, Event};
-
 use std::io::BufRead;
 use std::str::FromStr;
 
-use crate::context::Context;
-use crate::login_param::LoginParam;
-use crate::provider::{Protocol, Socket};
+use quick_xml::events::{BytesStart, Event};
 
 use super::read_url::read_url;
 use super::{Error, ServerParams};
+use crate::context::Context;
+use crate::login_param::LoginParam;
+use crate::provider::{Protocol, Socket};
 
 #[derive(Debug)]
 struct Server {

src/configure/auto_outlook.rs

@@ -3,15 +3,14 @@
 //! This module implements autoconfiguration via POX (Plain Old XML) interface to Autodiscover
 //! Service. Newer SOAP interface, introduced in Exchange 2010, is not used.
 
-use quick_xml::events::Event;
-
 use std::io::BufRead;
 
-use crate::context::Context;
-use crate::provider::{Protocol, Socket};
+use quick_xml::events::Event;
 
 use super::read_url::read_url;
 use super::{Error, ServerParams};
+use crate::context::Context;
+use crate::provider::{Protocol, Socket};
 
 /// Result of parsing a single `Protocol` tag.
 ///

src/contact.rs

@@ -1656,7 +1656,6 @@ impl RecentlySeenLoop {
 #[cfg(test)]
 mod tests {
     use super::*;
-
     use crate::chat::{get_chat_contacts, send_text_msg, Chat};
     use crate::chatlist::Chatlist;
     use crate::receive_imf::receive_imf;

src/context.rs

@@ -861,8 +861,13 @@ pub fn get_version_str() -> &'static str {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use std::time::Duration;
 
+    use anyhow::Context as _;
+    use strum::IntoEnumIterator;
+    use tempfile::tempdir;
+
+    use super::*;
     use crate::chat::{
         get_chat_contacts, get_chat_msgs, send_msg, set_muted, Chat, ChatId, MuteDuration,
     };
@@ -873,10 +878,6 @@ mod tests {
     use crate::receive_imf::receive_imf;
     use crate::test_utils::TestContext;
     use crate::tools::create_outgoing_rfc724_mid;
-    use anyhow::Context as _;
-    use std::time::Duration;
-    use strum::IntoEnumIterator;
-    use tempfile::tempdir;
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_wrong_db() -> Result<()> {

src/decrypt.rs

@@ -344,11 +344,10 @@ pub(crate) async fn get_autocrypt_peerstate(
 
 #[cfg(test)]
 mod tests {
+    use super::*;
     use crate::receive_imf::receive_imf;
     use crate::test_utils::TestContext;
 
-    use super::*;
-
     #[test]
     fn test_has_decrypted_pgp_armor() {
         let data = b" -----BEGIN PGP MESSAGE-----";

src/download.rs

@@ -1,9 +1,11 @@
 //! # Download large messages manually.
 
+use std::cmp::max;
+use std::collections::BTreeMap;
+
 use anyhow::{anyhow, Result};
 use deltachat_derive::{FromSql, ToSql};
 use serde::{Deserialize, Serialize};
-use std::collections::BTreeMap;
 
 use crate::config::Config;
 use crate::context::Context;
@@ -14,7 +16,6 @@ use crate::mimeparser::{MimeMessage, Part};
 use crate::param::Params;
 use crate::tools::time;
 use crate::{job_try, stock_str, EventType};
-use std::cmp::max;
 
 /// Download limits should not be used below `MIN_DOWNLOAD_LIMIT`.
 ///
@@ -264,14 +265,13 @@ impl MimeMessage {
 mod tests {
     use num_traits::FromPrimitive;
 
+    use super::*;
     use crate::chat::{get_chat_msgs, send_msg};
     use crate::ephemeral::Timer;
     use crate::message::Viewtype;
     use crate::receive_imf::receive_imf_inner;
     use crate::test_utils::TestContext;
 
-    use super::*;
-
     #[test]
     fn test_downloadstate_values() {
         // values may be written to disk and must not change

src/e2ee.rs

@@ -144,13 +144,12 @@ pub async fn ensure_secret_key_exists(context: &Context) -> Result<String> {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
     use crate::chat;
     use crate::message::{Message, Viewtype};
     use crate::param::Param;
     use crate::test_utils::{bob_keypair, TestContext};
 
-    use super::*;
-
     mod ensure_secret_key_exists {
         use super::*;
 

src/ephemeral.rs

@@ -64,6 +64,7 @@
 
 #![allow(missing_docs)]
 
+use std::cmp::max;
 use std::convert::{TryFrom, TryInto};
 use std::num::ParseIntError;
 use std::str::FromStr;
@@ -86,7 +87,6 @@ use crate::mimeparser::SystemMessage;
 use crate::sql::{self, params_iter};
 use crate::stock_str;
 use crate::tools::{duration_to_str, time};
-use std::cmp::max;
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Serialize, Deserialize)]
 pub enum Timer {

src/html.rs

@@ -7,12 +7,14 @@
 //! `MsgId.get_html()` will return HTML -
 //! this allows nice quoting, handling linebreaks properly etc.
 
-use futures::future::FutureExt;
 use std::future::Future;
 use std::pin::Pin;
 
 use anyhow::{Context as _, Result};
+use futures::future::FutureExt;
 use lettre_email::mime::{self, Mime};
+use lettre_email::PartBuilder;
+use mailparse::ParsedContentType;
 
 use crate::headerdef::{HeaderDef, HeaderDefMap};
 use crate::message::{Message, MsgId};
@@ -20,8 +22,6 @@ use crate::mimeparser::parse_message_id;
 use crate::param::Param::SendHtml;
 use crate::plaintext::PlainText;
 use crate::{context::Context, message};
-use lettre_email::PartBuilder;
-use mailparse::ParsedContentType;
 
 impl Message {
     /// Check if the message can be retrieved as HTML.

src/http.rs

@@ -1,8 +1,9 @@
 //! # HTTP module.
 
-use anyhow::Result;
 use std::time::Duration;
 
+use anyhow::Result;
+
 const HTTP_TIMEOUT: Duration = Duration::from_secs(30);
 
 pub(crate) fn get_client() -> Result<reqwest::Client> {

src/imap/client.rs

@@ -4,21 +4,18 @@ use std::{
 };
 
 use anyhow::{Context as _, Result};
-
 use async_imap::Client as ImapClient;
 use async_imap::Session as ImapSession;
-
 use tokio::io::BufWriter;
 use tokio::net::ToSocketAddrs;
 
 use super::capabilities::Capabilities;
 use super::session::Session;
+use super::session::SessionStream;
 use crate::login_param::build_tls;
 use crate::net::connect_tcp;
 use crate::socks::Socks5Config;
 
-use super::session::SessionStream;
-
 /// IMAP write and read timeout in seconds.
 pub(crate) const IMAP_TIMEOUT: Duration = Duration::from_secs(30);
 

src/imap/idle.rs

@@ -1,12 +1,12 @@
-use super::Imap;
+use std::time::{Duration, SystemTime};
 
 use anyhow::{bail, Context as _, Result};
 use async_channel::Receiver;
 use async_imap::extensions::idle::IdleResponse;
 use futures_lite::FutureExt;
-use std::time::{Duration, SystemTime};
 
 use super::session::Session;
+use super::Imap;
 use crate::imap::client::IMAP_TIMEOUT;
 use crate::{context::Context, scheduler::InterruptInfo};
 

src/imap/scan_folders.rs

@@ -3,13 +3,12 @@ use std::{collections::BTreeMap, time::Instant};
 use anyhow::{Context as _, Result};
 use futures::stream::StreamExt;
 
+use super::{get_folder_meaning, get_folder_meaning_by_name};
 use crate::config::Config;
 use crate::imap::Imap;
 use crate::log::LogExt;
 use crate::{context::Context, imap::FolderMeaning};
 
-use super::{get_folder_meaning, get_folder_meaning_by_name};
-
 impl Imap {
     /// Returns true if folders were scanned, false if scanning was postponed.
     pub(crate) async fn scan_folders(&mut self, context: &Context) -> Result<bool> {

src/imap/select_folder.rs

@@ -1,8 +1,8 @@
-use super::session::Session as ImapSession;
-
-use crate::context::Context;
 use anyhow::Context as _;
 
+use super::session::Session as ImapSession;
+use crate::context::Context;
+
 type Result<T> = std::result::Result<T, Error>;
 
 #[derive(Debug, thiserror::Error)]

src/imex.rs

@@ -769,14 +769,13 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use ::pgp::armor::BlockType;
 
+    use super::*;
     use crate::pgp::{split_armored_data, HEADER_AUTOCRYPT, HEADER_SETUPCODE};
     use crate::stock_str::StockMessage;
     use crate::test_utils::{alice_keypair, TestContext};
 
-    use ::pgp::armor::BlockType;
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_render_setup_file() {
         let t = TestContext::new_alice().await;

src/job.rs

@@ -424,7 +424,6 @@ LIMIT 1;
 #[cfg(test)]
 mod tests {
     use super::*;
-
     use crate::test_utils::TestContext;
 
     async fn insert_job(context: &Context, foreign_id: i64, valid: bool) {

src/key.rs

@@ -11,6 +11,7 @@ use anyhow::{ensure, Context as _, Result};
 use futures::Future;
 use num_traits::FromPrimitive;
 use pgp::composed::Deserializable;
+pub use pgp::composed::{SignedPublicKey, SignedSecretKey};
 use pgp::ser::Serialize;
 use pgp::types::{KeyTrait, SecretKeyTrait};
 use tokio::runtime::Handle;
@@ -18,11 +19,9 @@ use tokio::runtime::Handle;
 use crate::config::Config;
 use crate::constants::KeyGenType;
 use crate::context::Context;
-use crate::tools::{time, EmailAddress};
-
 // Re-export key types
 pub use crate::pgp::KeyPair;
-pub use pgp::composed::{SignedPublicKey, SignedSecretKey};
+use crate::tools::{time, EmailAddress};
 
 /// Convenience trait for working with keys.
 ///
@@ -390,11 +389,12 @@ impl std::str::FromStr for Fingerprint {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::test_utils::{alice_keypair, TestContext};
+    use std::sync::Arc;
 
     use once_cell::sync::Lazy;
-    use std::sync::Arc;
+
+    use super::*;
+    use crate::test_utils::{alice_keypair, TestContext};
 
     static KEYPAIR: Lazy<KeyPair> = Lazy::new(alice_keypair);
 

src/log.rs

@@ -155,9 +155,10 @@ impl<T, E: std::fmt::Display> LogExt<T, E> for Result<T, E> {
 
 #[cfg(test)]
 mod tests {
-    use crate::test_utils::TestContext;
     use anyhow::Result;
 
+    use crate::test_utils::TestContext;
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_get_last_error() -> Result<()> {
         let t = TestContext::new().await;

src/login_param.rs

@@ -332,7 +332,6 @@ pub fn build_tls(strict_tls: bool) -> async_native_tls::TlsConnector {
 #[cfg(test)]
 mod tests {
     use super::*;
-
     use crate::test_utils::TestContext;
 
     #[test]

src/message.rs

@@ -1982,14 +1982,13 @@ impl Viewtype {
 mod tests {
     use num_traits::FromPrimitive;
 
+    use super::*;
     use crate::chat::{marknoticed_chat, ChatItem};
     use crate::chatlist::Chatlist;
     use crate::receive_imf::receive_imf;
     use crate::test_utils as test;
     use crate::test_utils::{TestContext, TestContextManager};
 
-    use super::*;
-
     #[test]
     fn test_guess_msgtype_from_suffix() {
         assert_eq!(

src/mimefactory.rs

@@ -1508,6 +1508,7 @@ fn maybe_encode_words(words: &str) -> String {
 mod tests {
     use mailparse::{addrparse_header, MailHeaderMap};
 
+    use super::*;
     use crate::chat::ChatId;
     use crate::chat::{
         self, add_contact_to_chat, create_group_chat, remove_contact_from_chat, send_text_msg,
@@ -1518,8 +1519,6 @@ mod tests {
     use crate::mimeparser::MimeMessage;
     use crate::receive_imf::receive_imf;
     use crate::test_utils::{get_chat_msg, TestContext};
-
-    use super::*;
     #[test]
     fn test_render_email_address() {
         let display_name = "ä space";

src/mimeparser.rs

@@ -1953,6 +1953,8 @@ where
 mod tests {
     #![allow(clippy::indexing_slicing)]
 
+    use mailparse::ParsedMail;
+
     use super::*;
     use crate::{
         chatlist::Chatlist,
@@ -1962,7 +1964,6 @@ mod tests {
         receive_imf::receive_imf,
         test_utils::TestContext,
     };
-    use mailparse::ParsedMail;
 
     impl AvatarAction {
         pub fn is_change(&self) -> bool {

src/oauth2.rs

@@ -352,7 +352,6 @@ fn normalize_addr(addr: &str) -> &str {
 #[cfg(test)]
 mod tests {
     use super::*;
-
     use crate::test_utils::TestContext;
 
     #[test]

src/param.rs

@@ -435,14 +435,13 @@ impl<'a> ParamsFile<'a> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-
     use std::path::Path;
     use std::str::FromStr;
 
     use anyhow::Result;
     use tokio::fs;
 
+    use super::*;
     use crate::test_utils::TestContext;
 
     #[test]

src/peerstate.rs

@@ -4,6 +4,9 @@
 
 use std::collections::HashSet;
 
+use anyhow::{Context as _, Error, Result};
+use num_traits::FromPrimitive;
+
 use crate::aheader::{Aheader, EncryptPreference};
 use crate::chat::{self, Chat};
 use crate::chatlist::Chatlist;
@@ -16,8 +19,6 @@ use crate::message::Message;
 use crate::mimeparser::SystemMessage;
 use crate::sql::Sql;
 use crate::stock_str;
-use anyhow::{Context as _, Error, Result};
-use num_traits::FromPrimitive;
 
 #[derive(Debug)]
 pub enum PeerstateKeyType {

src/pgp.rs

@@ -382,11 +382,12 @@ pub async fn symm_decrypt<T: std::io::Read + std::io::Seek>(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::test_utils::{alice_keypair, bob_keypair};
     use once_cell::sync::Lazy;
     use tokio::sync::OnceCell;
 
+    use super::*;
+    use crate::test_utils::{alice_keypair, bob_keypair};
+
     #[test]
     fn test_split_armored_data_1() {
         let (typ, _headers, base64) = split_armored_data(

src/plaintext.rs

@@ -2,9 +2,10 @@
 
 #![allow(missing_docs)]
 
-use crate::simplify::split_lines;
 use once_cell::sync::Lazy;
 
+use crate::simplify::split_lines;
+
 #[derive(Debug)]
 pub struct PlainText {
     pub text: String,

src/provider.rs

@@ -4,13 +4,14 @@
 
 mod data;
 
-use crate::config::Config;
-use crate::context::Context;
-use crate::provider::data::{PROVIDER_DATA, PROVIDER_IDS, PROVIDER_UPDATED};
 use anyhow::Result;
 use chrono::{NaiveDateTime, NaiveTime};
 use trust_dns_resolver::{config, AsyncResolver, TokioAsyncResolver};
 
+use crate::config::Config;
+use crate::context::Context;
+use crate::provider::data::{PROVIDER_DATA, PROVIDER_IDS, PROVIDER_UPDATED};
+
 #[derive(Debug, Display, Copy, Clone, PartialEq, Eq, FromPrimitive, ToPrimitive)]
 #[repr(u8)]
 pub enum Status {
@@ -195,10 +196,11 @@ pub fn get_provider_update_timestamp() -> i64 {
 mod tests {
     #![allow(clippy::indexing_slicing)]
 
+    use chrono::NaiveDate;
+
     use super::*;
     use crate::test_utils::TestContext;
     use crate::tools::time;
-    use chrono::NaiveDate;
 
     #[test]
     fn test_get_provider_by_domain_unexistant() {

src/provider/data.rs

@@ -1,12 +1,13 @@
 // file generated by src/provider/update.py
 
+use std::collections::HashMap;
+
+use once_cell::sync::Lazy;
+
 use crate::provider::Protocol::*;
 use crate::provider::Socket::*;
 use crate::provider::UsernamePattern::*;
 use crate::provider::{Config, ConfigDefault, Oauth2Authorizer, Provider, Server, Status};
-use std::collections::HashMap;
-
-use once_cell::sync::Lazy;
 
 // 163.md: 163.com
 static P_163: Lazy<Provider> = Lazy::new(|| Provider {

src/qr.rs

@@ -3,14 +3,15 @@
 #![allow(missing_docs)]
 
 mod dclogin_scheme;
-pub use dclogin_scheme::LoginOptions;
+use std::collections::BTreeMap;
 
 use anyhow::{anyhow, bail, ensure, Context as _, Error, Result};
+pub use dclogin_scheme::LoginOptions;
 use once_cell::sync::Lazy;
 use percent_encoding::percent_decode_str;
 use serde::Deserialize;
-use std::collections::BTreeMap;
 
+use self::dclogin_scheme::configure_from_login_qr;
 use crate::chat::{self, get_chat_id_by_grpid, ChatIdBlocked};
 use crate::config::Config;
 use crate::constants::Blocked;
@@ -24,8 +25,6 @@ use crate::peerstate::Peerstate;
 use crate::tools::time;
 use crate::{token, EventType};
 
-use self::dclogin_scheme::configure_from_login_qr;
-
 const OPENPGP4FPR_SCHEME: &str = "OPENPGP4FPR:"; // yes: uppercase
 const DCACCOUNT_SCHEME: &str = "DCACCOUNT:";
 pub(super) const DCLOGIN_SCHEME: &str = "DCLOGIN:";
@@ -642,14 +641,14 @@ fn normalize_address(addr: &str) -> Result<String, Error> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use anyhow::Result;
 
+    use super::*;
     use crate::aheader::EncryptPreference;
     use crate::chat::{create_group_chat, ProtectionStatus};
     use crate::key::DcKey;
     use crate::securejoin::get_securejoin_qr;
     use crate::test_utils::{alice_keypair, TestContext};
-    use anyhow::Result;
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_decode_http() -> Result<()> {

src/qr/dclogin_scheme.rs

@@ -1,13 +1,13 @@
 use std::collections::HashMap;
 
-use crate::config::Config;
-use crate::context::Context;
-use crate::provider::Socket;
-use crate::{contact, login_param::CertificateChecks};
 use anyhow::{bail, Context as _, Result};
 use num_traits::cast::ToPrimitive;
 
 use super::{Qr, DCLOGIN_SCHEME};
+use crate::config::Config;
+use crate::context::Context;
+use crate::provider::Socket;
+use crate::{contact, login_param::CertificateChecks};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum LoginOptions {
@@ -221,9 +221,10 @@ pub(crate) async fn configure_from_login_qr(
 
 #[cfg(test)]
 mod test {
+    use anyhow::{self, bail};
+
     use super::{decode_login, LoginOptions};
     use crate::{login_param::CertificateChecks, provider::Socket, qr::Qr};
-    use anyhow::{self, bail};
 
     macro_rules! login_options_just_pw {
         ($pw: expr) => {

src/quota.rs

@@ -2,9 +2,10 @@
 
 #![allow(missing_docs)]
 
+use std::collections::BTreeMap;
+
 use anyhow::{anyhow, Context as _, Result};
 use async_imap::types::{Quota, QuotaResource};
-use std::collections::BTreeMap;
 
 use crate::chat::add_device_msg_with_importance;
 use crate::config::Config;

src/reaction.rs

@@ -286,7 +286,6 @@ pub async fn get_msg_reactions(context: &Context, msg_id: MsgId) -> Result<React
 #[cfg(test)]
 mod tests {
     use super::*;
-
     use crate::chat::get_chat_msgs;
     use crate::config::Config;
     use crate::constants::DC_CHAT_ID_TRASH;

src/receive_imf/tests.rs

@@ -1,7 +1,6 @@
 use tokio::fs;
 
 use super::*;
-
 use crate::aheader::EncryptPreference;
 use crate::chat::get_chat_contacts;
 use crate::chat::{get_chat_msgs, ChatItem, ChatVisibility};

src/scheduler.rs

@@ -4,6 +4,7 @@ use futures::try_join;
 use futures_lite::FutureExt;
 use tokio::task;
 
+use self::connectivity::ConnectivityStore;
 use crate::config::Config;
 use crate::contact::{ContactId, RecentlySeenLoop};
 use crate::context::Context;
@@ -17,8 +18,6 @@ use crate::sql;
 use crate::tools::time;
 use crate::tools::{duration_to_str, maybe_add_time_based_warnings};
 
-use self::connectivity::ConnectivityStore;
-
 pub(crate) mod connectivity;
 
 /// Job and connection scheduler.

src/scheduler/connectivity.rs

@@ -3,6 +3,8 @@
 use core::fmt;
 use std::{ops::Deref, sync::Arc};
 
+use anyhow::{anyhow, Result};
+use humansize::{format_size, BINARY};
 use tokio::sync::{Mutex, RwLockReadGuard};
 
 use crate::events::EventType;
@@ -13,8 +15,6 @@ use crate::quota::{
 use crate::tools::time;
 use crate::{config::Config, scheduler::Scheduler, stock_str, tools};
 use crate::{context::Context, log::LogExt};
-use anyhow::{anyhow, Result};
-use humansize::{format_size, BINARY};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, EnumProperty, PartialOrd, Ord)]
 pub enum Connectivity {

src/securejoin.rs

@@ -30,10 +30,11 @@ mod bob;
 mod bobstate;
 mod qrinvite;
 
-use crate::token::Namespace;
 use bobstate::BobState;
 use qrinvite::QrInvite;
 
+use crate::token::Namespace;
+
 pub const NON_ALPHANUMERIC_WITHOUT_DOT: &AsciiSet = &NON_ALPHANUMERIC.remove(b'.');
 
 macro_rules! inviter_progress {
@@ -767,7 +768,6 @@ fn encrypted_and_signed(
 #[cfg(test)]
 mod tests {
     use super::*;
-
     use crate::chat;
     use crate::chat::ProtectionStatus;
     use crate::chatlist::Chatlist;

src/securejoin/bob.rs

@@ -5,6 +5,9 @@
 
 use anyhow::{Context as _, Result};
 
+use super::bobstate::{BobHandshakeStage, BobState};
+use super::qrinvite::QrInvite;
+use super::HandshakeMessage;
 use crate::chat::{is_contact_in_chat, ChatId, ProtectionStatus};
 use crate::constants::{Blocked, Chattype};
 use crate::contact::Contact;
@@ -14,10 +17,6 @@ use crate::mimeparser::MimeMessage;
 use crate::tools::time;
 use crate::{chat, stock_str};
 
-use super::bobstate::{BobHandshakeStage, BobState};
-use super::qrinvite::QrInvite;
-use super::HandshakeMessage;
-
 /// Starts the securejoin protocol with the QR `invite`.
 ///
 /// This will try to start the securejoin protocol for the given QR `invite`.  If it

src/securejoin/bobstate.rs

@@ -10,6 +10,8 @@
 use anyhow::{Error, Result};
 use rusqlite::Connection;
 
+use super::qrinvite::QrInvite;
+use super::{encrypted_and_signed, fingerprint_equals_sender, mark_peer_as_verified};
 use crate::chat::{self, ChatId};
 use crate::contact::{Contact, Origin};
 use crate::context::Context;
@@ -21,9 +23,6 @@ use crate::mimeparser::{MimeMessage, SystemMessage};
 use crate::param::Param;
 use crate::sql::Sql;
 
-use super::qrinvite::QrInvite;
-use super::{encrypted_and_signed, fingerprint_equals_sender, mark_peer_as_verified};
-
 /// The stage of the [`BobState`] securejoin handshake protocol state machine.
 ///
 /// This does not concern itself with user interactions, only represents what happened to

src/simplify.rs

@@ -285,9 +285,10 @@ fn is_plain_quote(buf: &str) -> bool {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use proptest::prelude::*;
 
+    use super::*;
+
     proptest! {
         #[test]
         // proptest does not support [[:graphical:][:space:]] regex.

src/smtp/send.rs

@@ -1,12 +1,13 @@
 //! # SMTP message sending
 
-use super::Smtp;
+use std::time::Duration;
+
 use async_smtp::{EmailAddress, Envelope, SendableEmail, Transport};
 
+use super::Smtp;
 use crate::config::Config;
 use crate::context::Context;
 use crate::events::EventType;
-use std::time::Duration;
 
 pub type Result<T> = std::result::Result<T, Error>;
 

src/socks.rs

@@ -4,17 +4,17 @@ use std::fmt;
 use std::pin::Pin;
 use std::time::Duration;
 
-use crate::net::connect_tcp;
 use anyhow::Result;
 pub use async_smtp::ServerAddress;
-use tokio::net::TcpStream;
-use tokio_io_timeout::TimeoutStream;
-
-use crate::context::Context;
 use fast_socks5::client::{Config, Socks5Stream};
 use fast_socks5::util::target_addr::ToTargetAddr;
 use fast_socks5::AuthenticationMethod;
 use fast_socks5::Socks5Command;
+use tokio::net::TcpStream;
+use tokio_io_timeout::TimeoutStream;
+
+use crate::context::Context;
+use crate::net::connect_tcp;
 
 #[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct Socks5Config {

src/sql.rs

@@ -874,11 +874,10 @@ pub fn repeat_vars(count: usize) -> String {
 mod tests {
     use async_channel as channel;
 
+    use super::*;
     use crate::config::Config;
     use crate::{test_utils::TestContext, EventType};
 
-    use super::*;
-
     #[test]
     fn test_maybe_add_file() {
         let mut files = Default::default();

src/stock_str.rs

@@ -6,6 +6,7 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use anyhow::{bail, Result};
+use humansize::{format_size, BINARY};
 use strum::EnumProperty as EnumPropertyTrait;
 use strum_macros::EnumProperty;
 use tokio::sync::RwLock;
@@ -19,7 +20,6 @@ use crate::context::Context;
 use crate::message::{Message, Viewtype};
 use crate::param::Param;
 use crate::tools::timestamp_to_str;
-use humansize::{format_size, BINARY};
 
 #[derive(Debug, Clone)]
 pub struct StockStrings {
@@ -1308,13 +1308,12 @@ impl Accounts {
 mod tests {
     use num_traits::ToPrimitive;
 
+    use super::*;
     use crate::chat::delete_and_reset_all_device_msgs;
     use crate::chat::Chat;
     use crate::chatlist::Chatlist;
     use crate::test_utils::TestContext;
 
-    use super::*;
-
     #[test]
     fn test_enum_mapping() {
         assert_eq!(StockMessage::NoMessages.to_usize().unwrap(), 1);

src/summary.rs

@@ -1,5 +1,8 @@
 //! # Message summary for chatlist.
 
+use std::borrow::Cow;
+use std::fmt;
+
 use crate::chat::Chat;
 use crate::constants::Chattype;
 use crate::contact::{Contact, ContactId};
@@ -9,8 +12,6 @@ use crate::mimeparser::SystemMessage;
 use crate::param::Param;
 use crate::stock_str;
 use crate::tools::truncate;
-use std::borrow::Cow;
-use std::fmt;
 
 /// Prefix displayed before message and separated by ":" in the chatlist.
 #[derive(Debug)]

src/sync.rs

@@ -1,5 +1,10 @@
 //! # Synchronize items between devices.
 
+use anyhow::Result;
+use lettre_email::mime::{self};
+use lettre_email::PartBuilder;
+use serde::{Deserialize, Serialize};
+
 use crate::chat::{Chat, ChatId};
 use crate::config::Config;
 use crate::constants::Blocked;
@@ -12,10 +17,6 @@ use crate::sync::SyncData::{AddQrToken, DeleteQrToken};
 use crate::token::Namespace;
 use crate::tools::time;
 use crate::{chat, stock_str, token};
-use anyhow::Result;
-use lettre_email::mime::{self};
-use lettre_email::PartBuilder;
-use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Serialize, Deserialize)]
 pub(crate) struct QrTokenData {
@@ -260,12 +261,13 @@ impl Context {
 
 #[cfg(test)]
 mod tests {
+    use anyhow::bail;
+
     use super::*;
     use crate::chat::Chat;
     use crate::chatlist::Chatlist;
     use crate::test_utils::TestContext;
     use crate::token::Namespace;
-    use anyhow::bail;
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_is_sync_sending_enabled() -> Result<()> {

src/tools.rs

@@ -9,7 +9,6 @@ use std::fmt;
 use std::io::Cursor;
 use std::path::{Path, PathBuf};
 use std::str::from_utf8;
-
 use std::time::{Duration, SystemTime};
 
 use anyhow::{bail, Error, Result};
@@ -703,7 +702,6 @@ mod tests {
     #![allow(clippy::indexing_slicing)]
 
     use super::*;
-
     use crate::{
         config::Config, message::get_msg_info, receive_imf::receive_imf, test_utils::TestContext,
     };
@@ -1008,11 +1006,12 @@ DKIM Results: Passed=true, Works=true, Allow_Keychange=true";
         assert_eq!(EmailAddress::new("@d.tt").is_ok(), false);
     }
 
-    use crate::chatlist::Chatlist;
-    use crate::{chat, test_utils};
     use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
     use proptest::prelude::*;
 
+    use crate::chatlist::Chatlist;
+    use crate::{chat, test_utils};
+
     proptest! {
         #[test]
         fn test_truncate(

src/update_helper.rs

@@ -1,10 +1,11 @@
 //! # Functions to update timestamps.
 
+use anyhow::Result;
+
 use crate::chat::{Chat, ChatId};
 use crate::contact::{Contact, ContactId};
 use crate::context::Context;
 use crate::param::{Param, Params};
-use anyhow::Result;
 
 impl Context {
     /// Updates a contact's timestamp, if reasonable.

src/webxdc.rs

@@ -770,6 +770,7 @@ impl Message {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
     use crate::chat::{
         add_contact_to_chat, create_broadcast_list, create_group_chat, forward_msgs,
         remove_contact_from_chat, resend_msgs, send_msg, send_text_msg, ChatId, ProtectionStatus,
@@ -781,8 +782,6 @@ mod tests {
     use crate::receive_imf::{receive_imf, receive_imf_inner};
     use crate::test_utils::TestContext;
 
-    use super::*;
-
     #[allow(clippy::assertions_on_constants)]
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_webxdc_file_limits() -> Result<()> {