Test reading from memory maps

src/mmap_blob.rs

@@ -4,7 +4,7 @@ extern crate protobuf;
 extern crate byteorder;
 extern crate memmap;
 
-use blob::{BlobDecode, decode_blob};
+use blob::{BlobDecode, BlobType, decode_blob};
 use byteorder::ByteOrder;
 use errors::*;
 use block::{HeaderBlock, PrimitiveBlock};
@@ -98,6 +98,15 @@ impl<'a> MmapBlob<'a> {
             x => Ok(BlobDecode::Unknown(x)),
         }
     }
+
+    /// Returns the type of a blob without decoding its content.
+    pub fn get_type(&self) -> BlobType {
+        match self.header.get_field_type() {
+            "OSMHeader" => BlobType::OsmHeader,
+            "OSMData" => BlobType::OsmData,
+            x => BlobType::Unknown(x),
+        }
+    }
 }
 
 /// A reader for memory mapped PBF files that allows iterating over `MmapBlob`s.

tests/read.rs

@@ -62,3 +62,60 @@ fn read() {
         }
     }
 }
+
+#[test]
+fn mmap_read() {
+    let mmap = unsafe { Mmap::from_path(TEST_FILE_PATH).unwrap() };
+    let reader = MmapBlobReader::new(&mmap);
+
+    let blobs = reader.collect::<Result<Vec<_>>>().unwrap();
+
+    assert_eq!(blobs.len(), 2);
+
+    assert_eq!(blobs[0].get_type(), BlobType::OsmHeader);
+    assert_eq!(blobs[1].get_type(), BlobType::OsmData);
+
+    if let BlobDecode::OsmHeader(header) = blobs[0].decode().unwrap() {
+        assert!(header.required_features().contains(&String::from("OsmSchema-V0.6")));
+        assert!(header.required_features().contains(&String::from("DenseNodes")));
+    } else {
+        panic!("Unexpected blob type");
+    }
+
+    if let BlobDecode::OsmData(primitive_block) = blobs[1].decode().unwrap() {
+        let nodes = primitive_block.groups().flat_map(|g| g.nodes()).count();
+        assert_eq!(nodes, 0);
+
+        {
+            let dense_nodes: Vec<_> = primitive_block.groups().flat_map(|g| g.dense_nodes()).collect();
+            assert_eq!(dense_nodes.len(), 3);
+
+            assert!(approx_eq(dense_nodes[1].lat(), 52.11992359584));
+            assert!(approx_eq(dense_nodes[1].lon(), 11.62564468943));
+
+            assert!(approx_eq(dense_nodes[2].lat(), 52.11989910567));
+            assert!(approx_eq(dense_nodes[2].lon(), 11.63101926915));
+
+            assert_eq!(dense_nodes[0].id, 105);
+            assert_eq!(dense_nodes[1].id, 106);
+            assert_eq!(dense_nodes[2].id, 108);
+
+            assert_eq!(dense_nodes[0].uid, 17);
+            assert_eq!(dense_nodes[1].uid, 17);
+            assert_eq!(dense_nodes[2].uid, 17);
+        }
+
+        {
+            let ways: Vec<_> = primitive_block.groups().flat_map(|g| g.ways()).collect();
+            assert_eq!(ways.len(), 1);
+
+            let way_tags = ways[0].tags().collect::<Vec<_>>();
+            assert_eq!(way_tags.len(), 2);
+
+            assert!(way_tags.contains(&("building", "yes")));
+            assert!(way_tags.contains(&("name", "triangle")));
+        }
+    } else {
+        panic!("Unexpected blob type");
+    }
+}