diff --git a/tests/rust_usage_test/Cargo.toml b/tests/rust_usage_test/Cargo.toml
index 664396d..e676970 100644
--- a/tests/rust_usage_test/Cargo.toml
+++ b/tests/rust_usage_test/Cargo.toml
@@ -6,11 +6,16 @@
            "FlatBuffers Maintainers"]
 
 [dependencies]
-flatbuffers = { path = "../../rust/flatbuffers" }
+flatbuffers = { path = "../../rust/flatbuffers", default-features = false }
 flexbuffers = { path = "../../rust/flexbuffers" }
 serde_derive = "1.0"
 serde = "1.0"
 serde_bytes = "0.11"
+libc_alloc = { version = "1.0.3", optional = true }
+
+[features]
+default = ["flatbuffers/default"]
+no_std = ["flatbuffers/no_std", "libc_alloc"]
 
 [[bin]]
 name = "monster_example"
@@ -36,14 +41,15 @@
 name = "sample_flatbuffers"
 path = "../../samples/sample_binary.rs"
 
-
 [dev-dependencies]
 quickcheck = "0.6"
 # TODO(rw): look into moving to criterion.rs
+serde = "1.0"
 bencher = "0.1.5"
 static_assertions = "1.0.0"
 rand = "*"
 quickcheck_derive = "*"
+array-init = "2.0"
 
 [[bench]]
 # setup for bencher
diff --git a/tests/rust_usage_test/benches/benchmarks.rs b/tests/rust_usage_test/benches/benchmarks.rs
index bfe63b6..51fae75 100644
--- a/tests/rust_usage_test/benches/benchmarks.rs
+++ b/tests/rust_usage_test/benches/benchmarks.rs
@@ -23,15 +23,7 @@
 mod flexbuffers_benchmarks;
 
 #[allow(dead_code, unused_imports)]
-#[path = "../../include_test/include_test1_generated.rs"]
-pub mod include_test1_generated;
-
-#[allow(dead_code, unused_imports)]
-#[path = "../../include_test/sub/include_test2_generated.rs"]
-pub mod include_test2_generated;
-
-#[allow(dead_code, unused_imports)]
-#[path = "../../monster_test_generated.rs"]
+#[path = "../../monster_test/mod.rs"]
 mod monster_test_generated;
 pub use monster_test_generated::my_game;
 
diff --git a/tests/rust_usage_test/benches/flatbuffers_benchmarks.rs b/tests/rust_usage_test/benches/flatbuffers_benchmarks.rs
index ee6d81d..580d433 100644
--- a/tests/rust_usage_test/benches/flatbuffers_benchmarks.rs
+++ b/tests/rust_usage_test/benches/flatbuffers_benchmarks.rs
@@ -14,18 +14,12 @@
  * limitations under the License.
  */
 
+use flatbuffers;
 use bencher::Bencher;
 
-#[allow(dead_code, unused_imports)]
-#[path = "../../include_test/include_test1_generated.rs"]
-pub mod include_test1_generated;
 
 #[allow(dead_code, unused_imports)]
-#[path = "../../include_test/sub/include_test2_generated.rs"]
-pub mod include_test2_generated;
-
-#[allow(dead_code, unused_imports)]
-#[path = "../../monster_test_generated.rs"]
+#[path = "../../monster_test/mod.rs"]
 mod monster_test_generated;
 pub use monster_test_generated::my_game;
 
@@ -148,7 +142,7 @@
 
 #[inline(always)]
 fn traverse_serialized_example_with_generated_code(bytes: &[u8]) {
-    let m = my_game::example::get_root_as_monster(bytes);
+    let m = unsafe { my_game::example::root_as_monster_unchecked(bytes) };
     blackbox(m.hp());
     blackbox(m.mana());
     blackbox(m.name());
@@ -178,7 +172,7 @@
 }
 
 fn create_string_10(bench: &mut Bencher) {
-    let builder = &mut flatbuffers::FlatBufferBuilder::new_with_capacity(1 << 20);
+    let builder = &mut flatbuffers::FlatBufferBuilder::with_capacity(1 << 20);
     let mut i = 0;
     bench.iter(|| {
         builder.create_string("foobarbaz"); // zero-terminated -> 10 bytes
@@ -193,7 +187,7 @@
 }
 
 fn create_string_100(bench: &mut Bencher) {
-    let builder = &mut flatbuffers::FlatBufferBuilder::new_with_capacity(1 << 20);
+    let builder = &mut flatbuffers::FlatBufferBuilder::with_capacity(1 << 20);
     let s_owned = (0..99).map(|_| "x").collect::<String>();
     let s: &str = &s_owned;
 
@@ -211,7 +205,7 @@
 }
 
 fn create_byte_vector_100_naive(bench: &mut Bencher) {
-    let builder = &mut flatbuffers::FlatBufferBuilder::new_with_capacity(1 << 20);
+    let builder = &mut flatbuffers::FlatBufferBuilder::with_capacity(1 << 20);
     let v_owned = (0u8..100).map(|i| i).collect::<Vec<u8>>();
     let v: &[u8] = &v_owned;
 
@@ -229,7 +223,7 @@
 }
 
 fn create_byte_vector_100_optimal(bench: &mut Bencher) {
-    let builder = &mut flatbuffers::FlatBufferBuilder::new_with_capacity(1 << 20);
+    let builder = &mut flatbuffers::FlatBufferBuilder::with_capacity(1 << 20);
     let v_owned = (0u8..100).map(|i| i).collect::<Vec<u8>>();
     let v: &[u8] = &v_owned;
 
@@ -246,6 +240,24 @@
     bench.bytes = v.len() as u64;
 }
 
+fn create_many_tables(bench: &mut Bencher) {
+    let builder = &mut flatbuffers::FlatBufferBuilder::with_capacity(1 << 20);
+    // We test vtable overhead by making many unique tables of up to 16 fields of u8s.
+    bench.iter(|| {
+        for i in 0..(1u16 << 10) {
+            let t = builder.start_table();
+            for j in 0..15 {
+                if i & (1 << j) == 1 {
+                    builder.push_slot_always(i * 2, 42u8);
+                }
+            }
+            builder.end_table(t);
+        }
+        builder.reset();
+    });
+    bench.bytes = 1 << 15;
+}
+
 benchmark_group!(
     benches,
     create_byte_vector_100_naive,
@@ -253,5 +265,6 @@
     traverse_canonical_buffer,
     create_canonical_buffer_then_reset,
     create_string_10,
-    create_string_100
+    create_string_100,
+    create_many_tables,
 );
diff --git a/tests/rust_usage_test/benches/flexbuffers_benchmarks.rs b/tests/rust_usage_test/benches/flexbuffers_benchmarks.rs
index 1e9c516..1b9a8fb 100644
--- a/tests/rust_usage_test/benches/flexbuffers_benchmarks.rs
+++ b/tests/rust_usage_test/benches/flexbuffers_benchmarks.rs
@@ -224,7 +224,7 @@
     b.iter(go);
     b.bytes = n as u64;
 }
-fn validate_monster(r: MapReader) {
+fn validate_monster(r: MapReader<&[u8]>) {
     assert_eq!(r.idx("type").as_str(), "great orc");
     assert_eq!(r.idx("age").as_u8(), 100);
     assert_eq!(r.idx("name").as_str(), "Mr. Orc");
diff --git a/tests/rust_usage_test/bin/flatbuffers_alloc_check.rs b/tests/rust_usage_test/bin/flatbuffers_alloc_check.rs
index c47e86e..418783c 100644
--- a/tests/rust_usage_test/bin/flatbuffers_alloc_check.rs
+++ b/tests/rust_usage_test/bin/flatbuffers_alloc_check.rs
@@ -29,15 +29,15 @@
 // import the flatbuffers generated code:
 extern crate flatbuffers;
 #[allow(dead_code, unused_imports)]
-#[path = "../../include_test/include_test1_generated.rs"]
+#[path = "../../include_test1/mod.rs"]
 pub mod include_test1_generated;
 
 #[allow(dead_code, unused_imports)]
-#[path = "../../include_test/sub/include_test2_generated.rs"]
+#[path = "../../include_test2/mod.rs"]
 pub mod include_test2_generated;
 
-#[allow(dead_code, unused_imports)]
-#[path = "../../monster_test_generated.rs"]
+#[allow(dead_code, unused_imports, clippy::approx_constant)]
+#[path = "../../monster_test/mod.rs"]
 mod monster_test_generated;
 pub use monster_test_generated::my_game;
 
@@ -98,6 +98,7 @@
     my_game::example::finish_monster_buffer(builder, mon);
 }
 
+#[cfg(not(miri))]  // slow.
 fn main() {
     // test the allocation tracking:
     {
@@ -131,7 +132,7 @@
 
         // do many reads, forcing them to execute by using assert_eq:
         {
-            let m = my_game::example::get_root_as_monster(buf);
+            let m = unsafe { my_game::example::root_as_monster_unchecked(buf) };
             assert_eq!(80, m.hp());
             assert_eq!(150, m.mana());
             assert_eq!("MyMonster", m.name());
diff --git a/tests/rust_usage_test/bin/flexbuffers_alloc_check.rs b/tests/rust_usage_test/bin/flexbuffers_alloc_check.rs
index 310d1a9..a921af7 100644
--- a/tests/rust_usage_test/bin/flexbuffers_alloc_check.rs
+++ b/tests/rust_usage_test/bin/flexbuffers_alloc_check.rs
@@ -70,6 +70,10 @@
 fn validate_monster(flexbuffer: &[u8]) {
     let r = Reader::get_root(flexbuffer).unwrap().as_map();
 
+    assert!(!r.is_empty());
+    assert!(r.index_key("not_a_field").is_none());
+
+    assert_eq!(r.len(), 7);
     assert_eq!(r.idx("type").as_str(), "great orc");
     assert_eq!(r.idx("age").as_u8(), 100);
     assert_eq!(r.idx("name").as_str(), "Mr. Orc");
@@ -103,6 +107,7 @@
 
 // This is in a separate binary than tests because taking over the global allocator is not
 // hermetic and not thread safe.
+#[cfg(not(miri))]  // slow.
 fn main() {
     let start_up = current_allocs();
 
@@ -133,6 +138,7 @@
 }
 
 #[test]
+#[cfg(not(miri))]  // slow.
 fn no_extra_allocations() {
     main()
 }
diff --git a/tests/rust_usage_test/bin/monster_example.rs b/tests/rust_usage_test/bin/monster_example.rs
index d0b75d7..17ce0e0 100644
--- a/tests/rust_usage_test/bin/monster_example.rs
+++ b/tests/rust_usage_test/bin/monster_example.rs
@@ -1,15 +1,15 @@
 extern crate flatbuffers;
 
 #[allow(dead_code, unused_imports)]
-#[path = "../../include_test/include_test1_generated.rs"]
+#[path = "../../include_test1/mod.rs"]
 pub mod include_test1_generated;
 
 #[allow(dead_code, unused_imports)]
-#[path = "../../include_test/sub/include_test2_generated.rs"]
+#[path = "../../include_test2/mod.rs"]
 pub mod include_test2_generated;
 
-#[allow(dead_code, unused_imports)]
-#[path = "../../monster_test_generated.rs"]
+#[allow(dead_code, unused_imports, clippy::approx_constant)]
+#[path = "../../monster_test/mod.rs"]
 mod monster_test_generated;
 pub use monster_test_generated::my_game;
 
@@ -20,7 +20,7 @@
     let mut buf = Vec::new();
     f.read_to_end(&mut buf).expect("file reading failed");
 
-    let monster = my_game::example::get_root_as_monster(&buf[..]);
+    let monster = my_game::example::root_as_monster(&buf[..]).unwrap();
     println!("{}", monster.hp()); // `80`
     println!("{}", monster.mana()); // default value of `150`
     println!("{:?}", monster.name()); // Some("MyMonster")
diff --git a/tests/rust_usage_test/outdir/.gitignore b/tests/rust_usage_test/outdir/.gitignore
new file mode 100644
index 0000000..c83f90a
--- /dev/null
+++ b/tests/rust_usage_test/outdir/.gitignore
@@ -0,0 +1 @@
+src/generated
diff --git a/tests/rust_usage_test/outdir/Cargo.toml b/tests/rust_usage_test/outdir/Cargo.toml
new file mode 100644
index 0000000..659638f
--- /dev/null
+++ b/tests/rust_usage_test/outdir/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "outdir"
+version = "0.1.0"
+authors = ["Casper Neo <cneo@google.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+flatbuffers = { path = "../../../rust/flatbuffers" }
+serde = "1.0"
diff --git a/tests/rust_usage_test/outdir/build.rs b/tests/rust_usage_test/outdir/build.rs
new file mode 100644
index 0000000..0462828
--- /dev/null
+++ b/tests/rust_usage_test/outdir/build.rs
@@ -0,0 +1,56 @@
+fn main() {
+    use std::process::Command;
+    let project_root = std::env::current_dir()
+        .unwrap()
+        .parent() // flatbuffers/tests/rust_usage test
+        .unwrap()
+        .parent() // flatbuffers/tests
+        .unwrap()
+        .parent() // flatbuffers/
+        .unwrap()
+        .to_path_buf();
+    let sample_schema = {
+        let mut s = project_root.to_path_buf();
+        s.push("samples");
+        s.push("monster.fbs");
+        s
+    };
+
+    let flatc = {
+        let mut f = project_root.to_path_buf();
+        f.push("flatc");
+        f
+    };
+
+    let out_dir = {
+        let mut d = std::path::Path::new(&std::env::var("OUT_DIR").unwrap()).to_path_buf();
+        d.push("flatbuffers");
+        d
+    };
+
+    Command::new(&flatc)
+        .arg("-o")
+        .arg(&out_dir)
+        .arg("--rust")
+        .arg(&sample_schema)
+        .output()
+        .expect("Failed to generate file");
+
+    assert!(out_dir.exists());
+
+    let generated = std::path::Path::new("src/generated");
+    #[cfg(target_os = "windows")]
+    {
+        if generated.exists() {
+            std::fs::remove_dir(generated).unwrap();
+        }
+        std::os::windows::fs::symlink_dir(out_dir, generated).unwrap();
+    }
+    #[cfg(not(target_os = "windows"))]
+    {
+        if generated.exists() {
+            std::fs::remove_file(generated).unwrap();
+        }
+        std::os::unix::fs::symlink(out_dir, generated).unwrap();
+    }
+}
diff --git a/tests/rust_usage_test/outdir/src/main.rs b/tests/rust_usage_test/outdir/src/main.rs
new file mode 100644
index 0000000..734e137
--- /dev/null
+++ b/tests/rust_usage_test/outdir/src/main.rs
@@ -0,0 +1,29 @@
+// In this example, a build.rs file generates the code and then copies it into generated/
+extern crate flatbuffers;
+#[allow(unused_imports, dead_code)]
+mod generated;
+use generated::my_game::sample::{Monster, MonsterArgs};
+
+fn main() {
+    let mut fbb = flatbuffers::FlatBufferBuilder::new();
+    let name = Some(fbb.create_string("bob"));
+    let m = Monster::create(
+        &mut fbb,
+        &MonsterArgs {
+            hp: 1,
+            mana: 2,
+            name,
+            ..Default::default()
+        },
+    );
+    fbb.finish(m, None);
+    let mon = flatbuffers::root::<Monster>(fbb.finished_data()).unwrap();
+    assert_eq!(mon.hp(), 1);
+    assert_eq!(mon.mana(), 2);
+    assert_eq!(mon.name().unwrap(), "bob");
+}
+
+#[test]
+fn test_main() {
+    main()
+}
diff --git a/tests/rust_usage_test/tests/arrays_test.rs b/tests/rust_usage_test/tests/arrays_test.rs
new file mode 100644
index 0000000..faa0ac8
--- /dev/null
+++ b/tests/rust_usage_test/tests/arrays_test.rs
@@ -0,0 +1,325 @@
+extern crate array_init;
+#[allow(dead_code, unused_imports)]
+#[path = "../../arrays_test/mod.rs"]
+mod arrays_test_generated;
+use std::fmt::Debug;
+
+use crate::arrays_test_generated::my_game::example::*;
+extern crate quickcheck;
+use array_init::array_init;
+use std::mem::size_of;
+use quickcheck::{Arbitrary, Gen};
+
+
+fn create_serialized_example_with_generated_code(builder: &mut flatbuffers::FlatBufferBuilder) {
+    let nested_struct1 = NestedStruct::new(
+        &[-1, 2],
+        TestEnum::A,
+        &[TestEnum::C, TestEnum::B],
+        &[0x1122334455667788, -0x1122334455667788],
+    );
+    let nested_struct2 = NestedStruct::new(
+        &[3, -4],
+        TestEnum::B,
+        &[TestEnum::B, TestEnum::A],
+        &[-0x1122334455667788, 0x1122334455667788],
+    );
+    let array_struct = ArrayStruct::new(
+        12.34,
+        &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF],
+        -127,
+        &[nested_struct1, nested_struct2],
+        1,
+        &[-0x8000000000000000, 0x7FFFFFFFFFFFFFFF],
+    );
+    // Test five makes sense when specified.
+    let ss = ArrayTable::create(
+        builder,
+        &ArrayTableArgs {
+            a: Some(&array_struct),
+        },
+    );
+    finish_array_table_buffer(builder, ss);
+}
+
+fn serialized_example_is_accessible_and_correct(
+    bytes: &[u8],
+    identifier_required: bool,
+    size_prefixed: bool,
+) {
+    if identifier_required {
+        let correct = if size_prefixed {
+            array_table_size_prefixed_buffer_has_identifier(bytes)
+        } else {
+            array_table_buffer_has_identifier(bytes)
+        };
+        assert_eq!(correct, true);
+    }
+
+    let array_table = if size_prefixed {
+        size_prefixed_root_as_array_table(bytes).unwrap()
+    } else {
+        root_as_array_table(bytes).unwrap()
+    };
+
+    let array_struct = array_table.a().unwrap();
+    assert_eq!(array_struct.a(), 12.34);
+    assert_eq!(array_struct.b().len(), 0xF);
+    assert_eq!(array_struct.b().iter().sum::<i32>(), 120);
+    assert_eq!(array_struct.c(), -127);
+
+    assert_eq!(array_struct.d().len(), 2);
+    let nested_struct1 = array_struct.d().get(0);
+    assert_eq!(nested_struct1.a().len(), 2);
+    assert_eq!(nested_struct1.a().iter().sum::<i32>(), 1);
+    assert_eq!(nested_struct1.b(), TestEnum::A);
+    assert_eq!(nested_struct1.c().len(), 2);
+    assert_eq!(nested_struct1.c().get(0), TestEnum::C);
+    assert_eq!(nested_struct1.c().get(1), TestEnum::B);
+    assert_eq!(nested_struct1.d().len(), 2);
+    assert_eq!(
+        [nested_struct1.d().get(0), nested_struct1.d().get(1)],
+        [0x1122334455667788, -0x1122334455667788]
+    );
+    let nested_struct2 = array_struct.d().get(1);
+    assert_eq!(nested_struct2.a().len(), 2);
+    assert_eq!(nested_struct2.a().iter().sum::<i32>(), -1);
+    assert_eq!(nested_struct2.b(), TestEnum::B);
+    assert_eq!(nested_struct2.c().len(), 2);
+    assert_eq!(nested_struct2.c().get(0), TestEnum::B);
+    assert_eq!(nested_struct2.c().get(1), TestEnum::A);
+    assert_eq!(nested_struct2.d().len(), 2);
+    let arr: [i64; 2] = nested_struct2.d().into();
+    assert_eq!(
+        arr,
+        [-0x1122334455667788, 0x1122334455667788]
+    );
+
+    assert_eq!(array_struct.e(), 1);
+    assert_eq!(array_struct.f().len(), 2);
+    assert_eq!(array_struct.f().get(0), -0x8000000000000000);
+    assert_eq!(array_struct.f().get(1), 0x7FFFFFFFFFFFFFFF);
+}
+
+#[test]
+fn generated_code_creates_correct_example() {
+    let mut b = flatbuffers::FlatBufferBuilder::new();
+    create_serialized_example_with_generated_code(&mut b);
+    let buf = b.finished_data();
+    serialized_example_is_accessible_and_correct(&buf[..], true, false);
+}
+
+#[test]
+fn struct_netsted_struct_is_32_bytes() {
+    assert_eq!(32, ::std::mem::size_of::<NestedStruct>());
+}
+
+#[test]
+fn struct_array_struct_is_160_bytes() {
+    assert_eq!(160, ::std::mem::size_of::<ArrayStruct>());
+}
+
+#[test]
+fn test_object_api_reads_correctly() {
+    let mut b = flatbuffers::FlatBufferBuilder::new();
+    create_serialized_example_with_generated_code(&mut b);
+
+    let array_table = root_as_array_table(b.finished_data()).unwrap().unpack();
+
+    let array_struct = array_table.a.unwrap();
+    assert_eq!(array_struct.a, 12.34);
+    assert_eq!(array_struct.b.len(), 0xF);
+    assert_eq!(array_struct.b.iter().sum::<i32>(), 120);
+    assert_eq!(array_struct.c, -127);
+
+    assert_eq!(array_struct.d.len(), 2);
+    let nested_struct1 = &array_struct.d[0];
+    assert_eq!(nested_struct1.a.len(), 2);
+    assert_eq!(nested_struct1.a.iter().sum::<i32>(), 1);
+    assert_eq!(nested_struct1.b, TestEnum::A);
+    assert_eq!(nested_struct1.c.len(), 2);
+    assert_eq!(nested_struct1.c[0], TestEnum::C);
+    assert_eq!(nested_struct1.c[1], TestEnum::B);
+    assert_eq!(nested_struct1.d.len(), 2);
+    assert_eq!(nested_struct1.d, [0x1122334455667788, -0x1122334455667788]);
+    let nested_struct2 = &array_struct.d[1];
+    assert_eq!(nested_struct2.a.len(), 2);
+    assert_eq!(nested_struct2.a.iter().sum::<i32>(), -1);
+    assert_eq!(nested_struct2.b, TestEnum::B);
+    assert_eq!(nested_struct2.c.len(), 2);
+    assert_eq!(nested_struct2.c[0], TestEnum::B);
+    assert_eq!(nested_struct2.c[1], TestEnum::A);
+    assert_eq!(nested_struct2.d.len(), 2);
+    assert_eq!(nested_struct2.d, [-0x1122334455667788, 0x1122334455667788]);
+
+    assert_eq!(array_struct.e, 1);
+    assert_eq!(array_struct.f.len(), 2);
+    assert_eq!(array_struct.f[0], -0x8000000000000000);
+    assert_eq!(array_struct.f[1], 0x7FFFFFFFFFFFFFFF);
+}
+
+#[test]
+fn object_api_defaults() {
+    use arrays_test_generated::my_game::example::*;
+
+    assert_eq!(
+        NestedStructT::default(),
+        NestedStructT {
+            a: [0, 0],
+            b: TestEnum::default(),
+            c: [TestEnum::default(), TestEnum::default()],
+            d: [0, 0]
+        }
+    );
+
+    assert_eq!(
+        ArrayStructT::default(),
+        ArrayStructT {
+            a: 0.0,
+            b: [0; 0xF],
+            c: 0,
+            d: [NestedStructT::default(), NestedStructT::default()],
+            e: 0,
+            f: [0, 0]
+        }
+    );
+}
+
+#[test]
+fn generated_code_debug_prints_correctly() {
+    let b = &mut flatbuffers::FlatBufferBuilder::new();
+    create_serialized_example_with_generated_code(b);
+    let buf = b.finished_data();
+    let array_table = root_as_array_table(buf).unwrap();
+    assert_eq!(
+        format!("{:.5?}", &array_table),
+        "ArrayTable { a: Some(ArrayStruct { a: 12.34000, \
+         b: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], \
+         c: -127, d: [NestedStruct { a: [-1, 2], b: A, c: [C, B], \
+         d: [1234605616436508552, -1234605616436508552] }, \
+         NestedStruct { a: [3, -4], b: B, c: [B, A], d: [-1234605616436508552, 1234605616436508552] }], \
+         e: 1, f: [-9223372036854775808, 9223372036854775807] }) }"
+    );
+}
+
+#[test]
+#[should_panic]
+fn assert_on_too_small_array_buf() {
+    let a = [0u8; 19];
+    flatbuffers::Array::<i32, 5>::new(&a);
+}
+
+#[test]
+#[should_panic]
+fn assert_on_too_big_array_buf() {
+    let a = [0u8; 21];
+    flatbuffers::Array::<i32, 5>::new(&a);
+}
+
+#[test]
+#[cfg(target_endian = "little")]
+fn verify_struct_array_alignment() {
+    let mut b = flatbuffers::FlatBufferBuilder::new();
+    create_serialized_example_with_generated_code(&mut b);
+    let buf = b.finished_data();
+    let array_table = root_as_array_table(buf).unwrap();
+    let array_struct = array_table.a().unwrap();
+    let struct_start_ptr = array_struct.0.as_ptr() as usize;
+    let b_start_ptr = array_struct.b().as_ptr() as usize;
+    let d_start_ptr = array_struct.d().as_ptr() as usize;
+    // The T type of b
+    let b_aln = ::std::mem::align_of::<i32>();
+    assert_eq!((b_start_ptr - struct_start_ptr) % b_aln, 0);
+    assert_eq!((d_start_ptr - b_start_ptr) % b_aln, 0);
+    assert_eq!((d_start_ptr - struct_start_ptr) % 8, 0);
+}
+
+#[derive(Clone, Debug)]
+struct FakeArray<T, const N: usize>([T; N]);
+
+impl<T: Arbitrary + Debug + PartialEq, const N: usize> Arbitrary for FakeArray<T, N> {
+    fn arbitrary<G: Gen>(g: &mut G) -> FakeArray<T, N> {
+        let x: [T; N] = array_init(|_| {
+            loop {
+                let generated_scalar = T::arbitrary(g);
+                // Verify that generated scalar is not Nan, which is not equals to itself, 
+                // therefore we can't use it to validate input == output
+                if generated_scalar == generated_scalar { return generated_scalar }
+            }
+        });
+        FakeArray{0: x}
+    }
+}
+
+#[cfg(test)]
+mod array_fuzz {
+    #[cfg(not(miri))]  // slow.
+    extern crate quickcheck;
+    extern crate flatbuffers;
+    use self::flatbuffers::{Follow, Push};
+    use super::*;
+
+    const MAX_TESTS: u64 = 20;
+    const ARRAY_SIZE: usize = 29;
+
+    // This uses a macro because lifetimes for the trait-bounded function get too
+    // complicated.
+    macro_rules! impl_prop {
+        ($test_name:ident, $fn_name:ident, $ty:ident) => (
+            fn $fn_name(xs: FakeArray<$ty, ARRAY_SIZE>) {
+                let mut test_buf = [0 as u8; 1024];
+                flatbuffers::emplace_scalar_array(&mut test_buf, 0, &xs.0);
+                let arr: flatbuffers::Array<$ty, ARRAY_SIZE> = flatbuffers::Array::follow(&test_buf, 0);
+                let got: [$ty; ARRAY_SIZE] = arr.into();
+                assert_eq!(got, xs.0);
+            }
+            #[test]
+            fn $test_name() { 
+                quickcheck::QuickCheck::new().max_tests(MAX_TESTS).quickcheck($fn_name as fn(FakeArray<$ty, ARRAY_SIZE>));
+            }
+        )
+    }
+
+    impl_prop!(test_bool, prop_bool, bool);
+    impl_prop!(test_u8, prop_u8, u8);
+    impl_prop!(test_i8, prop_i8, i8);
+    impl_prop!(test_u16, prop_u16, u16);
+    impl_prop!(test_u32, prop_u32, u32);
+    impl_prop!(test_u64, prop_u64, u64);
+    impl_prop!(test_i16, prop_i16, i16);
+    impl_prop!(test_i32, prop_i32, i32);
+    impl_prop!(test_i64, prop_i64, i64);
+    impl_prop!(test_f32, prop_f32, f32);
+    impl_prop!(test_f64, prop_f64, f64);
+
+    const NESTED_STRUCT_SIZE: usize = size_of::<NestedStruct>();
+
+    #[derive(Clone, Debug, PartialEq)]
+    struct NestedStructWrapper(NestedStruct);
+
+    impl Arbitrary for NestedStructWrapper {
+        fn arbitrary<G: Gen>(g: &mut G) -> NestedStructWrapper {
+            let mut x = NestedStruct::default();
+            x.0 = FakeArray::<u8, NESTED_STRUCT_SIZE>::arbitrary(g).0;
+            NestedStructWrapper{0: x}
+        }
+    }
+
+    fn prop_struct(xs: FakeArray<NestedStructWrapper, ARRAY_SIZE>) {
+        let mut test_buf = [0 as u8; 1024];
+        let native_struct_array: [&NestedStruct; ARRAY_SIZE] = array_init::from_iter(xs.0.iter().map(|x| &x.0)).unwrap();
+        for i in 0..ARRAY_SIZE {
+            let offset = i * NESTED_STRUCT_SIZE;
+            native_struct_array[i].push(&mut test_buf[offset..offset + NESTED_STRUCT_SIZE], &[]);
+        }
+        let arr: flatbuffers::Array<NestedStruct, ARRAY_SIZE> = flatbuffers::Array::follow(&test_buf, 0);
+        let got: [&NestedStruct; ARRAY_SIZE] = arr.into();
+        assert_eq!(got, native_struct_array);
+    }
+
+    #[test]
+    #[cfg(not(miri))]  // slow.
+    fn test_struct() { 
+        quickcheck::QuickCheck::new().max_tests(MAX_TESTS).quickcheck(prop_struct as fn(FakeArray<NestedStructWrapper, ARRAY_SIZE>));
+    }
+}
diff --git a/tests/rust_usage_test/tests/flexbuffers_tests/binary_format.rs b/tests/rust_usage_test/tests/flexbuffers_tests/binary_format.rs
index ce69511..910fc78 100644
--- a/tests/rust_usage_test/tests/flexbuffers_tests/binary_format.rs
+++ b/tests/rust_usage_test/tests/flexbuffers_tests/binary_format.rs
@@ -108,6 +108,7 @@
     );
 }
 
+#[cfg(not(miri))]  // slow.
 quickcheck! {
     fn qc_f32(x: f32) -> bool {
         let fxb = singleton(x);
@@ -310,7 +311,7 @@
             1,      // Root bytes
         ]
     );
-    let r = Reader::get_root(&buf).unwrap();
+    let r = Reader::get_root(buf.as_ref()).unwrap();
     assert_eq!(r.get_str(), Ok("snowman ☃︎"));
 }
 #[test]
diff --git a/tests/rust_usage_test/tests/flexbuffers_tests/interop.rs b/tests/rust_usage_test/tests/flexbuffers_tests/interop.rs
index 54ae1fd..705948f 100644
--- a/tests/rust_usage_test/tests/flexbuffers_tests/interop.rs
+++ b/tests/rust_usage_test/tests/flexbuffers_tests/interop.rs
@@ -18,14 +18,14 @@
 fn read_golden_flexbuffer() {
     let s =
         std::fs::read("../gold_flexbuffer_example.bin").expect("Unable to read golden flexbuffer.");
-    let r = Reader::get_root(&s).unwrap();
+    let r = Reader::get_root(s.as_ref()).unwrap();
     let m = r.as_map();
 
     let vec = m.idx("vec").as_vector();
     assert_eq!(vec.idx(0).as_i8(), -100);
     assert_eq!(vec.idx(1).as_str(), "Fred");
     assert_eq!(vec.idx(2).as_f32(), 4.0);
-    assert_eq!(vec.idx(3).as_blob(), Blob(&[77]));
+    assert_eq!(vec.idx(3).as_blob(), Blob([77].as_ref()));
     assert_eq!(vec.idx(4).flexbuffer_type(), FlexBufferType::Bool);
     assert_eq!(vec.idx(4).as_bool(), false);
     assert_eq!(vec.idx(5).as_f64(), 4.0);
diff --git a/tests/rust_usage_test/tests/flexbuffers_tests/mod.rs b/tests/rust_usage_test/tests/flexbuffers_tests/mod.rs
index 2fccdb3..621f81b 100644
--- a/tests/rust_usage_test/tests/flexbuffers_tests/mod.rs
+++ b/tests/rust_usage_test/tests/flexbuffers_tests/mod.rs
@@ -15,5 +15,6 @@
 mod binary_format;
 mod interop;
 mod other_api;
+#[cfg(not(miri))]  // slow.
 mod qc_serious;
 mod rwyw;
diff --git a/tests/rust_usage_test/tests/flexbuffers_tests/other_api.rs b/tests/rust_usage_test/tests/flexbuffers_tests/other_api.rs
index 430cae5..d1c0873 100644
--- a/tests/rust_usage_test/tests/flexbuffers_tests/other_api.rs
+++ b/tests/rust_usage_test/tests/flexbuffers_tests/other_api.rs
@@ -13,12 +13,14 @@
 // limitations under the License.
 
 use flexbuffers::*;
+#[cfg(not(miri))]  // slow.
 use quickcheck::QuickCheck;
 
 #[test]
+#[cfg(not(miri))]  // slow.
 fn qc_reader_no_crash() {
     fn no_crash(xs: Vec<u8>) -> bool {
-        let r = Reader::get_root(&xs);
+        let r = Reader::get_root(xs.as_ref());
         r.is_err() || r.is_ok()
     }
     QuickCheck::new()
@@ -131,7 +133,7 @@
 }
 #[test]
 fn null_reader() {
-    let n = Reader::default();
+    let n = Reader::<&[u8]>::default();
     assert_eq!(n.as_i8(), 0);
     assert_eq!(n.as_i16(), 0);
     assert_eq!(n.as_i32(), 0);
@@ -157,7 +159,7 @@
         (FlexBufferType::Vector as u8) << 2 | BitWidth::W8 as u8,
         1,
     ];
-    assert!(Reader::get_root(s).is_err());
+    assert!(Reader::get_root(s.as_ref()).is_err());
 }
 #[test]
 fn get_root_deref_u64() {
@@ -168,7 +170,24 @@
         1,
     ];
     // The risk of crashing is reading 8 bytes from index 0.
-    assert_eq!(Reader::get_root(s).unwrap().as_u64(), 0);
+    assert_eq!(Reader::get_root(s.as_ref()).unwrap().as_u64(), 0);
+}
+
+/// Verifies that the clone operation is shallow / zero copy.
+#[test]
+fn clone_is_shallow() {
+    let mut fxb = Builder::default();
+    let mut m = fxb.start_map();
+    m.push("a", &[-1i8, -2, -3, -4]);
+    m.push("b", 250i64);
+    m.push("c", 5000u16);
+    m.end_map();
+
+    let r = Reader::get_root(fxb.view()).unwrap();
+
+    let r2 = r.clone();
+
+    assert_eq!(r.buffer().as_ptr(), r2.buffer().as_ptr());
 }
 
 #[test]
diff --git a/tests/rust_usage_test/tests/flexbuffers_tests/qc_serious.rs b/tests/rust_usage_test/tests/flexbuffers_tests/qc_serious.rs
index abd1ced..1bed3c2 100644
--- a/tests/rust_usage_test/tests/flexbuffers_tests/qc_serious.rs
+++ b/tests/rust_usage_test/tests/flexbuffers_tests/qc_serious.rs
@@ -1,7 +1,6 @@
 use super::rwyw::NonNullString;
 use flexbuffers::*;
 use quickcheck::{Arbitrary, Gen};
-use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -134,12 +133,13 @@
 }
 
 quickcheck! {
-    fn qc_serious(x: Struct) -> bool {
-        let mut s = FlexbufferSerializer::new();
-        x.serialize(&mut s).unwrap();
-        let r = Reader::get_root(s.view()).unwrap();
-        println!("{}", r);
-        let x2 = Struct::deserialize(r).unwrap();
-        x == x2
+    fn qc_serious(original: Struct) -> bool {
+        let struct_buf = flexbuffers::to_vec(&original).unwrap();
+        let root = Reader::get_root(&*struct_buf).unwrap();
+        let reader_buf = flexbuffers::to_vec(&root).unwrap();
+        let deserialized: Struct = flexbuffers::from_slice(&struct_buf).unwrap();
+        let reserialized: Struct = flexbuffers::from_slice(&reader_buf).unwrap();
+
+        original == deserialized && original == reserialized
     }
 }
diff --git a/tests/rust_usage_test/tests/flexbuffers_tests/rwyw.rs b/tests/rust_usage_test/tests/flexbuffers_tests/rwyw.rs
index 7ae7974..8c27e6b 100644
--- a/tests/rust_usage_test/tests/flexbuffers_tests/rwyw.rs
+++ b/tests/rust_usage_test/tests/flexbuffers_tests/rwyw.rs
@@ -14,6 +14,7 @@
 
 // Read what you wrote.
 use flexbuffers::*;
+#[cfg(not(miri))]  // slow.
 use quickcheck;
 use serde::{Deserialize, Serialize};
 
@@ -33,6 +34,7 @@
     }
 }
 
+#[cfg(not(miri))]  // slow.
 quickcheck! {
     fn qc_vec_bool(xs: Vec<bool>) -> bool {
         let mut builder = Builder::default();
@@ -41,7 +43,7 @@
             v.push(x);
         }
         v.end_vector();
-        let r = Reader::get_root(&builder.view()).unwrap().as_vector();
+        let r = Reader::get_root(builder.view()).unwrap().as_vector();
         xs.iter().enumerate().all(|(i, &x)| r.index(i).unwrap().get_bool().unwrap() == x)
     }
     fn qc_vec_uint(xs: Vec<u64>) -> bool {
@@ -51,7 +53,7 @@
             v.push(x);
         }
         v.end_vector();
-        let r = Reader::get_root(&builder.view()).unwrap().as_vector();
+        let r = Reader::get_root(builder.view()).unwrap().as_vector();
         xs.iter().enumerate().all(|(i, &x)| r.idx(i).as_u64() == x)
     }
     fn qc_vec_int(xs: Vec<i64>) -> bool {
@@ -61,7 +63,7 @@
             v.push(x);
         }
         v.end_vector();
-        let r = Reader::get_root(&builder.view()).unwrap().as_vector();
+        let r = Reader::get_root(builder.view()).unwrap().as_vector();
         xs.iter().enumerate().all(|(i, &x)| r.idx(i).as_i64() == x)
     }
     fn qc_vec_float(xs: Vec<f64>) -> bool {
@@ -71,7 +73,7 @@
             v.push(x);
         }
         v.end_vector();
-        let r = Reader::get_root(&builder.view()).unwrap().as_vector();
+        let r = Reader::get_root(builder.view()).unwrap().as_vector();
         xs.iter().enumerate().all(|(i, &x)| (r.idx(i).as_f64() - x).abs() < std::f64::EPSILON)
     }
     fn qc_vec_string(xs: Vec<String>) -> bool {
@@ -81,7 +83,7 @@
             v.push(x as &str);
         }
         v.end_vector();
-        let r = Reader::get_root(&builder.view()).unwrap().as_vector();
+        let r = Reader::get_root(builder.view()).unwrap().as_vector();
         xs.iter().enumerate().all(|(i, x)| (r.idx(i).as_str() == x))
     }
     fn qc_map_int(xs: std::collections::BTreeMap<NonNullString, i64>) -> bool {
@@ -91,7 +93,7 @@
             m.push(&k.0, v);
         }
         m.end_map();
-        let r = Reader::get_root(&builder.view()).unwrap().as_map();
+        let r = Reader::get_root(builder.view()).unwrap().as_map();
         xs.iter().enumerate().all(|(i, (k, &v))| {
             r.idx(i).as_i64() == v && r.idx(k.0.as_str()).as_i64() == v
         })
@@ -103,7 +105,7 @@
             m.push(&k.0, v as &str);
         }
         m.end_map();
-        let r = Reader::get_root(&builder.view()).unwrap().as_map();
+        let r = Reader::get_root(builder.view()).unwrap().as_map();
         xs.iter().enumerate().all(|(i, (k, v))| {
             r.idx(i).as_str() == v && r.idx(k.0.as_str()).as_str() == v
         })
@@ -112,10 +114,10 @@
         let mut builder = Builder::default();
         let mut v = builder.start_vector();
         for x in &xs {
-            v.push(Blob(&x));
+            v.push(Blob(x.as_ref()));
         }
         v.end_vector();
-        let r = Reader::get_root(&builder.view()).unwrap().as_vector();
+        let r = Reader::get_root(builder.view()).unwrap().as_vector();
         xs.iter().enumerate().all(
             |(i, x)| r.idx(i).get_blob().unwrap().0.iter().eq(x.iter())
         )
@@ -207,7 +209,7 @@
     v.push("barrr");
     v.push("bazzzzzz");
     v.end_vector();
-    let r = Reader::get_root(&builder.view()).unwrap().as_vector();
+    let r = Reader::get_root(builder.view()).unwrap().as_vector();
     assert_eq!(r.idx(0).as_str(), "foo");
     assert_eq!(r.idx(1).as_str(), "barrr");
     assert_eq!(r.idx(2).as_str(), "bazzzzzz");
@@ -216,7 +218,7 @@
 #[test]
 fn store_13() {
     let finished = singleton::<i32>(13);
-    let r = Reader::get_root(&finished).unwrap();
+    let r = Reader::get_root(finished.as_ref()).unwrap();
     assert_eq!(r.as_i32(), 13);
 }
 #[test]
@@ -231,7 +233,7 @@
     let buf2 = singleton(&[2u8, 3, 5]);
     assert_eq!(buf1, buf2.as_slice());
 
-    let r = Reader::get_root(&buf1).unwrap().as_vector();
+    let r = Reader::get_root(buf1).unwrap().as_vector();
     assert_eq!(r.idx(0).get_u64(), Ok(2));
     assert_eq!(r.idx(1).get_u64(), Ok(3));
     assert_eq!(r.idx(2).get_u64(), Ok(5));
@@ -246,13 +248,14 @@
     v.push(5u8);
     v.push(7u8);
     v.end_vector();
-    let r = Reader::get_root(&fxb.view()).unwrap();
+    let r = Reader::get_root(fxb.view()).unwrap();
     let v = r.as_vector();
     assert_eq!(v.idx(0).get_u64(), Ok(2));
     assert_eq!(v.idx(1).get_u64(), Ok(3));
     assert_eq!(v.idx(2).get_u64(), Ok(5));
     assert_eq!(v.idx(3).get_u64(), Ok(7));
     assert!(v.index(4).is_err());
+    #[allow(deprecated)]
     #[cfg(target_endian = "little")]
     {
         assert_eq!(r.get_slice::<u8>().unwrap(), [2, 3, 5, 7]);
@@ -262,13 +265,13 @@
 fn store_and_read_blob() {
     let mut fxb = Builder::default();
     let mut v = fxb.start_vector();
-    v.push(Blob(&[1, 2, 3, 4]));
-    v.push(Blob(&[5, 6, 7]));
+    v.push(Blob([1, 2, 3, 4].as_ref()));
+    v.push(Blob([5, 6, 7].as_ref()));
     v.end_vector();
 
-    let r = Reader::get_root(&fxb.view()).unwrap().as_vector();
-    assert_eq!(r.idx(0).get_blob(), Ok(Blob(&[1, 2, 3, 4])));
-    assert_eq!(r.idx(1).get_blob(), Ok(Blob(&[5, 6, 7])));
+    let r = Reader::get_root(fxb.view()).unwrap().as_vector();
+    assert_eq!(r.idx(0).get_blob(), Ok(Blob([1, 2, 3, 4].as_ref())));
+    assert_eq!(r.idx(1).get_blob(), Ok(Blob([5, 6, 7].as_ref())));
 }
 #[test]
 fn map_64bit() {
@@ -278,7 +281,7 @@
     m.push("b", u64::max_value() - 3);
     m.end_map();
 
-    let r = Reader::get_root(&fxb.view()).unwrap().as_map();
+    let r = Reader::get_root(fxb.view()).unwrap().as_map();
     assert_eq!(r.idx("a").as_u16(), 257);
     assert_eq!(r.idx("b").as_u64(), u64::max_value() - 3);
 }
@@ -339,7 +342,7 @@
 #[test]
 fn store_u64() {
     let finished = singleton(u64::max_value() - 10);
-    let r = Reader::get_root(&finished).unwrap();
+    let r = Reader::get_root(finished.as_ref()).unwrap();
     assert_eq!(r.get_u64(), Ok(u64::max_value() - 10));
 }
 #[test]
@@ -363,6 +366,8 @@
     c: Vec<u32>,
     d: String,
 }
+
+#[cfg(not(miri))]  // slow.
 quickcheck! {
     fn serde_foo(a: i8,
     b: f64,
@@ -395,7 +400,7 @@
         b: u16,
         c: u32,
         d: u64,
-    };
+    }
 
     #[derive(Debug, PartialEq, Serialize, Deserialize)]
     struct MyUnitStruct(Vec<String>);
@@ -440,7 +445,7 @@
     Foo(vec![5, 6, 7, 8]).serialize(&mut s).unwrap();
     let reader = Reader::get_root(s.view()).unwrap();
     assert_eq!(reader.flexbuffer_type(), FlexBufferType::Blob);
-    assert_eq!(reader.as_blob(), Blob(&[5, 6, 7, 8]));
+    assert_eq!(reader.as_blob(), Blob([5, 6, 7, 8].as_ref()));
 }
 #[test]
 fn iter() {
@@ -462,7 +467,7 @@
     #[derive(Deserialize)]
     struct Foo(u8);
     let data = [13, 4, 1];
-    let r = Reader::get_root(&data).unwrap();
+    let r = Reader::get_root(data.as_ref()).unwrap();
     let foo = Foo::deserialize(r).unwrap();
     assert_eq!(foo.0, 13);
 }
@@ -471,7 +476,7 @@
     #[derive(Deserialize)]
     struct Foo<'a>(&'a str);
     let data = [5, b'h', b'e', b'l', b'l', b'o', b'\0', 6, 5 << 2, 1];
-    let r = Reader::get_root(&data).unwrap();
+    let r = Reader::get_root(data.as_ref()).unwrap();
     let foo = Foo::deserialize(r).unwrap();
     assert_eq!(foo.0, "hello");
 }
@@ -486,7 +491,7 @@
         23 << 2 | 1,    // (VectorUInt4, W16 - referring to data).
         1,              // Root width W8 - referring to vector.
     ];
-    let r = Reader::get_root(&data).unwrap();
+    let r = Reader::get_root(data.as_ref()).unwrap();
     let foo = Foo::deserialize(r).unwrap();
     assert_eq!(foo.0, 4);
     assert_eq!(foo.1, 16);
@@ -499,7 +504,7 @@
         23 << 2,    // Root type: VectorUInt4, W8.
         1,          // Root width: W8.
     ];
-    let r = Reader::get_root(&data).unwrap();
+    let r = Reader::get_root(data.as_ref()).unwrap();
     let foo = Foo::deserialize(r).unwrap();
     assert_eq!(foo.0, 1);
     assert_eq!(foo.1, 2);
diff --git a/tests/rust_usage_test/tests/integration_test.rs b/tests/rust_usage_test/tests/integration_test.rs
index 5957e2c..9a4c8b3 100644
--- a/tests/rust_usage_test/tests/integration_test.rs
+++ b/tests/rust_usage_test/tests/integration_test.rs
@@ -15,7 +15,12 @@
  * limitations under the License.
  */
 
+#[cfg(feature = "no_std")]
+#[global_allocator]
+static ALLOCATOR: libc_alloc::LibcAlloc = libc_alloc::LibcAlloc;
+
 #[macro_use]
+#[cfg(not(miri))] // slow.
 extern crate quickcheck;
 extern crate flatbuffers;
 extern crate flexbuffers;
@@ -23,26 +28,44 @@
 extern crate serde;
 #[macro_use]
 extern crate serde_derive;
+#[cfg(not(miri))] // slow.
 #[macro_use]
 extern crate quickcheck_derive;
 
 mod flexbuffers_tests;
+mod more_defaults_test;
 mod optional_scalars_test;
 
-#[path = "../../include_test/include_test1_generated.rs"]
+#[allow(dead_code, unused_imports)]
+#[path = "../../include_test1/mod.rs"]
 pub mod include_test1_generated;
 
-#[path = "../../include_test/sub/include_test2_generated.rs"]
+#[allow(dead_code, unused_imports)]
+#[path = "../../include_test2/mod.rs"]
 pub mod include_test2_generated;
 
-#[path = "../../monster_test_generated.rs"]
+#[allow(dead_code, unused_imports)]
+#[path = "../../namespace_test/mod.rs"]
+pub mod namespace_test_generated;
+
+#[allow(dead_code, unused_imports)]
+#[path = "../../monster_test/mod.rs"]
 mod monster_test_generated;
 pub use monster_test_generated::my_game;
 
 #[allow(dead_code, unused_imports)]
-#[path = "../../optional_scalars_generated.rs"]
+#[path = "../../optional_scalars/mod.rs"]
 mod optional_scalars_generated;
 
+#[allow(dead_code, unused_imports)]
+#[path = "../../arrays_test/mod.rs"]
+mod arrays_test_generated;
+
+// We use incorrect casing to test keywords.
+#[allow(dead_code, unused_imports, non_camel_case_types, non_snake_case)]
+#[path = "../../keyword_test/mod.rs"]
+mod keyword_test_generated;
+
 #[rustfmt::skip] // TODO: Use standard rust formatting and remove dead code.
 #[allow(dead_code)]
 mod flatbuffers_tests {
@@ -102,6 +125,77 @@
     assert!(check_is_some!(none).is_err());
 }
 
+#[test]
+fn object_api_defaults() {
+    use my_game::example::*;
+    assert_eq!(
+        Vec3T::default(), Vec3T {
+        x: 0.0,
+        y: 0.0,
+        z: 0.0,
+        test1: 0.0,
+        test2: Color::empty(),
+        test3: TestT {
+            a: 0,
+            b: 0
+        }
+    });
+    assert_eq!(
+        MonsterT::default(),
+        MonsterT {
+            pos: None,
+            hp: 100,
+            mana: 150,
+            name: String::new(),  // required string => default is empty string.
+            color: Color::Blue,
+            inventory: None,
+            testarrayoftables: None,
+            testarrayofstring: None,
+            testarrayofstring2: None,
+            testarrayofbools: None,
+            testarrayofsortedstruct: None,
+            enemy: None,
+            test: AnyT::NONE,
+            test4: None,
+            test5: None,
+            testnestedflatbuffer: None,
+            testempty: None,
+            testbool: false,
+            testhashs32_fnv1: 0,
+            testhashu32_fnv1: 0,
+            testhashs64_fnv1: 0,
+            testhashu64_fnv1: 0,
+            testhashs32_fnv1a: 0,
+            testhashu32_fnv1a: 0,
+            testhashs64_fnv1a: 0,
+            testhashu64_fnv1a: 0,
+            testf: 3.14159,
+            testf2: 3.0,
+            testf3: 0.0,
+            flex: None,
+            vector_of_longs: None,
+            vector_of_doubles: None,
+            parent_namespace_test: None,
+            vector_of_referrables: None,
+            single_weak_reference: 0,
+            vector_of_weak_references: None,
+            vector_of_strong_referrables: None,
+            co_owning_reference: 0,
+            vector_of_co_owning_references: None,
+            non_owning_reference: 0,
+            vector_of_non_owning_references: None,
+            any_unique: AnyUniqueAliasesT::NONE,
+            any_ambiguous: AnyAmbiguousAliasesT::NONE,
+            vector_of_enums: None,
+            signed_enum: Race::None,
+            testrequirednestedflatbuffer: None,  // despite the name, it is not required.
+            scalar_key_sorted_tables: None,
+            native_inline: None,
+            long_enum_non_enum_default: Default::default(),
+            long_enum_normal_default: LongEnum::LongOne,
+        }
+    );
+}
 
 fn create_serialized_example_with_generated_code(builder: &mut flatbuffers::FlatBufferBuilder) {
     let mon = {
@@ -177,9 +271,9 @@
     }
 
     let m = if size_prefixed {
-        my_game::example::get_size_prefixed_root_as_monster(bytes)
+        my_game::example::size_prefixed_root_as_monster(bytes).unwrap()
     } else {
-        my_game::example::get_root_as_monster(bytes)
+        my_game::example::root_as_monster(bytes).unwrap()
     };
 
     check_eq!(m.hp(), 80)?;
@@ -225,16 +319,60 @@
     Ok(())
 }
 
+#[test]
+fn test_object_api_reads_correctly() -> Result<(), &'static str>{
+    let mut fbb = flatbuffers::FlatBufferBuilder::new();
+    create_serialized_example_with_library_code(&mut fbb);
+
+    let m = my_game::example::root_as_monster(fbb.finished_data()).unwrap().unpack();
+
+    check_eq!(m.hp, 80)?;
+    check_eq!(m.mana, 150)?;
+    check_eq!(m.name, "MyMonster")?;
+
+    let pos = m.pos.as_ref().unwrap();
+    check_eq!(pos.x, 1.0f32)?;
+    check_eq!(pos.y, 2.0f32)?;
+    check_eq!(pos.z, 3.0f32)?;
+    check_eq!(pos.test1, 3.0f64)?;
+    check_eq!(pos.test2, my_game::example::Color::Green)?;
+
+    let pos_test3 = &pos.test3;
+    check_eq!(pos_test3.a, 5i16)?;
+    check_eq!(pos_test3.b, 6i8)?;
+
+    let monster2 = m.test.as_monster().unwrap();
+    check_eq!(monster2.name, "Fred")?;
+
+    let inv = m.inventory.as_ref().unwrap();
+    check_eq!(inv.len(), 5)?;
+    check_eq!(inv.iter().sum::<u8>(), 10u8)?;
+    check_eq!(inv.iter().rev().sum::<u8>(), 10u8)?;
+
+    let test4 = m.test4.as_ref().unwrap();
+    check_eq!(test4.len(), 2)?;
+    check_eq!(test4[0].a as i32 + test4[0].b as i32 +
+              test4[1].a as i32 + test4[1].b as i32, 100)?;
+
+    let testarrayofstring = m.testarrayofstring.as_ref().unwrap();
+    check_eq!(testarrayofstring.len(), 2)?;
+    check_eq!(testarrayofstring[0], "test1")?;
+    check_eq!(testarrayofstring[1], "test2")?;
+    Ok(())
+}
+
+
+
 // Disabled due to Windows CI limitations.
 // #[test]
 // fn builder_initializes_with_maximum_buffer_size() {
-//     flatbuffers::FlatBufferBuilder::new_with_capacity(flatbuffers::FLATBUFFERS_MAX_BUFFER_SIZE);
+//     flatbuffers::FlatBufferBuilder::with_capacity(flatbuffers::FLATBUFFERS_MAX_BUFFER_SIZE);
 // }
 
 #[should_panic]
 #[test]
 fn builder_abort_with_greater_than_maximum_buffer_size() {
-    flatbuffers::FlatBufferBuilder::new_with_capacity(flatbuffers::FLATBUFFERS_MAX_BUFFER_SIZE+1);
+    flatbuffers::FlatBufferBuilder::with_capacity(flatbuffers::FLATBUFFERS_MAX_BUFFER_SIZE+1);
 }
 
 #[test]
@@ -245,6 +383,109 @@
     serialized_example_is_accessible_and_correct(&backing_buf[head..], true, false).unwrap();
 }
 
+#[test]
+#[cfg(not(miri))]  // slow.
+fn verifier_one_byte_errors_do_not_crash() {
+    let mut b = flatbuffers::FlatBufferBuilder::new();
+    create_serialized_example_with_library_code(&mut b);
+    let mut badbuf = b.finished_data().to_vec();
+    // If the verifier says a buffer is okay then using it won't cause a crash.
+    // We use write_fmt since Debug visits all the fields - but there's no need to store anything.
+    struct ForgetfulWriter;
+    use std::fmt::Write;
+    impl Write for ForgetfulWriter {
+        fn write_str(&mut self, _: &str) -> Result<(), std::fmt::Error> {
+            Ok(())
+        }
+    }
+    let mut w = ForgetfulWriter;
+    for d in 1..=255u8 {
+        for i in 0..badbuf.len() {
+            let orig = badbuf[i];
+            badbuf[i] = badbuf[i].wrapping_add(d);
+            if let Ok(m) = flatbuffers::root::<my_game::example::Monster>(&badbuf) {
+                w.write_fmt(format_args!("{:?}", m)).unwrap()
+            }
+            badbuf[i] = orig;
+        }
+    }
+}
+#[test]
+#[cfg(not(miri))]  // slow.
+fn verifier_too_many_tables() {
+    use my_game::example::*;
+    let b = &mut flatbuffers::FlatBufferBuilder::new();
+    let r = Referrable::create(b, &ReferrableArgs { id: 42 });
+    let rs = b.create_vector(&vec![r; 500]);
+    let name = Some(b.create_string("foo"));
+    let m = Monster::create(b, &MonsterArgs {
+        vector_of_referrables: Some(rs),
+        name,  // required field.
+        ..Default::default()
+    });
+    b.finish(m, None);
+
+    let data = b.finished_data();
+    let mut opts = flatbuffers::VerifierOptions::default();
+
+    opts.max_tables = 500;
+    let res = flatbuffers::root_with_opts::<Monster>(&opts, data);
+    assert_eq!(res.unwrap_err(), flatbuffers::InvalidFlatbuffer::TooManyTables);
+
+    opts.max_tables += 2;
+    assert!(flatbuffers::root_with_opts::<Monster>(&opts, data).is_ok());
+}
+#[test]
+#[cfg(not(miri))]  // slow.
+fn verifier_apparent_size_too_large() {
+    use my_game::example::*;
+    let b = &mut flatbuffers::FlatBufferBuilder::new();
+    let name = Some(b.create_string("foo"));
+    // String amplification attack.
+    let s = b.create_string(&(std::iter::repeat("X").take(1000).collect::<String>()));
+    let testarrayofstring = Some(b.create_vector(&vec![s; 1000]));
+    let m = Monster::create(b, &MonsterArgs {
+        testarrayofstring,
+        name,  // required field.
+        ..Default::default()
+    });
+    b.finish(m, None);
+    let data = b.finished_data();
+    assert!(data.len() < 5100);  // est 4000 for the vector + 1000 for the string + 100 overhead.
+    let mut opts = flatbuffers::VerifierOptions::default();
+    opts.max_apparent_size = 1_000_000;
+
+    let res = flatbuffers::root_with_opts::<Monster>(&opts, data);
+    assert_eq!(res.unwrap_err(), flatbuffers::InvalidFlatbuffer::ApparentSizeTooLarge);
+
+    opts.max_apparent_size += 20_000;
+    assert!(flatbuffers::root_with_opts::<Monster>(&opts, data).is_ok());
+}
+#[test]
+fn verifier_in_too_deep() {
+    use my_game::example::*;
+    let b = &mut flatbuffers::FlatBufferBuilder::new();
+    let name = Some(b.create_string("foo"));
+    let mut prev_monster = None;
+    for _ in 0..11 {
+        prev_monster = Some(Monster::create(b, &MonsterArgs {
+            enemy: prev_monster,
+            name,  // required field.
+            ..Default::default()
+        }));
+    };
+    b.finish(prev_monster.unwrap(), None);
+    let mut opts = flatbuffers::VerifierOptions::default();
+    opts.max_depth = 10;
+
+    let data = b.finished_data();
+    let res = flatbuffers::root_with_opts::<Monster>(&opts, data);
+    assert_eq!(res.unwrap_err(), flatbuffers::InvalidFlatbuffer::DepthLimitReached);
+
+    opts.max_depth += 1;
+    assert!(flatbuffers::root_with_opts::<Monster>(&opts, data).is_ok());
+}
+
 #[cfg(test)]
 mod generated_constants {
     extern crate flatbuffers;
@@ -316,7 +557,7 @@
         let slice: &[u8] = &buf;
         let slice: &'static [u8] = unsafe { mem::transmute(slice) };
         // make sure values retrieved from the 'static buffer are themselves 'static
-        let monster: my_game::example::Monster<'static> = my_game::example::get_root_as_monster(slice);
+        let monster: my_game::example::Monster<'static> = my_game::example::root_as_monster(slice).unwrap();
         // this line should compile:
         let name: Option<&'static str> = monster._tab.get::<flatbuffers::ForwardsUOffset<&str>>(my_game::example::Monster::VT_NAME, None);
         assert_eq!(name, Some("MyMonster"));
@@ -334,7 +575,7 @@
     fn table_object_self_lifetime_in_closure() {
         // This test is designed to ensure that lifetimes for temporary intermediate tables aren't inflated beyond where the need to be.
         let buf = load_file("../monsterdata_test.mon").expect("missing monsterdata_test.mon");
-        let monster = my_game::example::get_root_as_monster(&buf);
+        let monster = my_game::example::root_as_monster(&buf).unwrap();
         let enemy: Option<my_game::example::Monster> = monster.enemy();
         // This line won't compile if "self" is required to live for the lifetime of buf above as the borrow disappears at the end of the closure.
         let enemy_of_my_enemy = enemy.map(|e| {
@@ -357,7 +598,7 @@
     fn build_mon<'a, 'b>(builder: &'a mut flatbuffers::FlatBufferBuilder, args: &'b my_game::example::MonsterArgs) -> my_game::example::Monster<'a> {
         let mon = my_game::example::Monster::create(builder, &args);
         my_game::example::finish_monster_buffer(builder, mon);
-        my_game::example::get_root_as_monster(builder.finished_data())
+        my_game::example::root_as_monster(builder.finished_data()).unwrap()
     }
 
     #[test]
@@ -437,7 +678,7 @@
             my_game::example::finish_monster_buffer(b, outer);
         }
 
-        let mon = my_game::example::get_root_as_monster(b.finished_data());
+        let mon = my_game::example::root_as_monster(b.finished_data()).unwrap();
         assert_eq!(mon.name(), "bar");
         assert_eq!(mon.test_type(), my_game::example::Any::Monster);
         assert_eq!(my_game::example::Monster::init_from_table(mon.test().unwrap()).name(),
@@ -473,7 +714,7 @@
             my_game::example::finish_monster_buffer(b, outer);
         }
 
-        let mon = my_game::example::get_root_as_monster(b.finished_data());
+        let mon = my_game::example::root_as_monster(b.finished_data()).unwrap();
         assert_eq!(mon.name(), "bar");
         assert_eq!(mon.enemy().unwrap().name(), "foo");
     }
@@ -503,7 +744,7 @@
             my_game::example::finish_monster_buffer(b, outer);
         }
 
-        let mon = my_game::example::get_root_as_monster(b.finished_data());
+        let mon = my_game::example::root_as_monster(b.finished_data()).unwrap();
         assert_eq!(mon.name(), "bar");
         assert_eq!(mon.testempty().unwrap().id(), Some("foo"));
     }
@@ -540,12 +781,12 @@
             b1
         };
 
-        let m = my_game::example::get_root_as_monster(b1.finished_data());
+        let m = my_game::example::root_as_monster(b1.finished_data()).unwrap();
 
         assert!(m.testnestedflatbuffer().is_some());
         assert_eq!(m.testnestedflatbuffer().unwrap(), b0.finished_data());
 
-        let m2_a = my_game::example::get_root_as_monster(m.testnestedflatbuffer().unwrap());
+        let m2_a = my_game::example::root_as_monster(m.testnestedflatbuffer().unwrap()).unwrap();
         assert_eq!(m2_a.hp(), 123);
         assert_eq!(m2_a.name(), "foobar");
 
@@ -751,11 +992,6 @@
     }
 
     #[test]
-    fn enum_color_is_aligned_to_1() {
-        assert_eq!(1, ::std::mem::align_of::<my_game::example::Color>());
-    }
-
-    #[test]
     fn union_any_is_1_byte() {
         assert_eq!(1, ::std::mem::size_of::<my_game::example::Any>());
     }
@@ -764,28 +1000,16 @@
     fn union_any_is_aligned_to_1() {
         assert_eq!(1, ::std::mem::align_of::<my_game::example::Any>());
     }
-
     #[test]
     fn struct_test_is_4_bytes() {
         assert_eq!(4, ::std::mem::size_of::<my_game::example::Test>());
     }
-
-    #[test]
-    fn struct_test_is_aligned_to_2() {
-        assert_eq!(2, ::std::mem::align_of::<my_game::example::Test>());
-    }
-
     #[test]
     fn struct_vec3_is_32_bytes() {
         assert_eq!(32, ::std::mem::size_of::<my_game::example::Vec3>());
     }
 
     #[test]
-    fn struct_vec3_is_aligned_to_8() {
-        assert_eq!(8, ::std::mem::align_of::<my_game::example::Vec3>());
-    }
-
-    #[test]
     fn struct_vec3_is_written_with_correct_alignment_in_table() {
         let b = &mut flatbuffers::FlatBufferBuilder::new();
         {
@@ -799,15 +1023,15 @@
             my_game::example::finish_monster_buffer(b, mon);
         }
         let buf = b.finished_data();
-        let mon = my_game::example::get_root_as_monster(buf);
+        let mon = my_game::example::root_as_monster(buf).unwrap();
         let vec3 = mon.pos().unwrap();
 
         let start_ptr = buf.as_ptr() as usize;
         let vec3_ptr = vec3 as *const my_game::example::Vec3 as usize;
 
         assert!(vec3_ptr > start_ptr);
-        let aln = ::std::mem::align_of::<my_game::example::Vec3>();
-        assert_eq!((vec3_ptr - start_ptr) % aln, 0);
+        // Vec3 is aligned to 8 wrt the flatbuffer.
+        assert_eq!((vec3_ptr - start_ptr) % 8, 0);
     }
 
     #[test]
@@ -816,11 +1040,6 @@
     }
 
     #[test]
-    fn struct_ability_is_aligned_to_4() {
-        assert_eq!(4, ::std::mem::align_of::<my_game::example::Ability>());
-    }
-
-    #[test]
     fn struct_ability_is_written_with_correct_alignment_in_table_vector() {
         let b = &mut flatbuffers::FlatBufferBuilder::new();
         {
@@ -835,7 +1054,7 @@
             my_game::example::finish_monster_buffer(b, mon);
         }
         let buf = b.finished_data();
-        let mon = my_game::example::get_root_as_monster(buf);
+        let mon = my_game::example::root_as_monster(buf).unwrap();
         let abilities = mon.testarrayofsortedstruct().unwrap();
 
         let start_ptr = buf.as_ptr() as usize;
@@ -848,14 +1067,15 @@
         for a in abilities.iter().rev() {
             let a_ptr = a as *const my_game::example::Ability as usize;
             assert!(a_ptr > start_ptr);
-            let aln = ::std::mem::align_of::<my_game::example::Ability>();
-            assert_eq!((a_ptr - start_ptr) % aln, 0);
+            // Vec3 is aligned to 8 wrt the flatbuffer.
+            assert_eq!((a_ptr - start_ptr) % 8, 0);
         }
     }
 }
 
 #[cfg(test)]
 mod roundtrip_byteswap {
+    #[cfg(not(miri))]  // slow.
     extern crate quickcheck;
     extern crate flatbuffers;
 
@@ -903,6 +1123,41 @@
     // fn fuzz_f64() { quickcheck::QuickCheck::new().max_tests(N).quickcheck(prop_f64 as fn(f64)); }
 }
 
+#[cfg(not(miri))]
+quickcheck! {
+  fn struct_of_structs(
+    a_id: u32,
+    a_distance: u32,
+    b_a: i16,
+    b_b: i8,
+    c_id: u32,
+    c_distance: u32
+  ) -> bool {
+    use my_game::example::*;
+    let mut sos = StructOfStructs::default();
+    let mut a = Ability::default();
+    a.set_id(a_id);
+    a.set_distance(a_distance);
+    let mut b = Test::default();
+    b.set_a(b_a);
+    b.set_b(b_b);
+    let mut c = Ability::default();
+    c.set_id(c_id);
+    c.set_distance(c_distance);
+    sos.set_a(&a);
+    sos.set_b(&b);
+    sos.set_c(&c);
+
+    sos.a().id() == a_id &&
+    sos.a().distance() == a_distance &&
+    sos.b().a() == b_a &&
+    sos.b().b() == b_b &&
+    sos.c().id() == c_id &&
+    sos.c().distance() == c_distance
+  }
+}
+
+#[cfg(not(miri))]  // slow.
 #[cfg(test)]
 mod roundtrip_vectors {
 
@@ -982,6 +1237,7 @@
 
     #[cfg(test)]
     mod create_vector_direct {
+        #[cfg(not(miri))]  // slow.
         extern crate quickcheck;
         extern crate flatbuffers;
 
@@ -1029,6 +1285,7 @@
 
     #[cfg(test)]
     mod string_manual_build {
+        #[cfg(not(miri))]  // slow.
         extern crate quickcheck;
         extern crate flatbuffers;
 
@@ -1066,6 +1323,7 @@
 
     #[cfg(test)]
     mod string_helper_build {
+        #[cfg(not(miri))]  // slow.
         extern crate quickcheck;
         extern crate flatbuffers;
 
@@ -1096,9 +1354,11 @@
 
     #[cfg(test)]
     mod ubyte {
+        #[cfg(not(miri))]  // slow.
         extern crate quickcheck;
         extern crate flatbuffers;
 
+        #[cfg(not(miri))]  // slow.
         #[test]
         fn fuzz_manual_build() {
             fn prop(vec: Vec<u8>) {
@@ -1142,7 +1402,7 @@
 
         // Access it.
         let buf = b.finished_data();
-        let m = flatbuffers::get_size_prefixed_root::<my_game::example::Monster>(buf);
+        let m = flatbuffers::size_prefixed_root::<my_game::example::Monster>(buf).unwrap();
         assert_eq!(m.mana(), 200);
         assert_eq!(m.hp(), 300);
         assert_eq!(m.name(), "bob");
@@ -1154,11 +1414,13 @@
     use std::collections::HashMap;
 
     extern crate flatbuffers;
+    #[cfg(not(miri))]  // slow.
     extern crate quickcheck;
 
     use super::LCG;
 
     #[test]
+    #[cfg(not(miri))]  // slow.
     fn table_of_mixed_scalars_fuzz() {
         // Values we're testing against: chosen to ensure no bits get chopped
         // off anywhere, and also be different from eachother.
@@ -1260,12 +1522,12 @@
         assert!(values_generated > 0);
         assert!(min_tests_per_choice > 0);
         for i in 0..test_value_types_max as u64 {
-            assert!(stats[&i] >= min_tests_per_choice,
-                    format!("inadequately-tested fuzz case: {}", i));
+            assert!(stats[&i] >= min_tests_per_choice, "inadequately-tested fuzz case: {}", i);
         }
     }
 
     #[test]
+    #[cfg(not(miri))]  // slow.
     fn table_of_byte_strings_fuzz() {
         fn prop(vec: Vec<Vec<u8>>) {
             use flatbuffers::field_index_to_field_offset as fi2fo;
@@ -1302,6 +1564,7 @@
     }
 
     #[test]
+    #[cfg(not(miri))]  // slow.
     fn fuzz_table_of_strings() {
         fn prop(vec: Vec<String>) {
             use flatbuffers::field_index_to_field_offset as fi2fo;
@@ -1333,8 +1596,10 @@
         quickcheck::QuickCheck::new().max_tests(n).quickcheck(prop as fn(Vec<String>));
     }
 
+    #[cfg(not(miri))]  // slow.
     mod table_of_vectors_of_scalars {
         extern crate flatbuffers;
+        #[cfg(not(miri))]  // slow.
         extern crate quickcheck;
 
         const N: u64 = 20;
@@ -1415,17 +1680,21 @@
     }
 }
 
+#[cfg(not(miri))]  // slow.
 #[cfg(test)]
 mod roundtrip_scalars {
     extern crate flatbuffers;
+    #[cfg(not(miri))]  // slow.
     extern crate quickcheck;
 
     const N: u64 = 1000;
 
     fn prop<T: PartialEq + ::std::fmt::Debug + Copy + flatbuffers::EndianScalar>(x: T) {
         let mut buf = vec![0u8; ::std::mem::size_of::<T>()];
-        flatbuffers::emplace_scalar(&mut buf[..], x);
-        let y = flatbuffers::read_scalar(&buf[..]);
+        let y = unsafe {
+            flatbuffers::emplace_scalar(&mut buf[..], x);
+            flatbuffers::read_scalar(&buf[..])
+        };
         assert_eq!(x, y);
     }
 
@@ -1458,8 +1727,10 @@
 }
 
 #[cfg(test)]
+#[cfg(not(miri))]  // slow.
 mod roundtrip_push_follow_scalars {
     extern crate flatbuffers;
+    #[cfg(not(miri))]  // slow.
     extern crate quickcheck;
 
     use flatbuffers::Push;
@@ -1538,7 +1809,7 @@
         create_serialized_example_with_generated_code(b);
         let buf = b.finished_data();
         serialized_example_is_accessible_and_correct(&buf, true, false).unwrap();
-        let m = super::my_game::example::get_root_as_monster(buf);
+        let m = super::my_game::example::root_as_monster(buf).unwrap();
         assert_eq!(
             format!("{:.5?}", &m),
             "Monster { pos: Some(Vec3 { x: 1.00000, y: 2.00000, z: 3.00000, \
@@ -1562,8 +1833,10 @@
             vector_of_non_owning_references: None, any_unique_type: NONE, \
             any_unique: None, any_ambiguous_type: NONE, any_ambiguous: None, \
             vector_of_enums: None, signed_enum: None, \
-            testrequirednestedflatbuffer: None }, test4: Some([Test { \
-            a: 10, b: 20 }, Test { a: 30, b: 40 }]), \
+            testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None, \
+            native_inline: None, long_enum_non_enum_default: (empty), \
+            long_enum_normal_default: LongOne }, \
+            test4: Some([Test { a: 10, b: 20 }, Test { a: 30, b: 40 }]), \
             testarrayofstring: Some([\"test1\", \"test2\"]), \
             testarrayoftables: None, enemy: None, testnestedflatbuffer: None, \
             testempty: None, testbool: false, testhashs32_fnv1: 0, \
@@ -1580,11 +1853,14 @@
             vector_of_non_owning_references: None, any_unique_type: NONE, \
             any_unique: None, any_ambiguous_type: NONE, any_ambiguous: None, \
             vector_of_enums: None, signed_enum: None, \
-            testrequirednestedflatbuffer: None }"
+            testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None, \
+            native_inline: None, long_enum_non_enum_default: (empty), \
+            long_enum_normal_default: LongOne }"
         );
     }
 
     #[test]
+    #[cfg(not(miri))]  // slow.
     fn generated_code_creates_correct_example_repeatedly_with_reset() {
         let b = &mut flatbuffers::FlatBufferBuilder::new();
         for _ in 0..100 {
@@ -1606,6 +1882,7 @@
     }
 
     #[test]
+    #[cfg(not(miri))]  // slow.
     fn library_code_creates_correct_example_repeatedly_with_reset() {
         let b = &mut flatbuffers::FlatBufferBuilder::new();
         for _ in 0..100 {
@@ -1728,7 +2005,7 @@
         let builder = &mut flatbuffers::FlatBufferBuilder::new();
         super::create_serialized_example_with_library_code(builder);
         let buf = builder.finished_data();
-        let a = my_game::example::get_root_as_monster(buf);
+        let a = my_game::example::root_as_monster(buf).unwrap();
 
         // preconditions
         assert_eq!(a.name(), "MyMonster");
@@ -1744,7 +2021,7 @@
         let builder = &mut flatbuffers::FlatBufferBuilder::new();
         super::create_serialized_example_with_library_code(builder);
         let buf = builder.finished_data();
-        let a = my_game::example::get_root_as_monster(buf);
+        let a = my_game::example::root_as_monster(buf).unwrap();
         let b = a.test_as_monster().unwrap();
 
         // preconditions
@@ -1761,23 +2038,17 @@
 
 #[cfg(test)]
 mod included_schema_generated_code {
-    extern crate flatbuffers;
 
-    //extern crate rust_usage_test;
+    #[test]
+    #[allow(unused_imports)]
+    fn namespace_test_mod_is_importable() {
+        use super::namespace_test_generated::{
+            namespace_a,
+            namespace_a::namespace_b,
+            namespace_c,
+        };
 
-    // TODO(rw): make generated sub-namespace files importable
-    //#[test]
-    //fn namespace_test_mod_is_importable() {
-    //    use rust_usage_test::namespace_test;
-    //}
-    //#[test]
-    //fn namespace_test1_mod_is_importable() {
-    //    use rust_usage_test::namespace_test::namespace_test1_generated;
-    //}
-    //#[test]
-    //fn namespace_test2_mod_is_importable() {
-    //    use rust_usage_test::namespace_test::namespace_test2_generated;
-    //}
+    }
 }
 
 #[cfg(test)]
@@ -1848,7 +2119,7 @@
     // Define a test struct to use in a few tests. This replicates the work that the code generator
     // would normally do when defining a FlatBuffer struct. For reference, compare the following
     // `FooStruct` code with the code generated for the `Vec3` struct in
-    // `../../monster_test_generated.rs`.
+    // `../../monster_test/mod.rs`.
     use flatbuffers::EndianScalar;
     #[derive(Copy, Clone, Debug, PartialEq)]
     #[repr(C, packed)]
@@ -1931,14 +2202,6 @@
         assert_eq!(off.self_follow(&vec[..], 4).safe_slice(), &[1, 2, 3][..]);
     }
 
-    #[cfg(target_endian = "little")]
-    #[test]
-    fn to_slice_of_u16() {
-        let vec: Vec<u8> = vec![255, 255, 255, 255, 2, 0, 0, 0, 1, 2, 3, 4];
-        let off: flatbuffers::FollowStart<&[u16]> = flatbuffers::FollowStart::new();
-        assert_eq!(off.self_follow(&vec[..], 4), &vec![513, 1027][..]);
-    }
-
     #[test]
     fn to_vector_of_u16() {
         let vec: Vec<u8> = vec![255, 255, 255, 255, 2, 0, 0, 0, 1, 2, 3, 4];
@@ -2271,6 +2534,7 @@
         ]);
     }
 
+    #[cfg(not(miri))]  // slow.
     #[test]
     fn many_identical_tables_use_few_vtables() {
         let mut b = flatbuffers::FlatBufferBuilder::new();
@@ -2347,7 +2611,7 @@
 
     #[test]
     fn layout_03b_11xbyte_vector_matches_builder_size() {
-        let mut b = flatbuffers::FlatBufferBuilder::new_with_capacity(12);
+        let mut b = flatbuffers::FlatBufferBuilder::with_capacity(12);
         b.start_vector::<u8>(8);
 
         let mut gold = vec![0u8; 0];
@@ -2951,4 +3215,51 @@
     f.read_to_end(&mut buf)?;
     Ok(buf)
 }
+
+#[test]
+fn test_shared_strings() {
+    let mut builder = flatbuffers::FlatBufferBuilder::new();
+    let offset1 = builder.create_shared_string("welcome to flatbuffers!!");
+    let offset2 = builder.create_shared_string("welcome");
+    let offset3 = builder.create_shared_string("welcome to flatbuffers!!");
+    assert_ne!(offset2.value(), offset3.value());
+    assert_eq!(offset1.value(), offset3.value());
+    builder.reset();
+    let offset4 = builder.create_shared_string("welcome");
+    let offset5 = builder.create_shared_string("welcome to flatbuffers!!");
+    assert_ne!(offset2.value(), offset4.value());
+    assert_ne!(offset5.value(), offset1.value());
+    builder.reset();
+
+    // Checks if the shared string function would always work with
+    // an object in between the writes
+    let name = builder.create_shared_string("foo");
+    let enemy = my_game::example::Monster::create(&mut builder, &my_game::example::MonsterArgs {
+        name: Some(name),
+        ..Default::default()
+    });
+    let secondary_name = builder.create_shared_string("foo");
+    assert_eq!(name.value(), secondary_name.value());
+
+    // Builds a new monster object and embeds enemy into it so we can verify
+    // that shared strings are working.
+    let args = my_game::example::MonsterArgs {
+        name: Some(secondary_name),
+        enemy: Some(enemy),
+        testarrayofstring: Some(builder.create_vector(&[name, secondary_name])),
+        ..Default::default()
+    };
+    // Building secondary monster
+    let main_monster = my_game::example::Monster::create(&mut builder, &args);
+    builder.finish(main_monster, None);
+    let monster = my_game::example::root_as_monster(builder.finished_data()).unwrap();
+
+    // Checks if the embedded object (Enemy) name is foo
+    assert_eq!(monster.enemy().unwrap().name(), "foo");
+    let string_vector = monster.testarrayofstring().unwrap();
+    // Check if the vector will have the same string
+    assert_eq!(string_vector.get(0), "foo");
+    assert_eq!(string_vector.get(1), "foo");
+}
+
 }
diff --git a/tests/rust_usage_test/tests/more_defaults_test.rs b/tests/rust_usage_test/tests/more_defaults_test.rs
new file mode 100644
index 0000000..af664f2
--- /dev/null
+++ b/tests/rust_usage_test/tests/more_defaults_test.rs
@@ -0,0 +1,30 @@
+#[allow(dead_code, unused_imports)]
+#[path = "../../more_defaults/mod.rs"]
+mod more_defaults_generated;
+use self::more_defaults_generated::*;
+
+#[test]
+fn object_defaults() {
+    assert_eq!(
+        MoreDefaultsT::default(),
+        MoreDefaultsT {
+            ints: Vec::new(),
+            floats: Vec::new(),
+            empty_string: "".to_string(),
+            some_string: "some".to_string(),
+            abcs: Vec::new(),
+            bools: Vec::new(),
+        },
+    )
+}
+
+#[test]
+fn nonpresent_values() {
+    let m = flatbuffers::root::<MoreDefaults>(&[0; 4]).unwrap();
+    assert_eq!(m.ints().len(), 0);
+    assert_eq!(m.floats().len(), 0);
+    assert_eq!(m.abcs().len(), 0);
+    assert_eq!(m.bools().len(), 0);
+    assert_eq!(m.empty_string(), "");
+    assert_eq!(m.some_string(), "some");
+}
diff --git a/tests/rust_usage_test/tests/optional_scalars_test.rs b/tests/rust_usage_test/tests/optional_scalars_test.rs
index f029d03..f8588c5 100644
--- a/tests/rust_usage_test/tests/optional_scalars_test.rs
+++ b/tests/rust_usage_test/tests/optional_scalars_test.rs
@@ -1,5 +1,5 @@
 #[allow(dead_code, unused_imports)]
-#[path = "../../optional_scalars_generated.rs"]
+#[path = "../../optional_scalars/mod.rs"]
 mod optional_scalars_generated;
 use crate::optional_scalars_generated::optional_scalars::*;
 
@@ -27,16 +27,26 @@
             );
             builder.finish(ss, None);
 
-            let s = flatbuffers::get_root::<ScalarStuff>(builder.finished_data());
+            let s = flatbuffers::root::<ScalarStuff>(builder.finished_data()).unwrap();
             assert_eq!(s.$just(), $five);
             assert_eq!(s.$default(), $five);
             assert_eq!(s.$maybe(), Some($five));
 
             // Test defaults are used when not specified.
-            let s = flatbuffers::get_root::<ScalarStuff>(&[0; 8]);
+            let s = flatbuffers::root::<ScalarStuff>(&[0; 8]).unwrap();
             assert_eq!(s.$just(), $zero);
             assert_eq!(s.$default(), $fortytwo);
             assert_eq!(s.$maybe(), None);
+
+            // Same for object API
+            let s = flatbuffers::root::<ScalarStuff>(builder.finished_data()).unwrap().unpack();
+            assert_eq!(s.$just, $five);
+            assert_eq!(s.$default, $five);
+            assert_eq!(s.$maybe, Some($five));
+            let s = flatbuffers::root::<ScalarStuff>(&[0; 8]).unwrap().unpack();
+            assert_eq!(s.$just, $zero);
+            assert_eq!(s.$default, $fortytwo);
+            assert_eq!(s.$maybe, None);
         }
     };
 }
@@ -85,3 +95,55 @@
      OptionalByte::None,
      OptionalByte::One
 );
+
+#[test]
+fn object_api_defaults() {
+    assert_eq!(
+        ScalarStuffT::default(),
+        ScalarStuffT {
+            just_i8: 0,
+            maybe_i8: None,
+            default_i8: 42,
+            just_u8: 0,
+            maybe_u8: None,
+            default_u8: 42,
+
+            just_i16: 0,
+            maybe_i16: None,
+            default_i16: 42,
+            just_u16: 0,
+            maybe_u16: None,
+            default_u16: 42,
+
+            just_i32: 0,
+            maybe_i32: None,
+            default_i32: 42,
+            just_u32: 0,
+            maybe_u32: None,
+            default_u32: 42,
+
+            just_i64: 0,
+            maybe_i64: None,
+            default_i64: 42,
+            just_u64: 0,
+            maybe_u64: None,
+            default_u64: 42,
+
+            just_f32: 0.0,
+            maybe_f32: None,
+            default_f32: 42.0,
+            just_f64: 0.0,
+            maybe_f64: None,
+            default_f64: 42.0,
+
+            just_bool: false,
+            maybe_bool: None,
+            default_bool: true,
+
+            just_enum: OptionalByte::None,
+            maybe_enum: None,
+            default_enum: OptionalByte::One,
+
+        }
+    );
+}