diff --git a/serde_amqp/benches/serialize.rs b/serde_amqp/benches/serialize.rs
index fa36f969..2df4538a 100644
--- a/serde_amqp/benches/serialize.rs
+++ b/serde_amqp/benches/serialize.rs
@@ -177,10 +177,6 @@ fn criterion_benchmark(c: &mut Criterion) {
         b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
     });
 
-    // Symbol is very similar to String, so we don't benchmark it.
-
-    // TODO: How to bench list, map, and array? Define number of items or bytes?
-
     // 16 bytes of u64
     let mut value = vec![0u64; 16 / std::mem::size_of::<u64>()];
     rand::thread_rng().fill(&mut value[..]);
@@ -286,6 +282,168 @@ fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("serialize List<String> 10x1MB", |b| {
         b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
     });
+
+    // 10 Random strings of size between 16B and 1kB
+    let value = (0..10)
+        .map(|_| {
+            let size = rand::thread_rng().gen_range(16..1024);
+            Alphanumeric.sample_string(&mut rand::thread_rng(), size)
+        })
+        .map(String::from)
+        .collect::<Vec<_>>();
+    c.bench_function("serialize List<String> 10x16B-10kB", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
+
+    // 100 Random strings of size between 16B and 1kB
+    let value = (0..100)
+        .map(|_| {
+            let size = rand::thread_rng().gen_range(16..1024);
+            Alphanumeric.sample_string(&mut rand::thread_rng(), size)
+        })
+        .map(String::from)
+        .collect::<Vec<_>>();
+    c.bench_function("serialize List<String> 100x16B-10kB", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
+
+    // 1000 Random strings of size between 16B and 1kB
+    let value = (0..1000)
+        .map(|_| {
+            let size = rand::thread_rng().gen_range(16..1024);
+            Alphanumeric.sample_string(&mut rand::thread_rng(), size)
+        })
+        .map(String::from)
+        .collect::<Vec<_>>();
+    c.bench_function("serialize List<String> 1000x16B-10kB", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
+
+    // Map of 10 u64 -> u64
+    let value = (0..10)
+        .map(|_| {
+            let key = rand::random::<u64>();
+            let value = rand::random::<u64>();
+            (key, value)
+        })
+        .collect::<std::collections::HashMap<_, _>>();
+    c.bench_function("serialize Map<u64, u64> 10", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
+
+    // Map of 100 u64 -> u64
+    let value = (0..100)
+        .map(|_| {
+            let key = rand::random::<u64>();
+            let value = rand::random::<u64>();
+            (key, value)
+        })
+        .collect::<std::collections::HashMap<_, _>>();
+    c.bench_function("serialize Map<u64, u64> 100", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
+
+    // Map of 1000 u64 -> u64
+    let value = (0..1000)
+        .map(|_| {
+            let key = rand::random::<u64>();
+            let value = rand::random::<u64>();
+            (key, value)
+        })
+        .collect::<std::collections::HashMap<_, _>>();
+    c.bench_function("serialize Map<u64, u64> 1000", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
+
+    // Map of 10 16B String -> 16B String
+    let value = (0..10)
+        .map(|_| {
+            let key = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
+            let key = String::from(key);
+            let value = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
+            let value = String::from(value);
+            (key, value)
+        })
+        .collect::<std::collections::HashMap<_, _>>();
+    c.bench_function("serialize Map<String, String> 10x16B", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
+
+    // Map of 100 16B String -> 16B String
+    let value = (0..100)
+        .map(|_| {
+            let key = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
+            let key = String::from(key);
+            let value = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
+            let value = String::from(value);
+            (key, value)
+        })
+        .collect::<std::collections::HashMap<_, _>>();
+    c.bench_function("serialize Map<String, String> 100x16B", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
+
+    // Map of 1000 16B String -> 16B String
+    let value = (0..1000)
+        .map(|_| {
+            let key = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
+            let key = String::from(key);
+            let value = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
+            let value = String::from(value);
+            (key, value)
+        })
+        .collect::<std::collections::HashMap<_, _>>();
+    c.bench_function("serialize Map<String, String> 1000x16B", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
+
+    // Map of 10 random String (16B-1kB) -> random String (16B-1kB)
+    let value = (0..10)
+        .map(|_| {
+            let key_size = rand::thread_rng().gen_range(16..1024);
+            let key = Alphanumeric.sample_string(&mut rand::thread_rng(), key_size);
+            let key = String::from(key);
+            let value_size = rand::thread_rng().gen_range(16..1024);
+            let value = Alphanumeric.sample_string(&mut rand::thread_rng(), value_size);
+            let value = String::from(value);
+            (key, value)
+        })
+        .collect::<std::collections::HashMap<_, _>>();
+    c.bench_function("serialize Map<String, String> 10x16B-1kB", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
+
+    // Map of 100 random String (16B-1kB) -> random String (16B-1kB)
+    let value = (0..100)
+        .map(|_| {
+            let key_size = rand::thread_rng().gen_range(16..1024);
+            let key = Alphanumeric.sample_string(&mut rand::thread_rng(), key_size);
+            let key = String::from(key);
+            let value_size = rand::thread_rng().gen_range(16..1024);
+            let value = Alphanumeric.sample_string(&mut rand::thread_rng(), value_size);
+            let value = String::from(value);
+            (key, value)
+        })
+        .collect::<std::collections::HashMap<_, _>>();
+    c.bench_function("serialize Map<String, String> 100x16B-1kB", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
+
+    // Map of 1000 random String (16B-1kB) -> random String (16B-1kB)
+    let value = (0..1000)
+        .map(|_| {
+            let key_size = rand::thread_rng().gen_range(16..1024);
+            let key = Alphanumeric.sample_string(&mut rand::thread_rng(), key_size);
+            let key = String::from(key);
+            let value_size = rand::thread_rng().gen_range(16..1024);
+            let value = Alphanumeric.sample_string(&mut rand::thread_rng(), value_size);
+            let value = String::from(value);
+            (key, value)
+        })
+        .collect::<std::collections::HashMap<_, _>>();
+    c.bench_function("serialize Map<String, String> 1000x16B-1kB", |b| {
+        b.iter(|| serde_amqp::to_vec(black_box(&value)).unwrap())
+    });
 }
 
 criterion_group!(benches, criterion_benchmark);