Vendor dependencies for 0.3.0 release

vendor/gltf/tests/roundtrip_binary_gltf.rs

@@ -0,0 +1,89 @@
+//! Roundtrip test.
+//!
+//! Read some binary glTF, write it to disk, and compare to the original.
+//! The test will succeed if the output is the same as the original.
+
+use std::io::Read;
+use std::{boxed, error, fs, io, path};
+
+const SAMPLE_MODELS_DIRECTORY_PATH: &str = "glTF-Sample-Assets/Models";
+
+fn run() -> Result<(), boxed::Box<dyn error::Error>> {
+    let mut all_tests_passed = true;
+    let mut nr_test_cases = 0;
+    for entry in fs::read_dir(SAMPLE_MODELS_DIRECTORY_PATH)? {
+        let entry = entry?;
+        let metadata = entry.metadata()?;
+        if metadata.is_dir() {
+            let entry_path = entry.path();
+            if let Some(file_name) = entry_path.file_name() {
+                let mut path = entry_path.join("glTF-Binary").join(file_name);
+                path.set_extension("glb");
+                if path.exists() {
+                    // not all models have binary versions
+                    if let Err(err) = test(&path) {
+                        println!("{:?}: error: {:?}", path, err);
+                        all_tests_passed = false;
+                    } else {
+                        println!("{:?}: ok", path);
+                        nr_test_cases += 1;
+                    }
+                }
+            }
+        }
+    }
+
+    if sparse_accessor_without_buffer_view_test() {
+        nr_test_cases += 1;
+    } else {
+        all_tests_passed = false;
+    }
+
+    assert!(all_tests_passed);
+    assert!(nr_test_cases >= 25);
+    Ok(())
+}
+
+fn test(path: &path::Path) -> Result<(), boxed::Box<dyn error::Error>> {
+    let file = fs::File::open(path)?;
+    let length = file.metadata()?.len() as usize;
+    let mut reader = io::BufReader::new(file);
+    let mut original = Vec::with_capacity(length);
+    reader.read_to_end(&mut original)?;
+
+    // Check from_reader/to_vec implementation.
+    {
+        let glb = gltf::binary::Glb::from_reader(io::Cursor::new(&original))?;
+        let output = glb.to_vec()?;
+        assert_eq!(&original, &output);
+    }
+
+    // Check from_slice/to_writer implementation.
+    {
+        let glb = gltf::binary::Glb::from_slice(&original)?;
+        let mut output = Vec::with_capacity(length);
+        glb.to_writer(&mut output as &mut dyn io::Write)?;
+        assert_eq!(&original, &output);
+    }
+
+    Ok(())
+}
+
+/// Test a file with a sparse accessor with no buffer view.
+///
+/// Return true if the test passes, and false otherwise.
+fn sparse_accessor_without_buffer_view_test() -> bool {
+    let path = path::Path::new("tests/box_sparse.glb");
+    if let Err(err) = test(path) {
+        println!("{:?}: error: {:?}", path, err);
+        false
+    } else {
+        println!("{:?}: ok", path);
+        true
+    }
+}
+
+#[test]
+fn roundtrip_binary_gltf() {
+    run().expect("test failure");
+}