diff --git a/serde_test/src/token.rs b/serde_test/src/token.rs
index 5e9cead0..a9d01a33 100644
--- a/serde_test/src/token.rs
+++ b/serde_test/src/token.rs
@@ -54,11 +54,13 @@ pub enum Token {
     /// A serialized `ByteBuf`
     ByteBuf(&'static [u8]),
 
-    /// The header to a serialized `Option<T>`.
+    /// The header to a serialized `Option<T>` containing some value.
     ///
-    /// `None` is serialized as `Option(false)`, while `Some` is serialized as `Option(true)`, then
-    /// the value contained in the option.
-    Option(bool),
+    /// The tokens of the value follow after this header.
+    Some,
+
+    /// A serialized `Option<T>` containing none.
+    None,
 
     /// A serialized `()`.
     Unit,
@@ -70,52 +72,46 @@ pub enum Token {
     ///
     /// Newtype structs are serialized with this header, followed by the value contained in the
     /// newtype struct.
-    StructNewType(&'static str),
+    NewtypeStruct(&'static str),
 
     /// The header to an enum of the given name.
-    ///
-    /// This token is only used for deserializers, and ensures that the following tokens are read as
-    /// an enum. Because this is never emitted by serializers, calling `assert_ser_tokens` or
-    /// `assert_tokens` will fail if this token is used.
-    ///
-    /// TODO: Trash this.
-    EnumStart(&'static str),
+    Enum(&'static str),
 
     /// A unit variant of an enum of the given name, of the given name.
     ///
     /// The first string represents the name of the enum, and the second represents the name of the
     /// variant.
-    EnumUnit(&'static str, &'static str),
+    UnitVariant(&'static str, &'static str),
 
     /// The header to a newtype variant of an enum of the given name, of the given name.
     ///
     /// The first string represents the name of the enum, and the second represents the name of the
     /// variant. The value contained within this enum works the same as `StructNewType`.
-    EnumNewType(&'static str, &'static str),
+    NewtypeVariant(&'static str, &'static str),
 
     /// The header to a sequence of the given length.
     ///
     /// These are serialized via `serialize_seq`, which takes an optional length. After this
     /// header is a list of elements, followed by `SeqEnd`.
-    SeqStart(Option<usize>),
+    Seq(Option<usize>),
 
     /// The header to an array of the given length.
     ///
     /// These are serialized via `serialize_seq_fized_size`, which requires a length. After this
     /// header is a list of elements, followed by `SeqEnd`.
-    SeqArrayStart(usize),
+    SeqFixedSize(usize),
 
     /// An indicator of the end of a sequence.
     SeqEnd,
 
-    /// The header to a tuple of the given length, similar to `SeqArrayStart`.
-    TupleStart(usize),
+    /// The header to a tuple of the given length, similar to `SeqFixedSize`.
+    Tuple(usize),
 
     /// An indicator of the end of a tuple, similar to `SeqEnd`.
     TupleEnd,
 
     /// The header to a tuple struct of the given name and length.
-    TupleStructStart(&'static str, usize),
+    TupleStruct(&'static str, usize),
 
     /// An indicator of the end of a tuple struct, similar to `TupleEnd`.
     TupleStructEnd,
@@ -124,27 +120,27 @@ pub enum Token {
     ///
     /// These are serialized via `serialize_map`, which takes an optional length. After this header
     /// is a list of key-value pairs, followed by `MapEnd`.
-    MapStart(Option<usize>),
+    Map(Option<usize>),
 
     /// An indicator of the end of a map.
     MapEnd,
 
-    /// The header of a struct of the given name and length, similar to `MapStart`.
-    StructStart(&'static str, usize),
+    /// The header of a struct of the given name and length, similar to `Map`.
+    Struct(&'static str, usize),
 
     /// An indicator of the end of a struct, similar to `MapEnd`.
     StructEnd,
 
     /// The header to a tuple variant of an enum of the given name, of the given name and length.
-    EnumSeqStart(&'static str, &'static str, usize),
+    TupleVariant(&'static str, &'static str, usize),
 
     /// An indicator of the end of a tuple variant, similar to `TupleEnd`.
-    EnumSeqEnd,
+    TupleVariantEnd,
 
     /// The header of a struct variant of an enum of the given name, of the given name and length,
-    /// similar to `StructStart`.
-    EnumMapStart(&'static str, &'static str, usize),
+    /// similar to `Struct`.
+    StructVariant(&'static str, &'static str, usize),
 
     /// An indicator of the end of a struct, similar to `StructEnd`.
-    EnumMapEnd,
+    StructVariantEnd,
 }