diff --git a/Cargo.toml b/Cargo.toml
index 2a55524..b110a6a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -58,7 +58,7 @@ aws-sdk-s3 = "1.9.0"
 eml-codec = { git = "https://git.deuxfleurs.fr/Deuxfleurs/eml-codec.git", branch = "main" }
 smtp-message = { git = "http://github.com/Alexis211/kannader", branch = "feature/lmtp" }
 smtp-server = { git = "http://github.com/Alexis211/kannader", branch = "feature/lmtp" }
-imap-codec = { version = "1.0.0", features = ["quirk_crlf_relaxed", "bounded-static"] }
+imap-codec = { version = "1.0.0", features = ["quirk_crlf_relaxed", "bounded-static", "ext_condstore_qresync"] }
 imap-flow = { git = "https://github.com/duesee/imap-flow.git", rev = "e45ce7bb6ab6bda3c71a0c7b05e9b558a5902e90" }
 
 [dev-dependencies]
@@ -68,6 +68,6 @@ imap-types = { git = "https://github.com/duesee/imap-codec", branch = "v2" }
 imap-codec = { git = "https://github.com/duesee/imap-codec", branch = "v2" }
 
 [[test]]
-name = "imap_features"
-path = "tests/imap_features.rs"
+name = "behavior"
+path = "tests/behavior.rs"
 harness = false
diff --git a/src/imap/capability.rs b/src/imap/capability.rs
new file mode 100644
index 0000000..631c3e2
--- /dev/null
+++ b/src/imap/capability.rs
@@ -0,0 +1,93 @@
+use imap_codec::imap_types::core::NonEmptyVec;
+use imap_codec::imap_types::extensions::enable::{CapabilityEnable, Utf8Kind};
+use imap_codec::imap_types::response::Capability;
+use std::collections::HashSet;
+
+fn capability_unselect() -> Capability<'static> {
+    Capability::try_from("UNSELECT").unwrap()
+}
+
+fn capability_condstore() -> Capability<'static> {
+    Capability::try_from("CONDSTORE").unwrap()
+}
+
+fn capability_qresync() -> Capability<'static> {
+    Capability::try_from("QRESYNC").unwrap()
+}
+
+#[derive(Debug, Clone)]
+pub struct ServerCapability(HashSet<Capability<'static>>);
+
+impl Default for ServerCapability {
+    fn default() -> Self {
+        Self(HashSet::from([
+            Capability::Imap4Rev1,
+            Capability::Move,
+            Capability::LiteralPlus,
+            capability_unselect(),
+            //capability_condstore(),
+            //capability_qresync(),
+        ]))
+    }
+}
+
+impl ServerCapability {
+    pub fn to_vec(&self) -> NonEmptyVec<Capability<'static>> {
+        self.0
+            .iter()
+            .map(|v| v.clone())
+            .collect::<Vec<_>>()
+            .try_into()
+            .unwrap()
+    }
+
+    #[allow(dead_code)]
+    pub fn support(&self, cap: &Capability<'static>) -> bool {
+        self.0.contains(cap)
+    }
+}
+
+enum ClientStatus {
+    NotSupportedByServer,
+    Disabled,
+    Enabled,
+}
+
+pub struct ClientCapability {
+    condstore: ClientStatus,
+    utf8kind: Option<Utf8Kind>,
+}
+
+impl ClientCapability {
+    pub fn new(sc: &ServerCapability) -> Self {
+        Self {
+            condstore: match sc.0.contains(&capability_condstore()) {
+                true => ClientStatus::Disabled,
+                _ => ClientStatus::NotSupportedByServer,
+            },
+            utf8kind: None,
+        }
+    }
+
+    pub fn try_enable(
+        &mut self,
+        caps: &[CapabilityEnable<'static>],
+    ) -> Vec<CapabilityEnable<'static>> {
+        let mut enabled = vec![];
+        for cap in caps {
+            match cap {
+                CapabilityEnable::CondStore if matches!(self.condstore, ClientStatus::Disabled) => {
+                    self.condstore = ClientStatus::Enabled;
+                    enabled.push(cap.clone());
+                }
+                CapabilityEnable::Utf8(kind) if Some(kind) != self.utf8kind.as_ref() => {
+                    self.utf8kind = Some(kind.clone());
+                    enabled.push(cap.clone());
+                }
+                _ => (),
+            }
+        }
+
+        enabled
+    }
+}
diff --git a/src/imap/command/anonymous.rs b/src/imap/command/anonymous.rs
index fbd10e9..0582b06 100644
--- a/src/imap/command/anonymous.rs
+++ b/src/imap/command/anonymous.rs
@@ -1,8 +1,10 @@
 use anyhow::Result;
 use imap_codec::imap_types::command::{Command, CommandBody};
 use imap_codec::imap_types::core::AString;
+use imap_codec::imap_types::response::Code;
 use imap_codec::imap_types::secret::Secret;
 
+use crate::imap::capability::ServerCapability;
 use crate::imap::command::anystate;
 use crate::imap::flow;
 use crate::imap::response::Response;
@@ -13,6 +15,7 @@ use crate::mail::user::User;
 
 pub struct AnonymousContext<'a> {
     pub req: &'a Command<'static>,
+    pub server_capabilities: &'a ServerCapability,
     pub login_provider: &'a ArcLoginProvider,
 }
 
@@ -20,7 +23,9 @@ pub async fn dispatch(ctx: AnonymousContext<'_>) -> Result<(Response<'static>, f
     match &ctx.req.body {
         // Any State
         CommandBody::Noop => anystate::noop_nothing(ctx.req.tag.clone()),
-        CommandBody::Capability => anystate::capability(ctx.req.tag.clone()),
+        CommandBody::Capability => {
+            anystate::capability(ctx.req.tag.clone(), ctx.server_capabilities)
+        }
         CommandBody::Logout => anystate::logout(),
 
         // Specific to anonymous context (3 commands)
@@ -69,6 +74,7 @@ impl<'a> AnonymousContext<'a> {
         Ok((
             Response::build()
                 .to_req(self.req)
+                .code(Code::Capability(self.server_capabilities.to_vec()))
                 .message("Completed")
                 .ok()?,
             flow::Transition::Authenticate(user),
diff --git a/src/imap/command/anystate.rs b/src/imap/command/anystate.rs
index 42fe645..718ba3f 100644
--- a/src/imap/command/anystate.rs
+++ b/src/imap/command/anystate.rs
@@ -1,17 +1,19 @@
 use anyhow::Result;
-use imap_codec::imap_types::core::{NonEmptyVec, Tag};
-use imap_codec::imap_types::response::{Capability, Data};
+use imap_codec::imap_types::core::Tag;
+use imap_codec::imap_types::response::Data;
 
+use crate::imap::capability::ServerCapability;
 use crate::imap::flow;
 use crate::imap::response::Response;
 
-pub(crate) fn capability(tag: Tag<'static>) -> Result<(Response<'static>, flow::Transition)> {
-    let capabilities: NonEmptyVec<Capability> =
-        (vec![Capability::Imap4Rev1, Capability::Idle]).try_into()?;
+pub(crate) fn capability(
+    tag: Tag<'static>,
+    cap: &ServerCapability,
+) -> Result<(Response<'static>, flow::Transition)> {
     let res = Response::build()
         .tag(tag)
         .message("Server capabilities")
-        .data(Data::Capability(capabilities))
+        .data(Data::Capability(cap.to_vec()))
         .ok()?;
 
     Ok((res, flow::Transition::None))
diff --git a/src/imap/command/authenticated.rs b/src/imap/command/authenticated.rs
index 1bb4c6d..1481a80 100644
--- a/src/imap/command/authenticated.rs
+++ b/src/imap/command/authenticated.rs
@@ -3,13 +3,15 @@ use std::sync::Arc;
 
 use anyhow::{anyhow, bail, Result};
 use imap_codec::imap_types::command::{Command, CommandBody};
-use imap_codec::imap_types::core::{Atom, Literal, QuotedChar};
+use imap_codec::imap_types::core::{Atom, Literal, NonEmptyVec, QuotedChar};
 use imap_codec::imap_types::datetime::DateTime;
+use imap_codec::imap_types::extensions::enable::CapabilityEnable;
 use imap_codec::imap_types::flag::{Flag, FlagNameAttribute};
 use imap_codec::imap_types::mailbox::{ListMailbox, Mailbox as MailboxCodec};
 use imap_codec::imap_types::response::{Code, CodeOther, Data};
 use imap_codec::imap_types::status::{StatusDataItem, StatusDataItemName};
 
+use crate::imap::capability::{ClientCapability, ServerCapability};
 use crate::imap::command::{anystate, MailboxName};
 use crate::imap::flow;
 use crate::imap::mailbox_view::MailboxView;
@@ -22,6 +24,8 @@ use crate::mail::IMF;
 
 pub struct AuthenticatedContext<'a> {
     pub req: &'a Command<'static>,
+    pub server_capabilities: &'a ServerCapability,
+    pub client_capabilities: &'a mut ClientCapability,
     pub user: &'a Arc<User>,
 }
 
@@ -31,7 +35,9 @@ pub async fn dispatch<'a>(
     match &ctx.req.body {
         // Any state
         CommandBody::Noop => anystate::noop_nothing(ctx.req.tag.clone()),
-        CommandBody::Capability => anystate::capability(ctx.req.tag.clone()),
+        CommandBody::Capability => {
+            anystate::capability(ctx.req.tag.clone(), ctx.server_capabilities)
+        }
         CommandBody::Logout => anystate::logout(),
 
         // Specific to this state (11 commands)
@@ -61,6 +67,9 @@ pub async fn dispatch<'a>(
             message,
         } => ctx.append(mailbox, flags, date, message).await,
 
+        // rfc5161 ENABLE
+        CommandBody::Enable { capabilities } => ctx.enable(capabilities),
+
         // Collect other commands
         _ => anystate::wrong_state(ctx.req.tag.clone()),
     }
@@ -301,6 +310,9 @@ impl<'a> AuthenticatedContext<'a> {
                 StatusDataItemName::DeletedStorage => {
                     bail!("quota not implemented, can't return freed storage after EXPUNGE will be run");
                 },
+                StatusDataItemName::HighestModSeq => {
+                    bail!("highestmodseq not yet implemented");
+                }
             });
         }
 
@@ -504,6 +516,21 @@ impl<'a> AuthenticatedContext<'a> {
         }
     }
 
+    fn enable(
+        self,
+        cap_enable: &NonEmptyVec<CapabilityEnable<'static>>,
+    ) -> Result<(Response<'static>, flow::Transition)> {
+        let mut response_builder = Response::build().to_req(self.req);
+        let capabilities = self.client_capabilities.try_enable(cap_enable.as_ref());
+        if capabilities.len() > 0 {
+            response_builder = response_builder.data(Data::Enabled { capabilities });
+        }
+        Ok((
+            response_builder.message("ENABLE completed").ok()?,
+            flow::Transition::None,
+        ))
+    }
+
     pub(crate) async fn append_internal(
         self,
         mailbox: &MailboxCodec<'a>,
@@ -520,7 +547,7 @@ impl<'a> AuthenticatedContext<'a> {
         };
 
         if date.is_some() {
-            bail!("Cannot set date when appending message");
+            tracing::warn!("Cannot set date when appending message");
         }
 
         let msg =
diff --git a/src/imap/command/examined.rs b/src/imap/command/examined.rs
index 7de94f4..0d688c0 100644
--- a/src/imap/command/examined.rs
+++ b/src/imap/command/examined.rs
@@ -7,6 +7,7 @@ use imap_codec::imap_types::fetch::MacroOrMessageDataItemNames;
 use imap_codec::imap_types::search::SearchKey;
 use imap_codec::imap_types::sequence::SequenceSet;
 
+use crate::imap::capability::{ClientCapability, ServerCapability};
 use crate::imap::command::{anystate, authenticated};
 use crate::imap::flow;
 use crate::imap::mailbox_view::MailboxView;
@@ -17,18 +18,22 @@ pub struct ExaminedContext<'a> {
     pub req: &'a Command<'static>,
     pub user: &'a Arc<User>,
     pub mailbox: &'a mut MailboxView,
+    pub server_capabilities: &'a ServerCapability,
+    pub client_capabilities: &'a mut ClientCapability,
 }
 
 pub async fn dispatch(ctx: ExaminedContext<'_>) -> Result<(Response<'static>, flow::Transition)> {
     match &ctx.req.body {
         // Any State
         // noop is specific to this state
-        CommandBody::Capability => anystate::capability(ctx.req.tag.clone()),
+        CommandBody::Capability => {
+            anystate::capability(ctx.req.tag.clone(), ctx.server_capabilities)
+        }
         CommandBody::Logout => anystate::logout(),
 
         // Specific to the EXAMINE state (specialization of the SELECTED state)
         // ~3 commands -> close, fetch, search + NOOP
-        CommandBody::Close => ctx.close().await,
+        CommandBody::Close => ctx.close("CLOSE").await,
         CommandBody::Fetch {
             sequence_set,
             macro_or_item_names,
@@ -44,14 +49,19 @@ pub async fn dispatch(ctx: ExaminedContext<'_>) -> Result<(Response<'static>, fl
             Response::build()
                 .to_req(ctx.req)
                 .message("Forbidden command: can't write in read-only mode (EXAMINE)")
-                .bad()?,
+                .no()?,
             flow::Transition::None,
         )),
 
+        // UNSELECT extension (rfc3691)
+        CommandBody::Unselect => ctx.close("UNSELECT").await,
+
         // In examined mode, we fallback to authenticated when needed
         _ => {
             authenticated::dispatch(authenticated::AuthenticatedContext {
                 req: ctx.req,
+                server_capabilities: ctx.server_capabilities,
+                client_capabilities: ctx.client_capabilities,
                 user: ctx.user,
             })
             .await
@@ -64,11 +74,11 @@ pub async fn dispatch(ctx: ExaminedContext<'_>) -> Result<(Response<'static>, fl
 impl<'a> ExaminedContext<'a> {
     /// CLOSE in examined state is not the same as in selected state
     /// (in selected state it also does an EXPUNGE, here it doesn't)
-    async fn close(self) -> Result<(Response<'static>, flow::Transition)> {
+    async fn close(self, kind: &str) -> Result<(Response<'static>, flow::Transition)> {
         Ok((
             Response::build()
                 .to_req(self.req)
-                .message("CLOSE completed")
+                .message(format!("{} completed", kind))
                 .ok()?,
             flow::Transition::Unselect,
         ))
diff --git a/src/imap/command/selected.rs b/src/imap/command/selected.rs
index 220a952..c8cc680 100644
--- a/src/imap/command/selected.rs
+++ b/src/imap/command/selected.rs
@@ -10,6 +10,7 @@ use imap_codec::imap_types::response::{Code, CodeOther};
 use imap_codec::imap_types::search::SearchKey;
 use imap_codec::imap_types::sequence::SequenceSet;
 
+use crate::imap::capability::{ClientCapability, ServerCapability};
 use crate::imap::command::{anystate, authenticated, MailboxName};
 use crate::imap::flow;
 use crate::imap::mailbox_view::MailboxView;
@@ -21,6 +22,8 @@ pub struct SelectedContext<'a> {
     pub req: &'a Command<'static>,
     pub user: &'a Arc<User>,
     pub mailbox: &'a mut MailboxView,
+    pub server_capabilities: &'a ServerCapability,
+    pub client_capabilities: &'a mut ClientCapability,
 }
 
 pub async fn dispatch<'a>(
@@ -29,7 +32,9 @@ pub async fn dispatch<'a>(
     match &ctx.req.body {
         // Any State
         // noop is specific to this state
-        CommandBody::Capability => anystate::capability(ctx.req.tag.clone()),
+        CommandBody::Capability => {
+            anystate::capability(ctx.req.tag.clone(), ctx.server_capabilities)
+        }
         CommandBody::Logout => anystate::logout(),
 
         // Specific to this state (7 commands + NOOP)
@@ -58,11 +63,21 @@ pub async fn dispatch<'a>(
             mailbox,
             uid,
         } => ctx.copy(sequence_set, mailbox, uid).await,
+        CommandBody::Move {
+            sequence_set,
+            mailbox,
+            uid,
+        } => ctx.r#move(sequence_set, mailbox, uid).await,
+
+        // UNSELECT extension (rfc3691)
+        CommandBody::Unselect => ctx.unselect().await,
 
         // In selected mode, we fallback to authenticated when needed
         _ => {
             authenticated::dispatch(authenticated::AuthenticatedContext {
                 req: ctx.req,
+                server_capabilities: ctx.server_capabilities,
+                client_capabilities: ctx.client_capabilities,
                 user: ctx.user,
             })
             .await
@@ -84,6 +99,16 @@ impl<'a> SelectedContext<'a> {
         ))
     }
 
+    async fn unselect(self) -> Result<(Response<'static>, flow::Transition)> {
+        Ok((
+            Response::build()
+                .to_req(self.req)
+                .message("UNSELECT completed")
+                .ok()?,
+            flow::Transition::Unselect,
+        ))
+    }
+
     pub async fn fetch(
         self,
         sequence_set: &SequenceSet,
@@ -226,4 +251,58 @@ impl<'a> SelectedContext<'a> {
             flow::Transition::None,
         ))
     }
+
+    async fn r#move(
+        self,
+        sequence_set: &SequenceSet,
+        mailbox: &MailboxCodec<'a>,
+        uid: &bool,
+    ) -> Result<(Response<'static>, flow::Transition)> {
+        let name: &str = MailboxName(mailbox).try_into()?;
+
+        let mb_opt = self.user.open_mailbox(&name).await?;
+        let mb = match mb_opt {
+            Some(mb) => mb,
+            None => {
+                return Ok((
+                    Response::build()
+                        .to_req(self.req)
+                        .message("Destination mailbox does not exist")
+                        .code(Code::TryCreate)
+                        .no()?,
+                    flow::Transition::None,
+                ))
+            }
+        };
+
+        let (uidval, uid_map, data) = self.mailbox.r#move(sequence_set, mb, uid).await?;
+
+        // compute code
+        let copyuid_str = format!(
+            "{} {} {}",
+            uidval,
+            uid_map
+                .iter()
+                .map(|(sid, _)| format!("{}", sid))
+                .collect::<Vec<_>>()
+                .join(","),
+            uid_map
+                .iter()
+                .map(|(_, tuid)| format!("{}", tuid))
+                .collect::<Vec<_>>()
+                .join(",")
+        );
+
+        Ok((
+            Response::build()
+                .to_req(self.req)
+                .message("COPY completed")
+                .code(Code::Other(CodeOther::unvalidated(
+                    format!("COPYUID {}", copyuid_str).into_bytes(),
+                )))
+                .set_body(data)
+                .ok()?,
+            flow::Transition::None,
+        ))
+    }
 }
diff --git a/src/imap/mailbox_view.rs b/src/imap/mailbox_view.rs
index 7434512..861d27c 100644
--- a/src/imap/mailbox_view.rs
+++ b/src/imap/mailbox_view.rs
@@ -600,6 +600,37 @@ impl MailboxView {
         Ok((to_state.uidvalidity, ret))
     }
 
+    pub async fn r#move(
+        &mut self,
+        sequence_set: &SequenceSet,
+        to: Arc<Mailbox>,
+        is_uid_copy: &bool,
+    ) -> Result<(ImapUidvalidity, Vec<(ImapUid, ImapUid)>, Vec<Body<'static>>)> {
+        let mails = self.get_mail_ids(sequence_set, *is_uid_copy)?;
+
+        let mut new_uuids = vec![];
+        for mi in mails.iter() {
+            let copy_action = to.copy_from(&self.mailbox, mi.uuid).await?;
+            new_uuids.push(copy_action);
+            self.mailbox.delete(mi.uuid).await?
+        }
+
+        let mut ret = vec![];
+        let to_state = to.current_uid_index().await;
+        for (mi, new_uuid) in mails.iter().zip(new_uuids.iter()) {
+            let dest_uid = to_state
+                .table
+                .get(new_uuid)
+                .ok_or(anyhow!("moved mail not in destination mailbox"))?
+                .0;
+            ret.push((mi.uid, dest_uid));
+        }
+
+        let update = self.update().await?;
+
+        Ok((to_state.uidvalidity, ret, update))
+    }
+
     /// Looks up state changes in the mailbox and produces a set of IMAP
     /// responses describing the new state.
     pub async fn fetch<'b>(
@@ -1242,7 +1273,11 @@ fn get_message_section<'a>(
                 part.as_ref().map(|p| p.0.as_ref()).unwrap_or(&[]),
                 |part_msg| {
                     let mut ret = vec![];
-                    for f in &part_msg.mime().kv {
+                    let mime = match &part_msg {
+                        AnyPart::Msg(msg) => msg.child.mime(),
+                        other => other.mime(),
+                    };
+                    for f in mime.kv.iter() {
                         let (k, v) = match f {
                             header::Field::Good(header::Kv2(k, v)) => (k, v),
                             _ => continue,
@@ -1272,7 +1307,7 @@ fn get_message_section<'a>(
             let bytes = match &part {
                 AnyPart::Txt(p) => p.mime.fields.raw,
                 AnyPart::Bin(p) => p.mime.fields.raw,
-                AnyPart::Msg(p) => p.mime.fields.raw,
+                AnyPart::Msg(p) => p.child.mime().raw,
                 AnyPart::Mult(p) => p.mime.fields.raw,
             };
             Ok(bytes.to_vec().into())
diff --git a/src/imap/mod.rs b/src/imap/mod.rs
index 31eeaa8..aac1fd3 100644
--- a/src/imap/mod.rs
+++ b/src/imap/mod.rs
@@ -1,3 +1,4 @@
+mod capability;
 mod command;
 mod flow;
 mod mailbox_view;
@@ -17,12 +18,14 @@ use imap_flow::server::{ServerFlow, ServerFlowEvent, ServerFlowOptions};
 use imap_flow::stream::AnyStream;
 
 use crate::config::ImapConfig;
+use crate::imap::capability::ServerCapability;
 use crate::login::ArcLoginProvider;
 
 /// Server is a thin wrapper to register our Services in BàL
 pub struct Server {
     bind_addr: SocketAddr,
     login_provider: ArcLoginProvider,
+    capabilities: ServerCapability,
 }
 
 struct ClientContext {
@@ -30,12 +33,14 @@ struct ClientContext {
     addr: SocketAddr,
     login_provider: ArcLoginProvider,
     must_exit: watch::Receiver<bool>,
+    server_capabilities: ServerCapability,
 }
 
 pub fn new(config: ImapConfig, login: ArcLoginProvider) -> Server {
     Server {
         bind_addr: config.bind_addr,
         login_provider: login,
+        capabilities: ServerCapability::default(),
     }
 }
 
@@ -66,6 +71,7 @@ impl Server {
                 addr: remote_addr.clone(),
                 login_provider: self.login_provider.clone(),
                 must_exit: must_exit.clone(),
+                server_capabilities: self.capabilities.clone(),
             };
             let conn = tokio::spawn(client_wrapper(client));
             connections.push(conn);
@@ -83,7 +89,7 @@ async fn client_wrapper(ctx: ClientContext) {
     let addr = ctx.addr.clone();
     match client(ctx).await {
         Ok(()) => {
-            tracing::info!("closing successful session for {:?}", addr);
+            tracing::debug!("closing successful session for {:?}", addr);
         }
         Err(e) => {
             tracing::error!("closing errored session for {:?}: {}", addr, e);
@@ -96,28 +102,34 @@ async fn client(mut ctx: ClientContext) -> Result<()> {
     let (mut server, _) = ServerFlow::send_greeting(
         ctx.stream,
         ServerFlowOptions::default(),
-        Greeting::ok(None, "Aerogramme").unwrap(),
+        Greeting::ok(
+            Some(Code::Capability(ctx.server_capabilities.to_vec())),
+            "Aerogramme",
+        )
+        .unwrap(),
     )
     .await?;
 
     use crate::imap::response::{Body, Response as MyResponse};
     use crate::imap::session::Instance;
     use imap_codec::imap_types::command::Command;
-    use imap_codec::imap_types::response::{Response, Status};
+    use imap_codec::imap_types::response::{Code, Response, Status};
 
     use tokio::sync::mpsc;
     let (cmd_tx, mut cmd_rx) = mpsc::channel::<Command<'static>>(10);
     let (resp_tx, mut resp_rx) = mpsc::unbounded_channel::<MyResponse<'static>>();
 
     let bckgrnd = tokio::spawn(async move {
-        let mut session = Instance::new(ctx.login_provider);
+        let mut session = Instance::new(ctx.login_provider, ctx.server_capabilities);
         loop {
             let cmd = match cmd_rx.recv().await {
                 None => break,
                 Some(cmd_recv) => cmd_recv,
             };
 
+            tracing::debug!(cmd=?cmd, sock=%ctx.addr, "command");
             let maybe_response = session.command(cmd).await;
+            tracing::debug!(cmd=?maybe_response.completion, sock=%ctx.addr, "response");
 
             match resp_tx.send(maybe_response) {
                 Err(_) => break,
diff --git a/src/imap/session.rs b/src/imap/session.rs
index 5c67f8e..6b26478 100644
--- a/src/imap/session.rs
+++ b/src/imap/session.rs
@@ -1,3 +1,4 @@
+use crate::imap::capability::{ClientCapability, ServerCapability};
 use crate::imap::command::{anonymous, authenticated, examined, selected};
 use crate::imap::flow;
 use crate::imap::response::Response;
@@ -7,13 +8,18 @@ use imap_codec::imap_types::command::Command;
 //-----
 pub struct Instance {
     pub login_provider: ArcLoginProvider,
+    pub server_capabilities: ServerCapability,
+    pub client_capabilities: ClientCapability,
     pub state: flow::State,
 }
 impl Instance {
-    pub fn new(login_provider: ArcLoginProvider) -> Self {
+    pub fn new(login_provider: ArcLoginProvider, cap: ServerCapability) -> Self {
+        let client_cap = ClientCapability::new(&cap);
         Self {
             login_provider,
             state: flow::State::NotAuthenticated,
+            server_capabilities: cap,
+            client_capabilities: client_cap,
         }
     }
 
@@ -25,16 +31,24 @@ impl Instance {
                 let ctx = anonymous::AnonymousContext {
                     req: &cmd,
                     login_provider: &self.login_provider,
+                    server_capabilities: &self.server_capabilities,
                 };
                 anonymous::dispatch(ctx).await
             }
             flow::State::Authenticated(ref user) => {
-                let ctx = authenticated::AuthenticatedContext { req: &cmd, user };
+                let ctx = authenticated::AuthenticatedContext {
+                    req: &cmd,
+                    server_capabilities: &self.server_capabilities,
+                    client_capabilities: &mut self.client_capabilities,
+                    user,
+                };
                 authenticated::dispatch(ctx).await
             }
             flow::State::Selected(ref user, ref mut mailbox) => {
                 let ctx = selected::SelectedContext {
                     req: &cmd,
+                    server_capabilities: &self.server_capabilities,
+                    client_capabilities: &mut self.client_capabilities,
                     user,
                     mailbox,
                 };
@@ -43,6 +57,8 @@ impl Instance {
             flow::State::Examined(ref user, ref mut mailbox) => {
                 let ctx = examined::ExaminedContext {
                     req: &cmd,
+                    server_capabilities: &self.server_capabilities,
+                    client_capabilities: &mut self.client_capabilities,
                     user,
                     mailbox,
                 };
diff --git a/src/mail/incoming.rs b/src/mail/incoming.rs
index 04d2ef1..781d8dc 100644
--- a/src/mail/incoming.rs
+++ b/src/mail/incoming.rs
@@ -9,7 +9,7 @@ use base64::Engine;
 use futures::{future::BoxFuture, FutureExt};
 //use tokio::io::AsyncReadExt;
 use tokio::sync::watch;
-use tracing::{error, info, warn};
+use tracing::{debug, error, info, warn};
 
 use crate::cryptoblob;
 use crate::login::{Credentials, PublicCredentials};
@@ -62,7 +62,7 @@ async fn incoming_mail_watch_process_internal(
 
     loop {
         let maybe_updated_incoming_key = if *lock_held.borrow() {
-            info!("incoming lock held");
+            debug!("incoming lock held");
 
             let wait_new_mail = async {
                 loop {
@@ -83,7 +83,7 @@ async fn incoming_mail_watch_process_internal(
                 _     = rx_inbox_id.changed() => None,
             }
         } else {
-            info!("incoming lock not held");
+            debug!("incoming lock not held");
             tokio::select! {
                 _ = lock_held.changed() => None,
                 _ = rx_inbox_id.changed() => None,
@@ -93,11 +93,11 @@ async fn incoming_mail_watch_process_internal(
         let user = match Weak::upgrade(&user) {
             Some(user) => user,
             None => {
-                info!("User no longer available, exiting incoming loop.");
+                debug!("User no longer available, exiting incoming loop.");
                 break;
             }
         };
-        info!("User still available");
+        debug!("User still available");
 
         // If INBOX no longer is same mailbox, open new mailbox
         let inbox_id = *rx_inbox_id.borrow();
@@ -235,7 +235,7 @@ async fn k2v_lock_loop_internal(
     let watch_lock_loop: BoxFuture<Result<()>> = async {
         let mut ct = row_ref.clone();
         loop {
-            info!("k2v watch lock loop iter: ct = {:?}", ct);
+            debug!("k2v watch lock loop iter: ct = {:?}", ct);
             match storage.row_poll(&ct).await {
                 Err(e) => {
                     error!(
@@ -263,7 +263,7 @@ async fn k2v_lock_loop_internal(
                     }
                     let new_ct = cv.row_ref;
 
-                    info!(
+                    debug!(
                         "k2v watch lock loop: changed, old ct = {:?}, new ct = {:?}, v = {:?}",
                         ct, new_ct, lock_state
                     );
@@ -378,7 +378,7 @@ async fn k2v_lock_loop_internal(
 
     let _ = futures::try_join!(watch_lock_loop, lock_notify_loop, take_lock_loop);
 
-    info!("lock loop exited, releasing");
+    debug!("lock loop exited, releasing");
 
     if !held_tx.is_closed() {
         warn!("weird...");
diff --git a/tests/behavior.rs b/tests/behavior.rs
new file mode 100644
index 0000000..82fdc53
--- /dev/null
+++ b/tests/behavior.rs
@@ -0,0 +1,120 @@
+use anyhow::Context;
+
+mod common;
+use crate::common::fragments::*;
+
+fn main() {
+    rfc3501_imap4rev1_base();
+    rfc3691_imapext_unselect();
+    rfc5161_imapext_enable();
+    rfc6851_imapext_move();
+    rfc7888_imapext_literal();
+}
+
+fn rfc3501_imap4rev1_base() {
+    println!("rfc3501_imap4rev1_base");
+    common::aerogramme_provider_daemon_dev(|imap_socket, lmtp_socket| {
+        connect(imap_socket).context("server says hello")?;
+        capability(imap_socket, Extension::None).context("check server capabilities")?;
+        login(imap_socket, Account::Alice).context("login test")?;
+        create_mailbox(imap_socket, Mailbox::Archive).context("created mailbox archive")?;
+        // UNSUBSCRIBE IS NOT IMPLEMENTED YET
+        //unsubscribe_mailbox(imap_socket).context("unsubscribe from archive")?;
+        select(imap_socket, Mailbox::Inbox, None).context("select inbox")?;
+        check(imap_socket).context("check must run")?;
+        status_mailbox(imap_socket, Mailbox::Archive).context("status of archive from inbox")?;
+        lmtp_handshake(lmtp_socket).context("handshake lmtp done")?;
+        lmtp_deliver_email(lmtp_socket, Email::Multipart).context("mail delivered successfully")?;
+        noop_exists(imap_socket).context("noop loop must detect a new email")?;
+        fetch_rfc822(imap_socket, Selection::FirstId, Email::Multipart).context("fetch rfc822 message, should be our first message")?;
+        copy(imap_socket, Selection::FirstId, Mailbox::Archive).context("copy message to the archive mailbox")?;
+        append_email(imap_socket, Email::Basic).context("insert email in INBOX")?;
+        // SEARCH IS NOT IMPLEMENTED YET
+        //search(imap_socket).expect("search should return something");
+        add_flags_email(imap_socket, Selection::FirstId, Flag::Deleted)
+            .context("should add delete flag to the email")?;
+        expunge(imap_socket).context("expunge emails")?;
+        rename_mailbox(imap_socket, Mailbox::Archive, Mailbox::Drafts).context("Archive mailbox is renamed Drafts")?;
+        delete_mailbox(imap_socket, Mailbox::Drafts).context("Drafts mailbox is deleted")?;
+        Ok(())
+    })
+    .expect("test fully run");
+}
+
+fn rfc3691_imapext_unselect() {
+    println!("rfc3691_imapext_unselect");
+    common::aerogramme_provider_daemon_dev(|imap_socket, lmtp_socket| {
+        connect(imap_socket).context("server says hello")?;
+
+        lmtp_handshake(lmtp_socket).context("handshake lmtp done")?;
+        lmtp_deliver_email(lmtp_socket, Email::Basic).context("mail delivered successfully")?;
+
+        capability(imap_socket, Extension::Unselect).context("check server capabilities")?;
+        login(imap_socket, Account::Alice).context("login test")?;
+        select(imap_socket, Mailbox::Inbox, None).context("select inbox")?;
+        noop_exists(imap_socket).context("noop loop must detect a new email")?;
+        add_flags_email(imap_socket, Selection::FirstId, Flag::Deleted).context("add delete flags to the email")?;
+        unselect(imap_socket)
+            .context("unselect inbox while preserving email with the \\Delete flag")?;
+        select(imap_socket, Mailbox::Inbox, Some(1)).context("select inbox again")?;
+        fetch_rfc822(imap_socket, Selection::FirstId, Email::Basic).context("message is still present")?;
+        close(imap_socket).context("close inbox and expunge message")?;
+        select(imap_socket, Mailbox::Inbox, Some(0)).context("select inbox again and check it's empty")?;
+
+        Ok(())
+    })
+    .expect("test fully run");
+}
+
+fn rfc5161_imapext_enable() {
+    println!("rfc5161_imapext_enable");
+    common::aerogramme_provider_daemon_dev(|imap_socket, _lmtp_socket| {
+        connect(imap_socket).context("server says hello")?;
+        login(imap_socket, Account::Alice).context("login test")?;
+        enable(imap_socket, Enable::Utf8Accept, Some(Enable::Utf8Accept))?;
+        enable(imap_socket, Enable::Utf8Accept, None)?;
+        logout(imap_socket)?;
+
+        Ok(())
+    })
+    .expect("test fully run");
+}
+
+fn rfc6851_imapext_move() {
+    println!("rfc6851_imapext_move");
+    common::aerogramme_provider_daemon_dev(|imap_socket, lmtp_socket| {
+        connect(imap_socket).context("server says hello")?;
+
+        capability(imap_socket, Extension::Move).context("check server capabilities")?;
+        login(imap_socket, Account::Alice).context("login test")?;
+        create_mailbox(imap_socket, Mailbox::Archive).context("created mailbox archive")?;
+        select(imap_socket, Mailbox::Inbox, None).context("select inbox")?;
+
+        lmtp_handshake(lmtp_socket).context("handshake lmtp done")?;
+        lmtp_deliver_email(lmtp_socket, Email::Basic).context("mail delivered successfully")?;
+
+        noop_exists(imap_socket).context("noop loop must detect a new email")?;
+        r#move(imap_socket, Selection::FirstId, Mailbox::Archive).context("message from inbox moved to archive")?;
+
+        unselect(imap_socket)
+            .context("unselect inbox while preserving email with the \\Delete flag")?;
+        select(imap_socket, Mailbox::Archive, Some(1)).context("select archive")?;
+        fetch_rfc822(imap_socket, Selection::FirstId, Email::Basic).context("check mail exists")?;
+        logout(imap_socket).context("must quit")?;
+
+        Ok(())
+    })
+    .expect("test fully run");
+}
+
+fn rfc7888_imapext_literal() {
+    println!("rfc7888_imapext_literal");
+    common::aerogramme_provider_daemon_dev(|imap_socket, _lmtp_socket| {
+        connect(imap_socket).context("server says hello")?;
+
+        capability(imap_socket, Extension::LiteralPlus).context("check server capabilities")?;
+        login_with_literal(imap_socket, Account::Alice).context("use literal to connect Alice")?;
+
+        Ok(())
+    }).expect("test fully run");
+}
diff --git a/tests/common/constants.rs b/tests/common/constants.rs
new file mode 100644
index 0000000..c11a04d
--- /dev/null
+++ b/tests/common/constants.rs
@@ -0,0 +1,54 @@
+use std::time;
+
+pub static SMALL_DELAY: time::Duration = time::Duration::from_millis(200);
+
+pub static EMAIL1: &[u8] = b"Date: Sat, 8 Jul 2023 07:14:29 +0200\r
+From: Bob Robert <bob@example.tld>\r
+To: Alice Malice <alice@example.tld>\r
+CC: =?ISO-8859-1?Q?Andr=E9?= Pirard <PIRARD@vm1.ulg.ac.be>\r
+Subject: =?ISO-8859-1?B?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=\r
+    =?ISO-8859-2?B?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?=\r
+X-Unknown: something something\r
+Bad entry\r
+  on multiple lines\r
+Message-ID: <NTAxNzA2AC47634Y366BAMTY4ODc5MzQyODY0ODY5@www.grrrndzero.org>\r
+MIME-Version: 1.0\r
+Content-Type: multipart/alternative;\r
+ boundary=\"b1_e376dc71bafc953c0b0fdeb9983a9956\"\r
+Content-Transfer-Encoding: 7bit\r
+\r
+This is a multi-part message in MIME format.\r
+\r
+--b1_e376dc71bafc953c0b0fdeb9983a9956\r
+Content-Type: text/plain; charset=utf-8\r
+Content-Transfer-Encoding: quoted-printable\r
+\r
+GZ\r
+OoOoO\r
+oOoOoOoOo\r
+oOoOoOoOoOoOoOoOo\r
+oOoOoOoOoOoOoOoOoOoOoOo\r
+oOoOoOoOoOoOoOoOoOoOoOoOoOoOo\r
+OoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoO\r
+\r
+--b1_e376dc71bafc953c0b0fdeb9983a9956\r
+Content-Type: text/html; charset=us-ascii\r
+\r
+<div style=\"text-align: center;\"><strong>GZ</strong><br />\r
+OoOoO<br />\r
+oOoOoOoOo<br />\r
+oOoOoOoOoOoOoOoOo<br />\r
+oOoOoOoOoOoOoOoOoOoOoOo<br />\r
+oOoOoOoOoOoOoOoOoOoOoOoOoOoOo<br />\r
+OoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoO<br />\r
+</div>\r
+\r
+--b1_e376dc71bafc953c0b0fdeb9983a9956--\r
+";
+
+pub static EMAIL2: &[u8] = b"From: alice@example.com\r
+To: alice@example.tld\r
+Subject: Test\r
+\r
+Hello world!\r
+";
diff --git a/tests/common/fragments.rs b/tests/common/fragments.rs
new file mode 100644
index 0000000..3ed14cc
--- /dev/null
+++ b/tests/common/fragments.rs
@@ -0,0 +1,406 @@
+use anyhow::{bail, Result};
+use std::io::Write;
+use std::net::TcpStream;
+use std::thread;
+
+use crate::common::constants::*;
+use crate::common::*;
+
+/// These fragments are not a generic IMAP client
+/// but specialized to our specific tests. They can't take
+/// arbitrary values, only enum for which the code is known
+/// to be correct. The idea is that the generated message is more
+/// or less hardcoded by the developer, so its clear what's expected,
+/// and not generated by a library. Also don't use vector of enum,
+/// as it again introduce some kind of genericity we try so hard to avoid:
+/// instead add a dedicated enum, for example "All" or anything relaevent that would
+/// describe your list and then hardcode it in your fragment.
+/// DON'T. TRY. TO. BE. GENERIC. HERE.
+
+pub fn connect(imap: &mut TcpStream) -> Result<()> {
+    let mut buffer: [u8; 1500] = [0; 1500];
+
+    let read = read_lines(imap, &mut buffer, None)?;
+    assert_eq!(&read[..4], &b"* OK"[..]);
+
+    Ok(())
+}
+
+pub enum Account {
+    Alice,
+}
+
+pub enum Extension {
+    None,
+    Unselect,
+    Move,
+    CondStore,
+    LiteralPlus,
+}
+
+pub enum Enable {
+    Utf8Accept,
+    CondStore,
+    All,
+}
+
+pub enum Mailbox {
+    Inbox,
+    Archive,
+    Drafts,
+}
+
+pub enum Flag {
+    Deleted,
+    Important
+}
+
+pub enum Email {
+    Basic,
+    Multipart,
+}
+
+pub enum Selection {
+    FirstId,
+    SecondId,
+}
+
+pub fn capability(imap: &mut TcpStream, ext: Extension) -> Result<()> {
+    imap.write(&b"5 capability\r\n"[..])?;
+
+    let maybe_ext = match ext {
+        Extension::None => None,
+        Extension::Unselect => Some("UNSELECT"),
+        Extension::Move => Some("MOVE"),
+        Extension::CondStore => Some("CONDSTORE"),
+        Extension::LiteralPlus => Some("LITERAL+"),
+    };
+
+    let mut buffer: [u8; 6000] = [0; 6000];
+    let read = read_lines(imap, &mut buffer, Some(&b"5 OK"[..]))?;
+    let srv_msg = std::str::from_utf8(read)?;
+    assert!(srv_msg.contains("IMAP4REV1"));
+    if let Some(ext) = maybe_ext {
+        assert!(srv_msg.contains(ext));
+    }
+
+    Ok(())
+}
+
+pub fn login(imap: &mut TcpStream, account: Account) -> Result<()> {
+    let mut buffer: [u8; 1500] = [0; 1500];
+
+    assert!(matches!(account, Account::Alice));
+    imap.write(&b"10 login alice hunter2\r\n"[..])?;
+
+    let read = read_lines(imap, &mut buffer, None)?;
+    assert_eq!(&read[..5], &b"10 OK"[..]);
+
+    Ok(())
+}
+
+pub fn login_with_literal(imap: &mut TcpStream, account: Account) -> Result<()> {
+    let mut buffer: [u8; 1500] = [0; 1500];
+
+    assert!(matches!(account, Account::Alice));
+    imap.write(&b"10 login {5+}\r\nalice {7+}\r\nhunter2\r\n"[..])?;
+    let _read = read_lines(imap, &mut buffer, Some(&b"10 OK"[..]))?;
+    Ok(())
+}
+
+pub fn create_mailbox(imap: &mut TcpStream, mbx: Mailbox) -> Result<()> {
+    let mut buffer: [u8; 1500] = [0; 1500];
+
+    let mbx_str = match mbx {
+        Mailbox::Inbox => "INBOX",
+        Mailbox::Archive => "Archive",
+        Mailbox::Drafts => "Drafts",
+    };
+
+    let cmd = format!("15 create {}\r\n", mbx_str);
+    imap.write(cmd.as_bytes())?;
+    let read = read_lines(imap, &mut buffer, None)?;
+    assert_eq!(&read[..12], &b"15 OK CREATE"[..]);
+
+    Ok(())
+}
+
+pub fn select(imap: &mut TcpStream, mbx: Mailbox, maybe_exists: Option<u64>) -> Result<()> {
+    let mut buffer: [u8; 6000] = [0; 6000];
+
+    let mbx_str = match mbx {
+        Mailbox::Inbox => "INBOX",
+        Mailbox::Archive => "Archive",
+        Mailbox::Drafts => "Drafts",
+    };
+    imap.write(format!("20 select {}\r\n", mbx_str).as_bytes())?;
+
+    let read = read_lines(imap, &mut buffer, Some(&b"20 OK"[..]))?;
+    let srv_msg = std::str::from_utf8(read)?;
+    if let Some(exists) = maybe_exists {
+        let expected = format!("* {} EXISTS", exists);
+        assert!(srv_msg.contains(&expected));
+    }
+
+    Ok(())
+}
+
+pub fn unselect(imap: &mut TcpStream) -> Result<()> {
+    imap.write(&b"70 unselect\r\n"[..])?;
+    let mut buffer: [u8; 1500] = [0; 1500];
+    let _read = read_lines(imap, &mut buffer, Some(&b"70 OK"[..]))?;
+
+    Ok(())
+}
+
+pub fn check(imap: &mut TcpStream) -> Result<()> {
+    let mut buffer: [u8; 1500] = [0; 1500];
+
+    imap.write(&b"21 check\r\n"[..])?;
+    let _read = read_lines(imap, &mut buffer, Some(&b"21 OK"[..]))?;
+
+    Ok(())
+}
+
+pub fn status_mailbox(imap: &mut TcpStream, mbx: Mailbox) -> Result<()> {
+    assert!(matches!(mbx, Mailbox::Archive));
+    imap.write(&b"25 STATUS Archive (UIDNEXT MESSAGES)\r\n"[..])?;
+    let mut buffer: [u8; 6000] = [0; 6000];
+    let _read = read_lines(imap, &mut buffer, Some(&b"25 OK"[..]))?;
+
+    Ok(())
+}
+
+pub fn lmtp_handshake(lmtp: &mut TcpStream) -> Result<()> {
+    let mut buffer: [u8; 1500] = [0; 1500];
+
+    let _read = read_lines(lmtp, &mut buffer, None)?;
+    assert_eq!(&buffer[..4], &b"220 "[..]);
+
+    lmtp.write(&b"LHLO example.tld\r\n"[..])?;
+    let _read = read_lines(lmtp, &mut buffer, Some(&b"250 "[..]))?;
+
+    Ok(())
+}
+
+pub fn lmtp_deliver_email(lmtp: &mut TcpStream, email_type: Email) -> Result<()> {
+    let mut buffer: [u8; 1500] = [0; 1500];
+
+    let email = match email_type {
+        Email::Basic => EMAIL2,
+        Email::Multipart => EMAIL1,
+    };
+    lmtp.write(&b"MAIL FROM:<bob@example.tld>\r\n"[..])?;
+    let _read = read_lines(lmtp, &mut buffer, Some(&b"250 2.0.0"[..]))?;
+
+    lmtp.write(&b"RCPT TO:<alice@example.tld>\r\n"[..])?;
+    let _read = read_lines(lmtp, &mut buffer, Some(&b"250 2.1.5"[..]))?;
+
+    lmtp.write(&b"DATA\r\n"[..])?;
+    let _read = read_lines(lmtp, &mut buffer, Some(&b"354 "[..]))?;
+
+    lmtp.write(email)?;
+    lmtp.write(&b"\r\n.\r\n"[..])?;
+    let _read = read_lines(lmtp, &mut buffer, Some(&b"250 2.0.0"[..]))?;
+
+    Ok(())
+}
+
+pub fn noop_exists(imap: &mut TcpStream) -> Result<()> {
+    let mut buffer: [u8; 6000] = [0; 6000];
+
+    let mut max_retry = 20;
+    loop {
+        max_retry -= 1;
+        imap.write(&b"30 NOOP\r\n"[..])?;
+        let read = read_lines(imap, &mut buffer, Some(&b"30 OK"[..]))?;
+        let srv_msg = std::str::from_utf8(read)?;
+
+        match (max_retry, srv_msg.lines().count()) {
+            (_, cnt) if cnt > 1 => break,
+            (0, _) => bail!("no more retry"),
+            _ => (),
+        }
+
+        thread::sleep(SMALL_DELAY);
+    }
+
+    Ok(())
+}
+
+pub fn fetch_rfc822(imap: &mut TcpStream, selection: Selection, r#ref: Email) -> Result<()> {
+    let mut buffer: [u8; 65535] = [0; 65535];
+
+    assert!(matches!(selection, Selection::FirstId));
+    imap.write(&b"40 fetch 1 rfc822\r\n"[..])?;
+
+    let read = read_lines(imap, &mut buffer, Some(&b"40 OK FETCH"[..]))?;
+    let srv_msg = std::str::from_utf8(read)?;
+
+    let ref_mail = match r#ref {
+        Email::Basic => EMAIL2,
+        Email::Multipart => EMAIL1,
+    };
+    let orig_email = std::str::from_utf8(ref_mail)?;
+    assert!(srv_msg.contains(orig_email));
+
+    Ok(())
+}
+
+pub fn copy(imap: &mut TcpStream, selection: Selection, to: Mailbox) -> Result<()> {
+    let mut buffer: [u8; 65535] = [0; 65535];
+    assert!(matches!(selection, Selection::FirstId));
+    assert!(matches!(to, Mailbox::Archive));
+
+    imap.write(&b"45 copy 1 Archive\r\n"[..])?;
+    let read = read_lines(imap, &mut buffer, None)?;
+    assert_eq!(&read[..5], &b"45 OK"[..]);
+
+    Ok(())
+}
+
+pub fn append_email(imap: &mut TcpStream, content: Email) -> Result<()> {
+    let mut buffer: [u8; 6000] = [0; 6000];
+
+    let ref_mail = match content {
+        Email::Multipart => EMAIL1,
+        Email::Basic => EMAIL2,
+    };
+
+    let append_cmd = format!("47 append inbox (\\Seen) {{{}}}\r\n", ref_mail.len());
+    println!("append cmd: {}", append_cmd);
+    imap.write(append_cmd.as_bytes())?;
+
+    // wait for continuation
+    let read = read_lines(imap, &mut buffer, None)?;
+    assert_eq!(read[0], b'+');
+
+    // write our stuff
+    imap.write(ref_mail)?;
+    imap.write(&b"\r\n"[..])?;
+    let read = read_lines(imap, &mut buffer, None)?;
+    assert_eq!(&read[..5], &b"47 OK"[..]);
+
+    // we check that noop detects the change
+    noop_exists(imap)?;
+
+    Ok(())
+}
+
+
+
+pub fn add_flags_email(imap: &mut TcpStream, selection: Selection, flag: Flag) -> Result<()> {
+    let mut buffer: [u8; 1500] = [0; 1500];
+    assert!(matches!(selection, Selection::FirstId));
+    assert!(matches!(flag, Flag::Deleted));
+    imap.write(&b"50 store 1 +FLAGS (\\Deleted)\r\n"[..])?;
+    let _read = read_lines(imap, &mut buffer, Some(&b"50 OK STORE"[..]))?;
+
+    Ok(())
+}
+
+#[allow(dead_code)]
+/// Not yet implemented
+pub fn search(imap: &mut TcpStream) -> Result<()> {
+    imap.write(&b"55 search text \"OoOoO\"\r\n"[..])?;
+    let mut buffer: [u8; 1500] = [0; 1500];
+    let _read = read_lines(imap, &mut buffer, Some(&b"55 OK SEARCH"[..]))?;
+    Ok(())
+}
+
+pub fn expunge(imap: &mut TcpStream) -> Result<()> {
+    imap.write(&b"60 expunge\r\n"[..])?;
+    let mut buffer: [u8; 1500] = [0; 1500];
+    let _read = read_lines(imap, &mut buffer, Some(&b"60 OK EXPUNGE"[..]))?;
+
+    Ok(())
+}
+
+pub fn rename_mailbox(imap: &mut TcpStream, from: Mailbox, to: Mailbox) -> Result<()> {
+    assert!(matches!(from, Mailbox::Archive));
+    assert!(matches!(to, Mailbox::Drafts));
+
+    imap.write(&b"70 rename Archive Drafts\r\n"[..])?;
+    let mut buffer: [u8; 1500] = [0; 1500];
+    let read = read_lines(imap, &mut buffer, None)?;
+    assert_eq!(&read[..5], &b"70 OK"[..]);
+
+    imap.write(&b"71 list \"\" *\r\n"[..])?;
+    let read = read_lines(imap, &mut buffer, Some(&b"71 OK LIST"[..]))?;
+    let srv_msg = std::str::from_utf8(read)?;
+    assert!(!srv_msg.contains(" Archive\r\n"));
+    assert!(srv_msg.contains(" INBOX\r\n"));
+    assert!(srv_msg.contains(" Drafts\r\n"));
+
+    Ok(())
+}
+
+pub fn delete_mailbox(imap: &mut TcpStream, mbx: Mailbox) -> Result<()> {
+    let mbx_str = match mbx {
+        Mailbox::Inbox => "INBOX",
+        Mailbox::Archive => "Archive",
+        Mailbox::Drafts => "Drafts",
+    };
+    let cmd = format!("80 delete {}\r\n", mbx_str);
+
+    imap.write(cmd.as_bytes())?;
+    let mut buffer: [u8; 1500] = [0; 1500];
+    let read = read_lines(imap, &mut buffer, None)?;
+    assert_eq!(&read[..5], &b"80 OK"[..]);
+
+    imap.write(&b"81 list \"\" *\r\n"[..])?;
+    let read = read_lines(imap, &mut buffer, Some(&b"81 OK"[..]))?;
+    let srv_msg = std::str::from_utf8(read)?;
+    assert!(srv_msg.contains(" INBOX\r\n"));
+    assert!(!srv_msg.contains(format!(" {}\r\n", mbx_str).as_str()));
+
+    Ok(())
+}
+
+pub fn close(imap: &mut TcpStream) -> Result<()> {
+    imap.write(&b"60 close\r\n"[..])?;
+    let mut buffer: [u8; 1500] = [0; 1500];
+    let _read = read_lines(imap, &mut buffer, Some(&b"60 OK"[..]))?;
+
+    Ok(())
+}
+
+pub fn r#move(imap: &mut TcpStream, selection: Selection, to: Mailbox) -> Result<()> {
+    let mut buffer: [u8; 1500] = [0; 1500];
+    assert!(matches!(to, Mailbox::Archive));
+    assert!(matches!(selection, Selection::FirstId));
+
+    imap.write(&b"35 move 1 Archive\r\n"[..])?;
+    let read = read_lines(imap, &mut buffer, Some(&b"35 OK"[..]))?;
+    let srv_msg = std::str::from_utf8(read)?;
+    assert!(srv_msg.contains("* 1 EXPUNGE"));
+
+    Ok(())
+}
+
+pub fn enable(imap: &mut TcpStream, ask: Enable, done: Option<Enable>) -> Result<()> {
+    let mut buffer: [u8; 6000] = [0; 6000];
+    assert!(matches!(ask, Enable::Utf8Accept));
+
+    imap.write(&b"36 enable UTF8=ACCEPT\r\n"[..])?;
+    let read = read_lines(imap, &mut buffer, Some(&b"36 OK"[..]))?;
+    let srv_msg = std::str::from_utf8(read)?;
+    match done {
+        None => assert_eq!(srv_msg.lines().count(), 1),
+        Some(Enable::Utf8Accept) => {
+            assert_eq!(srv_msg.lines().count(), 2);
+            assert!(srv_msg.contains("* ENABLED UTF8=ACCEPT"));
+        },
+        _ => unimplemented!(),
+    }
+
+    Ok(())
+}
+
+pub fn logout(imap: &mut TcpStream) -> Result<()> {
+    imap.write(&b"99 logout\r\n"[..])?;
+    let mut buffer: [u8; 1500] = [0; 1500];
+    let read = read_lines(imap, &mut buffer, None)?;
+    assert_eq!(&read[..5], &b"* BYE"[..]);
+    Ok(())
+}
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
new file mode 100644
index 0000000..810fd79
--- /dev/null
+++ b/tests/common/mod.rs
@@ -0,0 +1,90 @@
+#![allow(dead_code)]
+pub mod constants;
+pub mod fragments;
+
+use anyhow::{bail, Context, Result};
+use std::io::Read;
+use std::net::{Shutdown, TcpStream};
+use std::process::Command;
+use std::thread;
+
+use constants::SMALL_DELAY;
+
+pub fn aerogramme_provider_daemon_dev(
+    mut fx: impl FnMut(&mut TcpStream, &mut TcpStream) -> Result<()>,
+) -> Result<()> {
+    // Check port is not used (= free) before starting the test
+    let mut max_retry = 20;
+    loop {
+        max_retry -= 1;
+        match (TcpStream::connect("[::1]:1143"), max_retry) {
+            (Ok(_), 0) => bail!("something is listening on [::1]:1143 and prevent the test from starting"),
+            (Ok(_), _) => println!("something is listening on [::1]:1143, maybe a previous daemon quitting, retrying soon..."),
+            (Err(_), _) => {
+                println!("test ready to start, [::1]:1143 is free!");
+                break
+            }
+        }
+        thread::sleep(SMALL_DELAY);
+    }
+
+    // Start daemon
+    let mut daemon = Command::new(env!("CARGO_BIN_EXE_aerogramme"))
+        .arg("--dev")
+        .arg("provider")
+        .arg("daemon")
+        .spawn()?;
+
+    // Check that our daemon is correctly listening on the free port
+    let mut max_retry = 20;
+    let mut imap_socket = loop {
+        max_retry -= 1;
+        match (TcpStream::connect("[::1]:1143"), max_retry) {
+            (Err(e), 0) => bail!("no more retry, last error is: {}", e),
+            (Err(e), _) => {
+                println!("unable to connect: {} ; will retry soon...", e);
+            }
+            (Ok(v), _) => break v,
+        }
+        thread::sleep(SMALL_DELAY);
+    };
+
+    // Assuming now it's safe to open a LMTP socket
+    let mut lmtp_socket =
+        TcpStream::connect("[::1]:1025").context("lmtp socket must be connected")?;
+
+    println!("-- ready to test imap features --");
+    let result = fx(&mut imap_socket, &mut lmtp_socket);
+    println!("-- test teardown --");
+
+    imap_socket
+        .shutdown(Shutdown::Both)
+        .context("closing imap socket at the end of the test")?;
+    lmtp_socket
+        .shutdown(Shutdown::Both)
+        .context("closing lmtp socket at the end of the test")?;
+    daemon.kill().context("daemon should be killed")?;
+
+    result.context("all tests passed")
+}
+
+pub fn read_lines<'a, F: Read>(
+    reader: &mut F,
+    buffer: &'a mut [u8],
+    stop_marker: Option<&[u8]>,
+) -> Result<&'a [u8]> {
+    let mut nbytes = 0;
+    loop {
+        nbytes += reader.read(&mut buffer[nbytes..])?;
+        //println!("partial read: {}", std::str::from_utf8(&buffer[..nbytes])?);
+        let pre_condition = match stop_marker {
+            None => true,
+            Some(mark) => buffer[..nbytes].windows(mark.len()).any(|w| w == mark),
+        };
+        if pre_condition && nbytes >= 2 && &buffer[nbytes - 2..nbytes] == &b"\r\n"[..] {
+            break;
+        }
+    }
+    println!("read: {}", std::str::from_utf8(&buffer[..nbytes])?);
+    Ok(&buffer[..nbytes])
+}
diff --git a/tests/imap_features.rs b/tests/imap_features.rs
deleted file mode 100644
index 9e8d587..0000000
--- a/tests/imap_features.rs
+++ /dev/null
@@ -1,394 +0,0 @@
-use anyhow::{bail, Context, Result};
-use std::io::{Read, Write};
-use std::net::{Shutdown, TcpStream};
-use std::process::Command;
-use std::{thread, time};
-
-static SMALL_DELAY: time::Duration = time::Duration::from_millis(200);
-static EMAIL1: &[u8] = b"Date: Sat, 8 Jul 2023 07:14:29 +0200\r
-From: Bob Robert <bob@example.tld>\r
-To: Alice Malice <alice@example.tld>\r
-CC: =?ISO-8859-1?Q?Andr=E9?= Pirard <PIRARD@vm1.ulg.ac.be>\r
-Subject: =?ISO-8859-1?B?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=\r
-    =?ISO-8859-2?B?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?=\r
-X-Unknown: something something\r
-Bad entry\r
-  on multiple lines\r
-Message-ID: <NTAxNzA2AC47634Y366BAMTY4ODc5MzQyODY0ODY5@www.grrrndzero.org>\r
-MIME-Version: 1.0\r
-Content-Type: multipart/alternative;\r
- boundary=\"b1_e376dc71bafc953c0b0fdeb9983a9956\"\r
-Content-Transfer-Encoding: 7bit\r
-\r
-This is a multi-part message in MIME format.\r
-\r
---b1_e376dc71bafc953c0b0fdeb9983a9956\r
-Content-Type: text/plain; charset=utf-8\r
-Content-Transfer-Encoding: quoted-printable\r
-\r
-GZ\r
-OoOoO\r
-oOoOoOoOo\r
-oOoOoOoOoOoOoOoOo\r
-oOoOoOoOoOoOoOoOoOoOoOo\r
-oOoOoOoOoOoOoOoOoOoOoOoOoOoOo\r
-OoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoO\r
-\r
---b1_e376dc71bafc953c0b0fdeb9983a9956\r
-Content-Type: text/html; charset=us-ascii\r
-\r
-<div style=\"text-align: center;\"><strong>GZ</strong><br />\r
-OoOoO<br />\r
-oOoOoOoOo<br />\r
-oOoOoOoOoOoOoOoOo<br />\r
-oOoOoOoOoOoOoOoOoOoOoOo<br />\r
-oOoOoOoOoOoOoOoOoOoOoOoOoOoOo<br />\r
-OoOoOoOoOoOoOoOoOoOoOoOoOoOoOoOoO<br />\r
-</div>\r
-\r
---b1_e376dc71bafc953c0b0fdeb9983a9956--\r
-";
-
-static EMAIL2: &[u8] = b"From: alice@example.com\r
-To: alice@example.tld\r
-Subject: Test\r
-\r
-Hello world!\r
-";
-
-fn main() {
-    let mut daemon = Command::new(env!("CARGO_BIN_EXE_aerogramme"))
-        .arg("--dev")
-        .arg("provider")
-        .arg("daemon")
-        .spawn()
-        .expect("daemon should be started");
-
-    let mut max_retry = 20;
-    let mut imap_socket = loop {
-        max_retry -= 1;
-        match (TcpStream::connect("[::1]:1143"), max_retry) {
-            (Err(e), 0) => panic!("no more retry, last error is: {}", e),
-            (Err(e), _) => {
-                println!("unable to connect: {} ; will retry in 1 sec", e);
-            }
-            (Ok(v), _) => break v,
-        }
-        thread::sleep(SMALL_DELAY);
-    };
-
-    let mut lmtp_socket = TcpStream::connect("[::1]:1025").expect("lmtp socket must be connected");
-
-    println!("-- ready to test imap features --");
-    let result = generic_test(&mut imap_socket, &mut lmtp_socket);
-    println!("-- test teardown --");
-
-    imap_socket
-        .shutdown(Shutdown::Both)
-        .expect("closing imap socket at the end of the test");
-    lmtp_socket
-        .shutdown(Shutdown::Both)
-        .expect("closing lmtp socket at the end of the test");
-    daemon.kill().expect("daemon should be killed");
-
-    result.expect("all tests passed");
-}
-
-fn generic_test(imap_socket: &mut TcpStream, lmtp_socket: &mut TcpStream) -> Result<()> {
-    connect(imap_socket).context("server says hello")?;
-    capability(imap_socket).context("check server capabilities")?;
-    login(imap_socket).context("login test")?;
-    create_mailbox(imap_socket).context("created mailbox archive")?;
-    // UNSUBSCRIBE IS NOT IMPLEMENTED YET
-    //unsubscribe_mailbox(imap_socket).context("unsubscribe from archive")?;
-    select_inbox(imap_socket).context("select inbox")?;
-    check(imap_socket).context("check must run")?;
-    status_mailbox(imap_socket).context("status of archive from inbox")?;
-    lmtp_handshake(lmtp_socket).context("handshake lmtp done")?;
-    lmtp_deliver_email(lmtp_socket, EMAIL1).context("mail delivered successfully")?;
-    noop_exists(imap_socket).context("noop loop must detect a new email")?;
-    fetch_rfc822(imap_socket, EMAIL1).context("fetch rfc822 message")?;
-    copy_email(imap_socket).context("copy message to the archive mailbox")?;
-    append_email(imap_socket, EMAIL2).context("insert email in INBOX")?;
-    // SEARCH IS NOT IMPLEMENTED YET
-    //search(imap_socket).expect("search should return something");
-    add_flags_email(imap_socket).context("should add delete and important flags to the email")?;
-    expunge(imap_socket).context("expunge emails")?;
-    rename_mailbox(imap_socket).context("archive mailbox is renamed my-archives")?;
-    delete_mailbox(imap_socket).context("my-archives mailbox is deleted")?;
-    Ok(())
-}
-
-fn connect(imap: &mut TcpStream) -> Result<()> {
-    let mut buffer: [u8; 1500] = [0; 1500];
-
-    let read = read_lines(imap, &mut buffer, None)?;
-    assert_eq!(&read[..4], &b"* OK"[..]);
-
-    Ok(())
-}
-
-fn capability(imap: &mut TcpStream) -> Result<()> {
-    imap.write(&b"5 capability\r\n"[..])?;
-
-    let mut buffer: [u8; 1500] = [0; 1500];
-    let read = read_lines(imap, &mut buffer, Some(&b"5 OK"[..]))?;
-    let srv_msg = std::str::from_utf8(read)?;
-    assert!(srv_msg.contains("IMAP4REV1"));
-    assert!(srv_msg.contains("IDLE"));
-
-    Ok(())
-}
-
-fn login(imap: &mut TcpStream) -> Result<()> {
-    let mut buffer: [u8; 1500] = [0; 1500];
-
-    imap.write(&b"10 login alice hunter2\r\n"[..])?;
-
-    let read = read_lines(imap, &mut buffer, None)?;
-    assert_eq!(&read[..5], &b"10 OK"[..]);
-
-    Ok(())
-}
-
-fn create_mailbox(imap: &mut TcpStream) -> Result<()> {
-    let mut buffer: [u8; 1500] = [0; 1500];
-
-    imap.write(&b"15 create archive\r\n"[..])?;
-    let read = read_lines(imap, &mut buffer, None)?;
-    assert_eq!(&read[..12], &b"15 OK CREATE"[..]);
-
-    Ok(())
-}
-
-#[allow(dead_code)]
-fn unsubscribe_mailbox(imap: &mut TcpStream) -> Result<()> {
-    let mut buffer: [u8; 6000] = [0; 6000];
-
-    imap.write(&b"16 lsub \"\" *\r\n"[..])?;
-    let read = read_lines(imap, &mut buffer, Some(&b"16 OK LSUB"[..]))?;
-    let srv_msg = std::str::from_utf8(read)?;
-    assert!(srv_msg.contains(" INBOX\r\n"));
-    assert!(srv_msg.contains(" archive\r\n"));
-
-    imap.write(&b"17 unsubscribe archive\r\n"[..])?;
-    let read = read_lines(imap, &mut buffer, None)?;
-    assert_eq!(&read[..5], &b"17 OK"[..]);
-
-    imap.write(&b"18 lsub \"\" *\r\n"[..])?;
-    let read = read_lines(imap, &mut buffer, Some(&b"18 OK LSUB"[..]))?;
-    let srv_msg = std::str::from_utf8(read)?;
-    assert!(srv_msg.contains(" INBOX\r\n"));
-    assert!(!srv_msg.contains(" archive\r\n"));
-
-    Ok(())
-}
-
-fn select_inbox(imap: &mut TcpStream) -> Result<()> {
-    let mut buffer: [u8; 6000] = [0; 6000];
-
-    imap.write(&b"20 select inbox\r\n"[..])?;
-    let _read = read_lines(imap, &mut buffer, Some(&b"20 OK"[..]))?;
-
-    Ok(())
-}
-
-fn check(imap: &mut TcpStream) -> Result<()> {
-    let mut buffer: [u8; 1500] = [0; 1500];
-
-    imap.write(&b"21 check\r\n"[..])?;
-    let _read = read_lines(imap, &mut buffer, Some(&b"21 OK"[..]))?;
-
-    Ok(())
-}
-
-fn status_mailbox(imap: &mut TcpStream) -> Result<()> {
-    imap.write(&b"25 STATUS archive (UIDNEXT MESSAGES)\r\n"[..])?;
-    let mut buffer: [u8; 6000] = [0; 6000];
-    let _read = read_lines(imap, &mut buffer, Some(&b"25 OK"[..]))?;
-
-    Ok(())
-}
-
-fn lmtp_handshake(lmtp: &mut TcpStream) -> Result<()> {
-    let mut buffer: [u8; 1500] = [0; 1500];
-
-    let _read = read_lines(lmtp, &mut buffer, None)?;
-    assert_eq!(&buffer[..4], &b"220 "[..]);
-
-    lmtp.write(&b"LHLO example.tld\r\n"[..])?;
-    let _read = read_lines(lmtp, &mut buffer, Some(&b"250 "[..]))?;
-
-    Ok(())
-}
-
-fn lmtp_deliver_email(lmtp: &mut TcpStream, email: &[u8]) -> Result<()> {
-    let mut buffer: [u8; 1500] = [0; 1500];
-
-    lmtp.write(&b"MAIL FROM:<bob@example.tld>\r\n"[..])?;
-    let _read = read_lines(lmtp, &mut buffer, Some(&b"250 2.0.0"[..]))?;
-
-    lmtp.write(&b"RCPT TO:<alice@example.tld>\r\n"[..])?;
-    let _read = read_lines(lmtp, &mut buffer, Some(&b"250 2.1.5"[..]))?;
-
-    lmtp.write(&b"DATA\r\n"[..])?;
-    let _read = read_lines(lmtp, &mut buffer, Some(&b"354 "[..]))?;
-
-    lmtp.write(email)?;
-    lmtp.write(&b"\r\n.\r\n"[..])?;
-    let _read = read_lines(lmtp, &mut buffer, Some(&b"250 2.0.0"[..]))?;
-
-    Ok(())
-}
-
-fn noop_exists(imap: &mut TcpStream) -> Result<()> {
-    let mut buffer: [u8; 6000] = [0; 6000];
-
-    let mut max_retry = 20;
-    loop {
-        max_retry -= 1;
-        imap.write(&b"30 NOOP\r\n"[..])?;
-        let read = read_lines(imap, &mut buffer, Some(&b"30 OK NOOP"[..]))?;
-        let srv_msg = std::str::from_utf8(read)?;
-
-        match (max_retry, srv_msg.contains("* 1 EXISTS")) {
-            (_, true) => break,
-            (0, _) => bail!("no more retry"),
-            _ => (),
-        }
-
-        thread::sleep(SMALL_DELAY);
-    }
-
-    Ok(())
-}
-
-fn fetch_rfc822(imap: &mut TcpStream, ref_mail: &[u8]) -> Result<()> {
-    let mut buffer: [u8; 65535] = [0; 65535];
-    imap.write(&b"40 fetch 1 rfc822\r\n"[..])?;
-
-    let read = read_lines(imap, &mut buffer, Some(&b"40 OK FETCH"[..]))?;
-    let srv_msg = std::str::from_utf8(read)?;
-    let orig_email = std::str::from_utf8(ref_mail)?;
-    assert!(srv_msg.contains(orig_email));
-
-    Ok(())
-}
-
-fn copy_email(imap: &mut TcpStream) -> Result<()> {
-    let mut buffer: [u8; 65535] = [0; 65535];
-    imap.write(&b"45 copy 1 archive\r\n"[..])?;
-    let read = read_lines(imap, &mut buffer, None)?;
-    assert_eq!(&read[..5], &b"45 OK"[..]);
-
-    Ok(())
-}
-
-fn append_email(imap: &mut TcpStream, ref_mail: &[u8]) -> Result<()> {
-    let mut buffer: [u8; 6000] = [0; 6000];
-    assert_ne!(ref_mail.len(), 0);
-    let append_cmd = format!("47 append inbox (\\Seen) {{{}}}\r\n", ref_mail.len());
-    println!("append cmd: {}", append_cmd);
-    imap.write(append_cmd.as_bytes())?;
-
-    // wait for continuation
-    let read = read_lines(imap, &mut buffer, None)?;
-    assert_eq!(read[0], b'+');
-
-    // write our stuff
-    imap.write(ref_mail)?;
-    imap.write(&b"\r\n"[..])?;
-    let read = read_lines(imap, &mut buffer, None)?;
-    assert_eq!(&read[..5], &b"47 OK"[..]);
-
-    // noop to force a sync
-    imap.write(&b"48 NOOP\r\n"[..])?;
-    let _read = read_lines(imap, &mut buffer, Some(&b"48 OK NOOP"[..]))?;
-
-    // check it is stored successfully
-    imap.write(&b"49 fetch 2 rfc822.size\r\n"[..])?;
-    let read = read_lines(imap, &mut buffer, Some(&b"49 OK"[..]))?;
-    let expected = format!("* 2 FETCH (RFC822.SIZE {})", ref_mail.len());
-    let expbytes = expected.as_bytes();
-    assert_eq!(&read[..expbytes.len()], expbytes);
-
-    Ok(())
-}
-
-fn add_flags_email(imap: &mut TcpStream) -> Result<()> {
-    let mut buffer: [u8; 1500] = [0; 1500];
-    imap.write(&b"50 store 1 +FLAGS (\\Deleted \\Important)\r\n"[..])?;
-    let _read = read_lines(imap, &mut buffer, Some(&b"50 OK STORE"[..]))?;
-
-    Ok(())
-}
-
-#[allow(dead_code)]
-/// Not yet implemented
-fn search(imap: &mut TcpStream) -> Result<()> {
-    imap.write(&b"55 search text \"OoOoO\"\r\n"[..])?;
-    let mut buffer: [u8; 1500] = [0; 1500];
-    let _read = read_lines(imap, &mut buffer, Some(&b"55 OK SEARCH"[..]))?;
-    Ok(())
-}
-
-fn expunge(imap: &mut TcpStream) -> Result<()> {
-    imap.write(&b"60 expunge\r\n"[..])?;
-    let mut buffer: [u8; 1500] = [0; 1500];
-    let _read = read_lines(imap, &mut buffer, Some(&b"60 OK EXPUNGE"[..]))?;
-
-    Ok(())
-}
-
-fn rename_mailbox(imap: &mut TcpStream) -> Result<()> {
-    imap.write(&b"70 rename archive my-archives\r\n"[..])?;
-    let mut buffer: [u8; 1500] = [0; 1500];
-    let read = read_lines(imap, &mut buffer, None)?;
-    assert_eq!(&read[..5], &b"70 OK"[..]);
-
-    imap.write(&b"71 list \"\" *\r\n"[..])?;
-    let read = read_lines(imap, &mut buffer, Some(&b"71 OK LIST"[..]))?;
-    let srv_msg = std::str::from_utf8(read)?;
-    assert!(!srv_msg.contains(" archive\r\n"));
-    assert!(srv_msg.contains(" INBOX\r\n"));
-    assert!(srv_msg.contains(" my-archives\r\n"));
-
-    Ok(())
-}
-
-fn delete_mailbox(imap: &mut TcpStream) -> Result<()> {
-    imap.write(&b"80 delete my-archives\r\n"[..])?;
-    let mut buffer: [u8; 1500] = [0; 1500];
-    let read = read_lines(imap, &mut buffer, None)?;
-    assert_eq!(&read[..5], &b"80 OK"[..]);
-
-    imap.write(&b"81 list \"\" *\r\n"[..])?;
-    let read = read_lines(imap, &mut buffer, Some(&b"81 OK LIST"[..]))?;
-    let srv_msg = std::str::from_utf8(read)?;
-    assert!(!srv_msg.contains(" archive\r\n"));
-    assert!(!srv_msg.contains(" my-archives\r\n"));
-    assert!(srv_msg.contains(" INBOX\r\n"));
-
-    Ok(())
-}
-
-fn read_lines<'a, F: Read>(
-    reader: &mut F,
-    buffer: &'a mut [u8],
-    stop_marker: Option<&[u8]>,
-) -> Result<&'a [u8]> {
-    let mut nbytes = 0;
-    loop {
-        nbytes += reader.read(&mut buffer[nbytes..])?;
-        //println!("partial read: {}", std::str::from_utf8(&buffer[..nbytes])?);
-        let pre_condition = match stop_marker {
-            None => true,
-            Some(mark) => buffer[..nbytes].windows(mark.len()).any(|w| w == mark),
-        };
-        if pre_condition && &buffer[nbytes - 2..nbytes] == &b"\r\n"[..] {
-            break;
-        }
-    }
-    println!("read: {}", std::str::from_utf8(&buffer[..nbytes])?);
-    Ok(&buffer[..nbytes])
-}