diff --git a/src/attention.rs b/src/attention.rs
index 398b2bfd2f3424189dca01d8875bfe0ea8025e7e..4bfffd7eb7fe725943adfbcb1c3289cc330c5b65 100644
--- a/src/attention.rs
+++ b/src/attention.rs
@@ -20,6 +20,11 @@ mod tests {
     use minidom::Element;
     use error::Error;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Attention, 0);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<attention xmlns='urn:xmpp:attention:0'/>".parse().unwrap();
diff --git a/src/bind.rs b/src/bind.rs
index 1922093b303c8dadcc14337bdac2e903a635a120..6bfa8a310edc4a765fb8cab864dab159eb339fb0 100644
--- a/src/bind.rs
+++ b/src/bind.rs
@@ -98,6 +98,11 @@ impl From<Bind> for Element {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Bind, 80);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'/>".parse().unwrap();
diff --git a/src/blocking.rs b/src/blocking.rs
index 6b6894c9ad5c14e68c1321d7ad4114b8395c94e2..87a2fbd2bcdc002d897bc33a9d969c84ebb6e62c 100644
--- a/src/blocking.rs
+++ b/src/blocking.rs
@@ -98,6 +98,14 @@ generate_empty_element!(
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_size() {
+        assert_size!(BlocklistRequest, 0);
+        assert_size!(BlocklistResult, 24);
+        assert_size!(Block, 24);
+        assert_size!(Unblock, 24);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<blocklist xmlns='urn:xmpp:blocking'/>".parse().unwrap();
diff --git a/src/bookmarks.rs b/src/bookmarks.rs
index 11b4a42131af17549f18115bf90e1d8beac4da30..8ae0639205358f30feb399b0a9e93750f2e9dacf 100644
--- a/src/bookmarks.rs
+++ b/src/bookmarks.rs
@@ -74,6 +74,13 @@ mod tests {
     use minidom::Element;
     use compare_elements::NamespaceAwareCompare;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Conference, 152);
+        assert_size!(Url, 48);
+        assert_size!(Storage, 48);
+    }
+
     #[test]
     fn empty() {
         let elem: Element = "<storage xmlns='storage:bookmarks'/>".parse().unwrap();
diff --git a/src/caps.rs b/src/caps.rs
index 25c851fbaba2d0906840d6711fc5a229f7ab2245..7fcaea801731e2ae4f238d3b14cae73c4d67a34d 100644
--- a/src/caps.rs
+++ b/src/caps.rs
@@ -211,6 +211,11 @@ mod tests {
     use caps;
     use base64;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Caps, 104);
+    }
+
     #[test]
     fn test_parse() {
         let elem: Element = "<c xmlns='http://jabber.org/protocol/caps' hash='sha-256' node='coucou' ver='K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4='/>".parse().unwrap();
diff --git a/src/chatstates.rs b/src/chatstates.rs
index c9fabd5264285d188ce3752cab97777bdd1d4454..477bdded08d5b9083ac95e3995acb2bde604ea85 100644
--- a/src/chatstates.rs
+++ b/src/chatstates.rs
@@ -37,6 +37,11 @@ mod tests {
     use error::Error;
     use ns;
 
+    #[test]
+    fn test_size() {
+        assert_size!(ChatState, 1);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<active xmlns='http://jabber.org/protocol/chatstates'/>".parse().unwrap();
diff --git a/src/component.rs b/src/component.rs
index 27229f25aaeab1bc8befc999a83a11f5c5561b32..503e103423c05bfff07fcbd9d51289661450c131 100644
--- a/src/component.rs
+++ b/src/component.rs
@@ -47,6 +47,11 @@ mod tests {
     use try_from::TryFrom;
     use minidom::Element;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Handshake, 24);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<handshake xmlns='jabber:component:accept'/>".parse().unwrap();
diff --git a/src/data_forms.rs b/src/data_forms.rs
index a43977974eb84b0efbccfbac91893fe19ef142cb..3fccd72622e8983631b495192cd1e93d0dbf11db 100644
--- a/src/data_forms.rs
+++ b/src/data_forms.rs
@@ -268,6 +268,15 @@ impl From<DataForm> for Element {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Option_, 48);
+        assert_size!(FieldType, 1);
+        assert_size!(Field, 128);
+        assert_size!(DataFormType, 1);
+        assert_size!(DataForm, 104);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<x xmlns='jabber:x:data' type='result'/>".parse().unwrap();
diff --git a/src/date.rs b/src/date.rs
index a344eb58d97dc4ad297de5fd471811c8594fd2f9..5f2038de7a4576fec17c8a5f1a618bfa3d6343fa 100644
--- a/src/date.rs
+++ b/src/date.rs
@@ -43,6 +43,11 @@ mod tests {
     use chrono::{Datelike, Timelike};
     use std::error::Error as StdError;
 
+    #[test]
+    fn test_size() {
+        assert_size!(DateTime, 16);
+    }
+
     #[test]
     fn test_simple() {
         let date: DateTime = "2002-09-10T23:08:25Z".parse().unwrap();
diff --git a/src/delay.rs b/src/delay.rs
index 581e72e26184428f4320bb80429fa4f55f481d43..c4f7518f6f85da2fcef3fd698fb770d8f00a5e5d 100644
--- a/src/delay.rs
+++ b/src/delay.rs
@@ -39,6 +39,11 @@ mod tests {
     use error::Error;
     use std::str::FromStr;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Delay, 112);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<delay xmlns='urn:xmpp:delay' from='capulet.com' stamp='2002-09-10T23:08:25Z'/>".parse().unwrap();
diff --git a/src/disco.rs b/src/disco.rs
index 59166eb82bd2d3db50663a287edccbdb5074b9d3..7b435530a6c72bec563000c459fd94c153106413 100644
--- a/src/disco.rs
+++ b/src/disco.rs
@@ -235,6 +235,18 @@ mod tests {
     use compare_elements::NamespaceAwareCompare;
     use std::str::FromStr;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Identity, 96);
+        assert_size!(Feature, 24);
+        assert_size!(DiscoInfoQuery, 24);
+        assert_size!(DiscoInfoResult, 96);
+
+        assert_size!(Item, 120);
+        assert_size!(DiscoItemsQuery, 24);
+        assert_size!(DiscoItemsResult, 48);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='client' type='pc'/><feature var='http://jabber.org/protocol/disco#info'/></query>".parse().unwrap();
diff --git a/src/ecaps2.rs b/src/ecaps2.rs
index 6e71040d51c86afc85f50b3d511f4ddfc2241118..d4811b5cc917d1ba59081a25d4dfd218dda80f57 100644
--- a/src/ecaps2.rs
+++ b/src/ecaps2.rs
@@ -152,6 +152,11 @@ mod tests {
     use minidom::Element;
     use error::Error;
 
+    #[test]
+    fn test_size() {
+        assert_size!(ECaps2, 24);
+    }
+
     #[test]
     fn test_parse() {
         let elem: Element = "<c xmlns='urn:xmpp:caps'><hash xmlns='urn:xmpp:hashes:2' algo='sha-256'>K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4=</hash><hash xmlns='urn:xmpp:hashes:2' algo='sha3-256'>+sDTQqBmX6iG/X3zjt06fjZMBBqL/723knFIyRf0sg8=</hash></c>".parse().unwrap();
diff --git a/src/eme.rs b/src/eme.rs
index 51eb2a6d3483135fe0977a26e597a695a3e1e12f..271b842e38ae0e24b41727660cb1b689844296fe 100644
--- a/src/eme.rs
+++ b/src/eme.rs
@@ -28,6 +28,11 @@ mod tests {
     use minidom::Element;
     use error::Error;
 
+    #[test]
+    fn test_size() {
+        assert_size!(ExplicitMessageEncryption, 48);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<encryption xmlns='urn:xmpp:eme:0' namespace='urn:xmpp:otr:0'/>".parse().unwrap();
diff --git a/src/forwarding.rs b/src/forwarding.rs
index b65b450367bf195ed29ce2135fc7f62088792812..fbfacb11ec2caaabc3a7afe5b9579598cedab932 100644
--- a/src/forwarding.rs
+++ b/src/forwarding.rs
@@ -30,6 +30,11 @@ mod tests {
     use minidom::Element;
     use error::Error;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Forwarded, 392);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<forwarded xmlns='urn:xmpp:forward:0'/>".parse().unwrap();
diff --git a/src/hashes.rs b/src/hashes.rs
index bf7fafbd797d6b2e5b991cecdc335c2ccd430d5c..7063dbc66ff754e8716b974329564581cd29c5e3 100644
--- a/src/hashes.rs
+++ b/src/hashes.rs
@@ -133,6 +133,12 @@ mod tests {
     use try_from::TryFrom;
     use minidom::Element;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Algo, 32);
+        assert_size!(Hash, 56);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<hash xmlns='urn:xmpp:hashes:2' algo='sha-256'>2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU=</hash>".parse().unwrap();
diff --git a/src/ibb.rs b/src/ibb.rs
index bede2f0b8ba148a57524621f775ca04370e5665b..e595fe4ab6a7709bd0b4d48ba8a82bc22e511e2c 100644
--- a/src/ibb.rs
+++ b/src/ibb.rs
@@ -76,6 +76,14 @@ mod tests {
     use error::Error;
     use std::error::Error as StdError;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Stanza, 1);
+        assert_size!(Open, 32);
+        assert_size!(Data, 56);
+        assert_size!(Close, 24);
+    }
+
     #[test]
     fn test_simple() {
         let sid = StreamId(String::from("coucou"));
diff --git a/src/ibr.rs b/src/ibr.rs
index 72324deeec3d7dbe86d7cdce05595a6a3ba29325..71256b642a0de42366eb438d15827e25df6be909 100644
--- a/src/ibr.rs
+++ b/src/ibr.rs
@@ -96,6 +96,11 @@ mod tests {
     use super::*;
     use compare_elements::NamespaceAwareCompare;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Query, 152);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<query xmlns='jabber:iq:register'/>".parse().unwrap();
diff --git a/src/idle.rs b/src/idle.rs
index 2704654735b03784db8855fa558a4f7aa9e548e6..45352a229a58509a5ed7e6a04d90bf458a9a04f0 100644
--- a/src/idle.rs
+++ b/src/idle.rs
@@ -27,6 +27,11 @@ mod tests {
     use std::str::FromStr;
     use std::error::Error as StdError;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Idle, 16);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<idle xmlns='urn:xmpp:idle:1' since='2017-05-21T20:19:55+01:00'/>".parse().unwrap();
diff --git a/src/iq.rs b/src/iq.rs
index aeeb836cc112ef5904d0196a911fc362038046b3..b5f27bf06a545720576a160abaa9f71e349f6c4f 100644
--- a/src/iq.rs
+++ b/src/iq.rs
@@ -226,6 +226,12 @@ mod tests {
     use compare_elements::NamespaceAwareCompare;
     use disco::DiscoInfoQuery;
 
+    #[test]
+    fn test_size() {
+        assert_size!(IqType, 216);
+        assert_size!(Iq, 384);
+    }
+
     #[test]
     fn test_require_type() {
         #[cfg(not(feature = "component"))]
diff --git a/src/jingle.rs b/src/jingle.rs
index 3102b1052abc3c3287f4713e4310cb9f83f3ba34..38577f8415e86fc9fe1591a1a97eb91119e9fc10 100644
--- a/src/jingle.rs
+++ b/src/jingle.rs
@@ -533,6 +533,20 @@ impl From<Jingle> for Element {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Action, 1);
+        assert_size!(Creator, 1);
+        assert_size!(Senders, 1);
+        assert_size!(Disposition, 1);
+        assert_size!(ContentId, 24);
+        assert_size!(Content, 344);
+        assert_size!(Reason, 1);
+        assert_size!(ReasonElement, 32);
+        assert_size!(SessionId, 24);
+        assert_size!(Jingle, 256);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'/>".parse().unwrap();
diff --git a/src/jingle_ft.rs b/src/jingle_ft.rs
index e206ab3c55c8f29b2507dee502cebdcd86dfbb68..0a3c022a1ab6518e459d17e9be26f73ab9bc754e 100644
--- a/src/jingle_ft.rs
+++ b/src/jingle_ft.rs
@@ -348,6 +348,15 @@ mod tests {
     use hashes::Algo;
     use base64;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Range, 48);
+        assert_size!(File, 184);
+        assert_size!(Description, 184);
+        assert_size!(Checksum, 216);
+        assert_size!(Received, 32);
+    }
+
     #[test]
     fn test_description() {
         let elem: Element = r#"
diff --git a/src/jingle_ibb.rs b/src/jingle_ibb.rs
index 7438133c56681055a5d52236bb01fe7564324afd..c56c73d490a3907512b668e29a52f2af1477ff7b 100644
--- a/src/jingle_ibb.rs
+++ b/src/jingle_ibb.rs
@@ -29,6 +29,11 @@ mod tests {
     use error::Error;
     use std::error::Error as StdError;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Transport, 32);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1' block-size='3' sid='coucou'/>".parse().unwrap();
diff --git a/src/jingle_message.rs b/src/jingle_message.rs
index d8e30382f61871c1bc00b33e5aa0f5ec32560888..150e7a03134367da32a384d78827147921a1e52c 100644
--- a/src/jingle_message.rs
+++ b/src/jingle_message.rs
@@ -121,6 +121,11 @@ impl From<JingleMI> for Element {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_size() {
+        assert_size!(JingleMI, 136);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<accept xmlns='urn:xmpp:jingle-message:0' id='coucou'/>".parse().unwrap();
diff --git a/src/jingle_s5b.rs b/src/jingle_s5b.rs
index f6f05be3416394f0e50d0fc4a8d23c0f48c466b9..a5fdff0deb3b63dad66b32a5b6727344819c7a1b 100644
--- a/src/jingle_s5b.rs
+++ b/src/jingle_s5b.rs
@@ -277,6 +277,17 @@ mod tests {
     use std::str::FromStr;
     use compare_elements::NamespaceAwareCompare;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Type, 1);
+        assert_size!(Mode, 1);
+        assert_size!(CandidateId, 24);
+        assert_size!(StreamId, 24);
+        assert_size!(Candidate, 128);
+        assert_size!(TransportPayload, 32);
+        assert_size!(Transport, 88);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:s5b:1' sid='coucou'/>".parse().unwrap();
diff --git a/src/macros.rs b/src/macros.rs
index 5793fef04ee05c21a427cef9dc101fa621546e01..3deade1d361315e1d3692e5e13a87947798b565d 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -510,3 +510,9 @@ macro_rules! generate_element {
         }
     );
 }
+
+macro_rules! assert_size (
+    ($t:ty, $sz:expr) => (
+        assert_eq!(::std::mem::size_of::<$t>(), $sz);
+    );
+);
diff --git a/src/mam.rs b/src/mam.rs
index 11850a29177e557c2a00d5c0c6ca11bdf237cb8b..44564120a727b058a6f58740ecda9e3dbb612ae0 100644
--- a/src/mam.rs
+++ b/src/mam.rs
@@ -191,6 +191,17 @@ mod tests {
     use super::*;
     use std::str::FromStr;
 
+    #[test]
+    fn test_size() {
+        assert_size!(QueryId, 24);
+        assert_size!(Query, 232);
+        assert_size!(Result_, 440);
+        assert_size!(Complete, 1);
+        assert_size!(Fin, 88);
+        assert_size!(DefaultPrefs, 1);
+        assert_size!(Prefs, 56);
+    }
+
     #[test]
     fn test_query() {
         let elem: Element = "<query xmlns='urn:xmpp:mam:2'/>".parse().unwrap();
diff --git a/src/media_element.rs b/src/media_element.rs
index 7ad264b2251d6c184c380893275081a062a27c1b..722780f2f03ceb12fb0b8dcaa96e9eee362cdb86 100644
--- a/src/media_element.rs
+++ b/src/media_element.rs
@@ -51,6 +51,12 @@ mod tests {
     use data_forms::DataForm;
     use std::error::Error as StdError;
 
+    #[test]
+    fn test_size() {
+        assert_size!(URI, 48);
+        assert_size!(MediaElement, 56);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<media xmlns='urn:xmpp:media-element'/>".parse().unwrap();
diff --git a/src/message.rs b/src/message.rs
index 7506a3fa513b612b3afdddbf8b010dd48078fa02..2e9d9c659d9509cfc5da8e71400e82bdf1a12905 100644
--- a/src/message.rs
+++ b/src/message.rs
@@ -234,6 +234,15 @@ mod tests {
     use std::str::FromStr;
     use compare_elements::NamespaceAwareCompare;
 
+    #[test]
+    fn test_size() {
+        assert_size!(MessageType, 1);
+        assert_size!(Body, 24);
+        assert_size!(Subject, 24);
+        assert_size!(Thread, 24);
+        assert_size!(Message, 272);
+    }
+
     #[test]
     fn test_simple() {
         #[cfg(not(feature = "component"))]
diff --git a/src/message_correct.rs b/src/message_correct.rs
index 04834518d8cb01f37ed43a8bcc014d0e82408888..e8233ee632d6b5295e1c180d1e14aff328958e54 100644
--- a/src/message_correct.rs
+++ b/src/message_correct.rs
@@ -25,6 +25,11 @@ mod tests {
     use minidom::Element;
     use error::Error;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Replace, 24);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0' id='coucou'/>".parse().unwrap();
diff --git a/src/mood.rs b/src/mood.rs
index 8612a42c18caa9511169b73c89ed5d831eaacc9b..6bf8bd2383cf1fce59068131b62872132cd3a205 100644
--- a/src/mood.rs
+++ b/src/mood.rs
@@ -272,6 +272,12 @@ mod tests {
     use try_from::TryFrom;
     use minidom::Element;
 
+    #[test]
+    fn test_size() {
+        assert_size!(MoodEnum, 1);
+        assert_size!(Text, 24);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<happy xmlns='http://jabber.org/protocol/mood'/>".parse().unwrap();
diff --git a/src/nick.rs b/src/nick.rs
index 9844e9318c8670319e3f032e9717c10d9ffbfade..2d2f90c4c7d212d491c244e4b5aa97a8c752d0e4 100644
--- a/src/nick.rs
+++ b/src/nick.rs
@@ -16,6 +16,11 @@ mod tests {
     use minidom::Element;
     use error::Error;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Nick, 24);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<nick xmlns='http://jabber.org/protocol/nick'>Link Mauve</nick>".parse().unwrap();
diff --git a/src/ping.rs b/src/ping.rs
index 0af81c0da3f2b06cd4a0e68be9c9a7b63820c4c7..557f535a7038ab4417cefed415e5ad22b9c7e7dd 100644
--- a/src/ping.rs
+++ b/src/ping.rs
@@ -22,6 +22,11 @@ mod tests {
     use minidom::Element;
     use error::Error;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Ping, 0);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<ping xmlns='urn:xmpp:ping'/>".parse().unwrap();
diff --git a/src/presence.rs b/src/presence.rs
index 8bde17801226156970b6065ebdb4f546632412d3..02a9a9c7c890c95e6dad4173f70a3fb378c42901 100644
--- a/src/presence.rs
+++ b/src/presence.rs
@@ -323,6 +323,13 @@ mod tests {
     use super::*;
     use compare_elements::NamespaceAwareCompare;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Show, 1);
+        assert_size!(Type, 1);
+        assert_size!(Presence, 224);
+    }
+
     #[test]
     fn test_simple() {
         #[cfg(not(feature = "component"))]
diff --git a/src/receipts.rs b/src/receipts.rs
index 898a5dd65cc351801f9c828d90f8764c2b1f291f..ecf0a21cabe54828889a5dcfba0e002f8765486a 100644
--- a/src/receipts.rs
+++ b/src/receipts.rs
@@ -33,6 +33,12 @@ mod tests {
     use minidom::Element;
     use ns;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Request, 0);
+        assert_size!(Received, 24);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<request xmlns='urn:xmpp:receipts'/>".parse().unwrap();
diff --git a/src/roster.rs b/src/roster.rs
index 0bb743932007edd30a7881c3123d323c388f040d..eeebddf80cf192dc77db449c23567241c7affca4 100644
--- a/src/roster.rs
+++ b/src/roster.rs
@@ -85,6 +85,14 @@ mod tests {
     use std::str::FromStr;
     use compare_elements::NamespaceAwareCompare;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Group, 24);
+        assert_size!(Subscription, 1);
+        assert_size!(Item, 128);
+        assert_size!(Roster, 48);
+    }
+
     #[test]
     fn test_get() {
         let elem: Element = "<query xmlns='jabber:iq:roster'/>".parse().unwrap();
diff --git a/src/rsm.rs b/src/rsm.rs
index d16751a1f6890e910d74edd25072e87bb18d6369..2f176932430ff022cc9136282b1b4f5fc2852987 100644
--- a/src/rsm.rs
+++ b/src/rsm.rs
@@ -158,6 +158,12 @@ mod tests {
     use super::*;
     use compare_elements::NamespaceAwareCompare;
 
+    #[test]
+    fn test_size() {
+        assert_size!(SetQuery, 80);
+        assert_size!(SetResult, 80);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'/>".parse().unwrap();
diff --git a/src/sasl.rs b/src/sasl.rs
index f27167b1fdaaff082b22af98f3ecad9a8318c17d..5272fd0d315b786196877e542ee3d9a7de809551 100644
--- a/src/sasl.rs
+++ b/src/sasl.rs
@@ -215,6 +215,18 @@ mod tests {
     use try_from::TryFrom;
     use minidom::Element;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Mechanism, 1);
+        assert_size!(Auth, 32);
+        assert_size!(Challenge, 24);
+        assert_size!(Response, 24);
+        assert_size!(Abort, 0);
+        assert_size!(Success, 24);
+        assert_size!(DefinedCondition, 1);
+        assert_size!(Failure, 32);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<auth xmlns='urn:ietf:params:xml:ns:xmpp-sasl' mechanism='PLAIN'/>".parse().unwrap();
diff --git a/src/sm.rs b/src/sm.rs
index e93aa24f189115dea05edee7ff5a573df6075416..dfc3dff204493cb77f5b2339aa441396098dd06b 100644
--- a/src/sm.rs
+++ b/src/sm.rs
@@ -144,6 +144,20 @@ mod tests {
     use try_from::TryFrom;
     use minidom::Element;
 
+    #[test]
+    fn test_size() {
+        assert_size!(A, 4);
+        assert_size!(ResumeAttr, 1);
+        assert_size!(Enable, 12);
+        assert_size!(StreamId, 24);
+        assert_size!(Enabled, 64);
+        assert_size!(Failed, 12);
+        assert_size!(R, 0);
+        assert_size!(Resume, 32);
+        assert_size!(Resumed, 32);
+        assert_size!(StreamManagement, 0);
+    }
+
     #[test]
     fn a() {
         let elem: Element = "<a xmlns='urn:xmpp:sm:3' h='5'".parse().unwrap();
diff --git a/src/stanza_error.rs b/src/stanza_error.rs
index 37e71be0209127d278183f57cd60cfb8d45cdac0..480b1d8092c40d8c3b6442a4c573efaa3318e662 100644
--- a/src/stanza_error.rs
+++ b/src/stanza_error.rs
@@ -289,6 +289,13 @@ impl From<StanzaError> for Element {
 mod tests {
     use super::*;
 
+    #[test]
+    fn test_size() {
+        assert_size!(ErrorType, 1);
+        assert_size!(DefinedCondition, 1);
+        assert_size!(StanzaError, 208);
+    }
+
     #[test]
     fn test_simple() {
         #[cfg(not(feature = "component"))]
diff --git a/src/stanza_id.rs b/src/stanza_id.rs
index 07e947a3e403e1fba0cc2130e4e1755d1f9fc860..9dc3698a6c64896a3cb88074ca98b88ed5228ea8 100644
--- a/src/stanza_id.rs
+++ b/src/stanza_id.rs
@@ -42,6 +42,12 @@ mod tests {
     use error::Error;
     use std::str::FromStr;
 
+    #[test]
+    fn test_size() {
+        assert_size!(StanzaId, 96);
+        assert_size!(OriginId, 24);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<stanza-id xmlns='urn:xmpp:sid:0' id='coucou' by='coucou@coucou'/>".parse().unwrap();
diff --git a/src/stream.rs b/src/stream.rs
index 693796dcb2022f23a4c7328339c1aeb3a87229d9..b81ba7710208e552c94e66af77125e7bb286063c 100644
--- a/src/stream.rs
+++ b/src/stream.rs
@@ -76,6 +76,11 @@ mod tests {
     use try_from::TryFrom;
     use minidom::Element;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Stream, 216);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' xml:lang='en' version='1.0' id='abc' from='some-server.example'/>".parse().unwrap();
diff --git a/src/version.rs b/src/version.rs
index 4354df50d282cf7a14a365f201f6a6972e5647b1..7ed89743bf4bf35a4e6346728ebfa74658474e1b 100644
--- a/src/version.rs
+++ b/src/version.rs
@@ -43,6 +43,12 @@ mod tests {
     use minidom::Element;
     use compare_elements::NamespaceAwareCompare;
 
+    #[test]
+    fn test_size() {
+        assert_size!(VersionQuery, 0);
+        assert_size!(VersionResult, 72);
+    }
+
     #[test]
     fn simple() {
         let elem: Element = "<query xmlns='jabber:iq:version'><name>xmpp-rs</name><version>0.3.0</version></query>".parse().unwrap();
diff --git a/src/websocket.rs b/src/websocket.rs
index 102690cde582f37a5d8a06e329369fa36343c91b..2f87437b1c1a3074db3919b454d0a64cd8f5137f 100644
--- a/src/websocket.rs
+++ b/src/websocket.rs
@@ -75,6 +75,11 @@ mod tests {
     use try_from::TryFrom;
     use minidom::Element;
 
+    #[test]
+    fn test_size() {
+        assert_size!(Open, 216);
+    }
+
     #[test]
     fn test_simple() {
         let elem: Element = "<open xmlns='urn:ietf:params:xml:ns:xmpp-framing'/>".parse().unwrap();