Actually run code in doc tests

src/blob.rs

     ///
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn new(reader: R) -> BlobReader<R> {
         BlobReader {
     /// let reader = BlobReader::from_path("tests/test.osm.pbf")?;
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self>
     {
     /// let mut reader = BlobReader::new_seekable(buf_reader)?;
     /// let first_blob = reader.next().unwrap()?;
     ///
-    /// assert_eq!(first_blob.offset(), Some(ByteOffset(1)));
+    /// assert_eq!(first_blob.offset(), Some(ByteOffset(0)));
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn new_seekable(mut reader: R) -> Result<BlobReader<R>> {
         let pos = reader.seek(SeekFrom::Current(0))?;
     /// assert_eq!(first_blob.offset(), first_blob_again.offset());
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn seek(&mut self, pos: ByteOffset) -> Result<()> {
         match self.reader.seek(SeekFrom::Start(pos.0)) {

src/elements.rs

     ///
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn tags(&self) -> TagIter<'a> {
         TagIter {
     ///
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn tags(&self) -> TagIter<'a> {
         TagIter {
     ///
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn tags(&self) -> TagIter<'a> {
         TagIter {

src/mmap_blob.rs

     /// let mmap = unsafe { Mmap::from_file(&f)? };
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub unsafe fn from_file(file: &File) -> Result<Mmap> {
         memmap::Mmap::map(file)
     /// let mmap = unsafe { Mmap::from_path("tests/test.osm.pbf")? };
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub unsafe fn from_path<P: AsRef<Path>>(path: P) -> Result<Mmap> {
         let file = File::open(&path)?;
     ///
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn new(mmap: &Mmap) -> MmapBlobReader {
         MmapBlobReader {
     ///
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn seek(&mut self, pos: ByteOffset) {
         self.offset = pos.0 as usize;

src/reader.rs

     ///
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn new(reader: R) -> ElementReader<R> {
         ElementReader {
     ///
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn for_each<F>(self, mut f: F) -> Result<()>
         where F: for<'a> FnMut(Element<'a>) {
     /// println!("Number of ways: {}", ways);
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn par_map_reduce<MP, RD, ID, T>(self, map_op: MP, identity: ID, reduce_op: RD) -> Result<T>
         where MP: for<'a> Fn(Element<'a>) -> T + Sync + Send,
     /// let reader = ElementReader::from_path("tests/test.osm.pbf")?;
     /// # Ok(())
     /// # }
+    /// # foo().unwrap();
     /// ```
     pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self>
     {