Use nullptr instead of NULL.

cast size_t to uint_64_t for rapidjson serialization

.github/workflows/c-cpp.yml

@@ -0,0 +1,165 @@
+name: C/C++ CI
+
+on: [push, pull_request]
+
+jobs:
+
+  # compile with older gcc4.8
+  build-gcc48:
+
+    runs-on: ubuntu-18.04
+    name: Build with gcc 4.8
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Build
+        run: |
+            sudo apt-get update
+            sudo apt-get install -y build-essential
+            sudo apt-get install -y gcc-4.8 g++-4.8
+            g++-4.8 -std=c++11 -o loader_example loader_example.cc
+
+      - name: NoexceptBuild
+        run: |
+            g++-4.8 -DTINYGLTF_NOEXCEPTION -std=c++11 -o loader_example loader_example.cc
+
+      - name: RapidjsonBuild
+        run: |
+            git clone https://github.com/Tencent/rapidjson
+            g++-4.8 -DTINYGLTF_USE_RAPIDJSON -I./rapidjson/include/rapidjson -std=c++11 -o loader_example loader_example.cc
+
+  # compile with mingw gcc cross
+  build-mingw-cross:
+
+    runs-on: ubuntu-18.04
+    name: Build with MinGW gcc cross
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Build
+        run: |
+            sudo apt-get update
+            sudo apt-get install -y build-essential
+            sudo apt-get install -y mingw-w64
+            x86_64-w64-mingw32-g++ -std=c++11 -o loader_example loader_example.cc
+
+  # Windows(x64) + Visual Studio 2019 build
+  build-windows-msvc:
+
+    runs-on: windows-latest
+    name: Build for Windows(x64, MSVC)
+
+    # Use system installed cmake
+    # https://help.github.com/en/actions/reference/software-installed-on-github-hosted-runners
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+      - name: Configure
+        run: |
+          mkdir build
+          cd build
+          cmake -G "Visual Studio 16 2019" -DTINYGLTF_BUILD_LOADER_EXAMPLE=On -DTINYGLTF_BUILD_GL_EXAMPLES=Off -DTINYGLTF_BUILD_VALIDATOR_EXAMPLE=On ..
+          cd ..
+      - name: Build
+        run: cmake --build build --config Release
+
+
+  build-linux:
+
+    runs-on: ubuntu-latest
+    name: Buld with gcc
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: build
+      run: |
+        g++ -std=c++11 -o loader_example loader_example.cc
+    - name: test
+      run: |
+        ./loader_example models/Cube/Cube.gltf
+
+    - name: tests
+      run: |
+        cd tests
+        g++ -I../  -std=c++11 -g -O0 -o tester tester.cc
+        ./tester
+        cd ..
+
+    - name: noexcept_tests
+      run: |
+        cd tests
+        g++ -DTINYGLTF_NOEXCEPTION -I../  -std=c++11 -g -O0 -o tester_noexcept tester.cc
+        ./tester_noexcept
+        cd ..
+
+
+  build-rapidjson-linux:
+
+    runs-on: ubuntu-latest
+    name: Buld with gcc + rapidjson
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: build
+      run: |
+        git clone https://github.com/Tencent/rapidjson
+        g++ -v
+        g++ -DTINYGLTF_USE_RAPIDJSON -I./rapidjson/include/rapidjson -std=c++11 -o loader_example loader_example.cc
+
+    - name: loader_example_test
+      run: |
+        ./loader_example models/Cube/Cube.gltf
+
+    - name: tests
+      run: |
+        cd tests
+        g++ -DTINYGLTF_USE_RAPIDJSON -I../rapidjson/include/rapidjson -I../  -std=c++11 -g -O0 -o tester tester.cc
+        ./tester
+        cd ..
+
+    - name: noexcept_tests
+      run: |
+        cd tests
+        g++ -DTINYGLTF_USE_RAPIDJSON -I../rapidjson/include/rapidjson -DTINYGLTF_NOEXCEPTION -I../  -std=c++11 -g -O0 -o tester_noexcept tester.cc
+        ./tester_noexcept
+        cd ..
+
+  # Cross-compile for aarch64 linux target
+  build-cross-aarch64:
+
+    runs-on: ubuntu-18.04
+    name: Build on cross aarch64
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+      - name: Build
+        run: |
+            sudo apt-get update
+            sudo apt-get install -y build-essential
+            sudo apt-get install -y gcc-8-aarch64-linux-gnu g++-8-aarch64-linux-gnu
+
+            git clone https://github.com/Tencent/rapidjson
+            aarch64-linux-gnu-g++-8 -DTINYGLTF_USE_RAPIDJSON -I./rapidjson/include/rapidjson -std=c++11 -g -O0 -o loader_example loader_example.cc
+
+  # macOS clang
+  build-macos:
+
+    runs-on: macos-latest
+    name: Build on macOS
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+      - name: Build
+        run: |
+            clang++ -std=c++11 -g -O0 -o loader_example loader_example.cc
+            ./loader_example models/Cube/Cube.gltf
+
+            git clone https://github.com/Tencent/rapidjson
+            clang++ -DTINYGLTF_USE_RAPIDJSON -I./rapidjson/include/rapidjson -std=c++11 -g -O0 -o loader_example loader_example.cc
+

.travis.yml

@@ -31,6 +31,17 @@ matrix:
   - addons: *1
     compiler: clang
     env: COMPILER_VERSION=3.9 BUILD_TYPE=Debug CFLAGS="-O0" CXXFLAGS="-O0"
+  - addons: &3
+      apt:
+        sources:
+        - ubuntu-toolchain-r-test
+        packages:
+        - g++-4.8
+    compiler: gcc
+    env: COMPILER_VERSION=4.8 BUILD_TYPE=Debug
+  - addons: *3
+    compiler: gcc
+    env: COMPILER_VERSION=4.8 BUILD_TYPE=Release
 
 before_install:
   - ./.travis-before-install.sh

CMakeLists.txt

@@ -4,14 +4,27 @@ PROJECT (tinygltf)
 
 SET(CMAKE_CXX_STANDARD 11)
 
-ADD_EXECUTABLE ( loader_example
-  loader_example.cc
-  )
+option(TINYGLTF_BUILD_LOADER_EXAMPLE "Build loader_example" ON)
+option(TINYGLTF_BUILD_GL_EXAMPLES "Build GL exampels(requires glfw, OpenGL, etc)" OFF)
+option(TINYGLTF_BUILD_VALIDATOR_EXAMPLE "Build validator exampe" OFF)
 
-ADD_SUBDIRECTORY ( examples/gltfutil )
-ADD_SUBDIRECTORY ( examples/glview )
-ADD_SUBDIRECTORY ( examples/validator )
+if (TINYGLTF_BUILD_LOADER_EXAMPLE)
+  ADD_EXECUTABLE ( loader_example
+    loader_example.cc
+    )
+endif (TINYGLTF_BUILD_LOADER_EXAMPLE)
 
+if (TINYGLTF_BUILD_GL_EXAMPLES)
+  ADD_SUBDIRECTORY ( examples/gltfutil )
+  ADD_SUBDIRECTORY ( examples/glview )
+endif (TINYGLTF_BUILD_GL_EXAMPLES)
+
+if (TINYGLTF_BUILD_VALIDATOR_EXAMPLE)
+  ADD_SUBDIRECTORY ( examples/validator )
+endif (TINYGLTF_BUILD_VALIDATOR_EXAMPLE)
+#
+# TinuGLTF is a header-only library, so no library build. just install header files.
+#
 INSTALL ( FILES
   json.hpp
   stb_image.h

README.md

@@ -19,6 +19,8 @@ If you are looking for old, C++03 version, please use `devel-picojson` branch.
 
 [![Build status](https://ci.appveyor.com/api/projects/status/warngenu9wjjhlm8?svg=true)](https://ci.appveyor.com/project/syoyo/tinygltf)
 
+![C/C++ CI](https://github.com/syoyo/tinygltf/workflows/C/C++%20CI/badge.svg)
+
 ## Features
 
 * Written in portable C++. C++-11 with STL dependency only.
@@ -34,8 +36,11 @@ If you are looking for old, C++03 version, please use `devel-picojson` branch.
 * Moderate parsing time and memory consumption.
 * glTF specification v2.0.0
   * [x] ASCII glTF
+    * [x] Load
+    * [x] Save
   * [x] Binary glTF(GLB)
-  * [x] PBR material description
+    * [x] Load
+    * [x] Save(.bin embedded .glb)
 * Buffers
   * [x] Parse BASE64 encoded embedded buffer data(DataURI).
   * [x] Load `.bin` file.
@@ -55,6 +60,7 @@ If you are looking for old, C++03 version, please use `devel-picojson` branch.
   * [x] Image save
 * Extensions
   * [x] Draco mesh decoding
+  * [ ] Draco mesh encoding
 
 ## Note on extension property
 
@@ -75,9 +81,11 @@ In extension(`ExtensionMap`), JSON number value is parsed as int or float(number
 * GLTF loader plugin for OGRE 2.1. Support for PBR materials via HLMS/PBS https://github.com/Ybalrid/Ogre_glTF
 * [TinyGltfImporter](http://doc.magnum.graphics/magnum/classMagnum_1_1Trade_1_1TinyGltfImporter.html) plugin for [Magnum](https://github.com/mosra/magnum), a lightweight and modular C++11/C++14 graphics middleware for games and data visualization.
 * [Diligent Engine](https://github.com/DiligentGraphics/DiligentEngine) - A modern cross-platform low-level graphics library and rendering framework
-* Lighthouse 2: a rendering framework for real-time ray tracing / path tracing experiments. https://github.com/jbikker/lighthouse2 
+* Lighthouse 2: a rendering framework for real-time ray tracing / path tracing experiments. https://github.com/jbikker/lighthouse2
 * [QuickLook GLTF](https://github.com/toshiks/glTF-quicklook) - quicklook plugin for macos. Also SceneKit wrapper for tinygltf.
 * [GlslViewer](https://github.com/patriciogonzalezvivo/glslViewer) - live GLSL coding for MacOS and Linux
+* [Vulkan-Samples](https://github.com/KhronosGroup/Vulkan-Samples) - The Vulkan Samples is collection of resources to help you develop optimized Vulkan applications.
+* [TDME2](https://github.com/andreasdr/tdme2) - TDME2 - ThreeDeeMiniEngine2 is a lightweight 3D engine including tools suited for 3D game development using C++11
 * Your projects here! (Please send PR)
 
 ## TODOs
@@ -159,14 +167,17 @@ if (!ret) {
 
 
 ### Saving gltTF 2.0 model
-* [ ] Buffers.
+
+* Buffers.
   * [x] To file
   * [x] Embedded
   * [ ] Draco compressed?
 * [x] Images
   * [x] To file
   * [x] Embedded
-* [ ] Binary(.glb)
+* Binary(.glb)
+  * [x] .bin embedded single .glb
+  * [ ] External .bin
 
 ## Running tests.
 
@@ -194,9 +205,17 @@ $ ./tester
 $ ./tester_noexcept
 ```
 
+### Fuzzing tests
+
+See `tests/fuzzer` for details.
+
+After running fuzzer on Ryzen9 3950X a week, at least `LoadASCIIFromString` looks safe except for out-of-memory error in Fuzzer.
+We may be better to introduce bounded memory size checking when parsing glTF data.
+
 ## Third party licenses
 
 * json.hpp : Licensed under the MIT License <http://opensource.org/licenses/MIT>. Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
 * stb_image : Public domain.
 * catch : Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved. Distributed under the Boost Software License, Version 1.0.
 * RapidJSON : Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved. http://rapidjson.org/
+* dlib(uridecode, uriencode) : Copyright (C) 2003  Davis E. King Boost Software License 1.0. http://dlib.net/dlib/server/server_http.cpp.html

examples/basic/README.md

@@ -19,3 +19,7 @@ $ make
 Plese use solution file located at `basic` folder.
 
 
+## Limitation
+
+There are so many limitations in this example(e.g. no PBR shader. the shader only shows texture of textures[0] if available).
+

examples/basic/main.cpp

@@ -100,42 +100,49 @@ std::map<int, GLuint> bindMesh(std::map<int, GLuint> vbos,
         std::cout << "vaa missing: " << attrib.first << std::endl;
     }
 
-    GLuint texid;
-    glGenTextures(1, &texid);
+    if (model.textures.size() > 0) {
+      // fixme: Use material's baseColor
+      tinygltf::Texture &tex = model.textures[0];
 
-    tinygltf::Texture &tex = model.textures[0];
-    tinygltf::Image &image = model.images[tex.source];
+      if (tex.source > -1) {
 
-    glBindTexture(GL_TEXTURE_2D, texid);
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+        GLuint texid;
+        glGenTextures(1, &texid);
 
-    GLenum format = GL_RGBA;
+        tinygltf::Image &image = model.images[tex.source];
 
-    if (image.component == 1) {
-      format = GL_RED;
-    } else if (image.component == 2) {
-      format = GL_RG;
-    } else if (image.component == 3) {
-      format = GL_RGB;
-    } else {
-      // ???
+        glBindTexture(GL_TEXTURE_2D, texid);
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+
+        GLenum format = GL_RGBA;
+
+        if (image.component == 1) {
+          format = GL_RED;
+        } else if (image.component == 2) {
+          format = GL_RG;
+        } else if (image.component == 3) {
+          format = GL_RGB;
+        } else {
+          // ???
+        }
+
+        GLenum type = GL_UNSIGNED_BYTE;
+        if (image.bits == 8) {
+          // ok
+        } else if (image.bits == 16) {
+          type = GL_UNSIGNED_SHORT;
+        } else {
+          // ???
+        }
+
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0,
+                     format, type, &image.image.at(0));
+      }
     }
-
-    GLenum type = GL_UNSIGNED_BYTE;
-    if (image.bits == 8) {
-      // ok
-    } else if (image.bits == 16) {
-      type = GL_UNSIGNED_SHORT;
-    } else {
-      // ???
-    }
-
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0,
-                 format, type, &image.image.at(0));
   }
 
   return vbos;
@@ -144,8 +151,12 @@ std::map<int, GLuint> bindMesh(std::map<int, GLuint> vbos,
 // bind models
 void bindModelNodes(std::map<int, GLuint> vbos, tinygltf::Model &model,
                     tinygltf::Node &node) {
-  bindMesh(vbos, model, model.meshes[node.mesh]);
+  if ((node.mesh >= 0) && (node.mesh < model.meshes.size())) {
+    bindMesh(vbos, model, model.meshes[node.mesh]);
+  }
+
   for (size_t i = 0; i < node.children.size(); i++) {
+    assert((node.children[i] >= 0) && (node.children[i] < model.nodes.size()));
     bindModelNodes(vbos, model, model.nodes[node.children[i]]);
   }
 }
@@ -157,6 +168,7 @@ GLuint bindModel(tinygltf::Model &model) {
 
   const tinygltf::Scene &scene = model.scenes[model.defaultScene];
   for (size_t i = 0; i < scene.nodes.size(); ++i) {
+    assert((scene.nodes[i] >= 0) && (scene.nodes[i] < model.nodes.size()));
     bindModelNodes(vbos, model, model.nodes[scene.nodes[i]]);
   }
 
@@ -182,7 +194,9 @@ void drawMesh(tinygltf::Model &model, tinygltf::Mesh &mesh) {
 
 // recursively draw node and children nodes of model
 void drawModelNodes(tinygltf::Model &model, tinygltf::Node &node) {
-  drawMesh(model, model.meshes[node.mesh]);
+  if ((node.mesh >= 0) && (node.mesh < model.meshes.size())) {
+    drawMesh(model, model.meshes[node.mesh]);
+  }
   for (size_t i = 0; i < node.children.size(); i++) {
     drawModelNodes(model, model.nodes[node.children[i]]);
   }

loader_example.cc

@@ -322,6 +322,15 @@ static void DumpStringIntMap(const std::map<std::string, int> &m, int indent) {
   }
 }
 
+static void DumpExtensions(const tinygltf::ExtensionMap &extension,
+                           const int indent) {
+  // TODO(syoyo): pritty print Value
+  for (auto &e : extension) {
+    std::cout << Indent(indent) << e.first << std::endl;
+    std::cout << PrintValue("extensions", e.second, indent + 1) << std::endl;
+  }
+}
+
 static void DumpPrimitive(const tinygltf::Primitive &primitive, int indent) {
   std::cout << Indent(indent) << "material : " << primitive.material
             << std::endl;
@@ -333,19 +342,23 @@ static void DumpPrimitive(const tinygltf::Primitive &primitive, int indent) {
             << std::endl;
   DumpStringIntMap(primitive.attributes, indent + 1);
 
+  DumpExtensions(primitive.extensions, indent);
   std::cout << Indent(indent) << "extras :" << std::endl
             << PrintValue("extras", primitive.extras, indent + 1) << std::endl;
-}
 
-static void DumpExtensions(const tinygltf::ExtensionMap &extension,
-                           const int indent) {
-  // TODO(syoyo): pritty print Value
-  for (auto &e : extension) {
-    std::cout << Indent(indent) << e.first << std::endl;
-    std::cout << PrintValue("extensions", e.second, indent + 1) << std::endl;
+  if (!primitive.extensions_json_string.empty()) {
+    std::cout << Indent(indent + 1) << "extensions(JSON string) = "
+              << primitive.extensions_json_string << "\n";
+  }
+
+  if (!primitive.extras_json_string.empty()) {
+    std::cout << Indent(indent + 1)
+              << "extras(JSON string) = " << primitive.extras_json_string
+              << "\n";
   }
 }
 
+
 static void DumpTextureInfo(const tinygltf::TextureInfo &texinfo,
                             const int indent) {
   std::cout << Indent(indent) << "index     : " << texinfo.index << "\n";
@@ -353,6 +366,17 @@ static void DumpTextureInfo(const tinygltf::TextureInfo &texinfo,
             << "\n";
   DumpExtensions(texinfo.extensions, indent + 1);
   std::cout << PrintValue("extras", texinfo.extras, indent + 1) << "\n";
+
+  if (!texinfo.extensions_json_string.empty()) {
+    std::cout << Indent(indent)
+              << "extensions(JSON string) = " << texinfo.extensions_json_string
+              << "\n";
+  }
+
+  if (!texinfo.extras_json_string.empty()) {
+    std::cout << Indent(indent)
+              << "extras(JSON string) = " << texinfo.extras_json_string << "\n";
+  }
 }
 
 static void DumpNormalTextureInfo(const tinygltf::NormalTextureInfo &texinfo,
@@ -546,6 +570,21 @@ static void Dump(const tinygltf::Model &model) {
       std::cout << Indent(2)
                 << "target       : " << PrintTarget(bufferView.target)
                 << std::endl;
+      std::cout << Indent(1) << "-------------------------------------\n";
+
+      DumpExtensions(bufferView.extensions, 1);
+      std::cout << PrintValue("extras", bufferView.extras, 2) << std::endl;
+
+      if (!bufferView.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << bufferView.extensions_json_string << "\n";
+      }
+
+      if (!bufferView.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << bufferView.extras_json_string
+                  << "\n";
+      }
     }
   }
 
@@ -556,6 +595,21 @@ static void Dump(const tinygltf::Model &model) {
       std::cout << Indent(1) << "name         : " << buffer.name << std::endl;
       std::cout << Indent(2) << "byteLength   : " << buffer.data.size()
                 << std::endl;
+      std::cout << Indent(1) << "-------------------------------------\n";
+
+      DumpExtensions(buffer.extensions, 1);
+      std::cout << PrintValue("extras", buffer.extras, 2) << std::endl;
+
+      if (!buffer.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << buffer.extensions_json_string << "\n";
+      }
+
+      if (!buffer.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << buffer.extras_json_string
+                  << "\n";
+      }
     }
   }
 
@@ -602,6 +656,17 @@ static void Dump(const tinygltf::Model &model) {
 
       DumpExtensions(material.extensions, 1);
       std::cout << PrintValue("extras", material.extras, 2) << std::endl;
+
+      if (!material.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << material.extensions_json_string << "\n";
+      }
+
+      if (!material.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << material.extras_json_string
+                  << "\n";
+      }
     }
   }
 
@@ -625,6 +690,18 @@ static void Dump(const tinygltf::Model &model) {
       std::cout << Indent(2) << "height    : " << image.height << std::endl;
       std::cout << Indent(2) << "component : " << image.component << std::endl;
       DumpExtensions(image.extensions, 1);
+      std::cout << PrintValue("extras", image.extras, 2) << std::endl;
+
+      if (!image.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << image.extensions_json_string << "\n";
+      }
+
+      if (!image.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << image.extras_json_string
+                  << "\n";
+      }
     }
   }
 
@@ -637,6 +714,18 @@ static void Dump(const tinygltf::Model &model) {
       std::cout << Indent(1) << "source         : " << texture.source
                 << std::endl;
       DumpExtensions(texture.extensions, 1);
+      std::cout << PrintValue("extras", texture.extras, 2) << std::endl;
+
+      if (!texture.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << texture.extensions_json_string << "\n";
+      }
+
+      if (!texture.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << texture.extras_json_string
+                  << "\n";
+      }
     }
   }
 
@@ -658,6 +747,20 @@ static void Dump(const tinygltf::Model &model) {
       std::cout << Indent(2)
                 << "wrapT        : " << PrintWrapMode(sampler.wrapT)
                 << std::endl;
+
+      DumpExtensions(sampler.extensions, 1);
+      std::cout << PrintValue("extras", sampler.extras, 2) << std::endl;
+
+      if (!sampler.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << sampler.extensions_json_string << "\n";
+      }
+
+      if (!sampler.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << sampler.extras_json_string
+                  << "\n";
+      }
     }
   }
 
@@ -690,6 +793,54 @@ static void Dump(const tinygltf::Model &model) {
                   << "znear         : " << camera.orthographic.znear
                   << std::endl;
       }
+
+      std::cout << Indent(1) << "-------------------------------------\n";
+
+      DumpExtensions(camera.extensions, 1);
+      std::cout << PrintValue("extras", camera.extras, 2) << std::endl;
+
+      if (!camera.extensions_json_string.empty()) {
+        std::cout << Indent(2) << "extensions(JSON string) = "
+                  << camera.extensions_json_string << "\n";
+      }
+
+      if (!camera.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << camera.extras_json_string
+                  << "\n";
+      }
+    }
+  }
+
+  {
+    std::cout << "skins(items=" << model.skins.size() << ")" << std::endl;
+    for (size_t i = 0; i < model.skins.size(); i++) {
+      const tinygltf::Skin &skin = model.skins[i];
+      std::cout << Indent(1) << "name         : " << skin.name << std::endl;
+      std::cout << Indent(2)
+                << "inverseBindMatrices   : " << skin.inverseBindMatrices
+                << std::endl;
+      std::cout << Indent(2) << "skeleton              : " << skin.skeleton
+                << std::endl;
+      std::cout << Indent(2)
+                << "joints                : " << PrintIntArray(skin.joints)
+                << std::endl;
+      std::cout << Indent(1) << "-------------------------------------\n";
+
+      DumpExtensions(skin.extensions, 1);
+      std::cout << PrintValue("extras", skin.extras, 2) << std::endl;
+
+      if (!skin.extensions_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extensions(JSON string) = " << skin.extensions_json_string
+                  << "\n";
+      }
+
+      if (!skin.extras_json_string.empty()) {
+        std::cout << Indent(2)
+                  << "extras(JSON string) = " << skin.extras_json_string
+                  << "\n";
+      }
     }
   }
 
@@ -707,6 +858,12 @@ int main(int argc, char **argv) {
     exit(1);
   }
 
+  // Store original JSON string for `extras` and `extensions`
+  bool store_original_json_for_extras_and_extensions = false;
+  if (argc > 2) {
+    store_original_json_for_extras_and_extensions = true;
+  }
+
   tinygltf::Model model;
   tinygltf::TinyGLTF gltf_ctx;
   std::string err;
@@ -714,6 +871,9 @@ int main(int argc, char **argv) {
   std::string input_filename(argv[1]);
   std::string ext = GetFilePathExtension(input_filename);
 
+  gltf_ctx.SetStoreOriginalJSONForExtrasAndExtensions(
+      store_original_json_for_extras_and_extensions);
+
   bool ret = false;
   if (ext.compare("glb") == 0) {
     std::cout << "Reading binary glTF" << std::endl;

models/CubeImageUriSpaces/CubeImageUriMultipleSpaces.gltf

@@ -0,0 +1,171 @@
+{
+  "asset": {
+    "version": "2.0"
+  },
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ],
+  "scene": 0,
+  "nodes": [
+    {
+      "mesh": 0
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 2,
+            "POSITION": 1,
+            "TEXCOORD_0": 3
+          },
+          "indices": 0,
+          "mode": 4,
+          "material": 0
+        }
+      ]
+    }
+  ],
+  "materials": [
+    {
+      "pbrMetallicRoughness": {
+        "baseColorTexture": {
+          "index": 0,
+          "texCoord": 0
+        },
+        "baseColorFactor": [
+          1,
+          1,
+          1,
+          1
+        ],
+        "metallicFactor": 1,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "alphaMode": "OPAQUE"
+    }
+  ],
+  "textures": [
+    {
+      "source": 0,
+      "sampler": 0
+    }
+  ],
+  "samplers": [
+    {
+      "wrapS": 33071,
+      "wrapT": 33071
+    }
+  ],
+  "images": [
+    {
+      "uri": " 2x2 image  has multiple      spaces.png"
+    }
+  ],
+  "accessors": [
+    {
+      "bufferView": 0,
+      "byteOffset": 0,
+      "componentType": 5121,
+      "count": 36,
+      "normalized": false,
+      "max": [
+        23
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "bufferView": 1,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        0.5,
+        0.5,
+        0.5
+      ],
+      "min": [
+        -0.5,
+        -0.5,
+        -0.5
+      ],
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 2,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        1,
+        1,
+        1
+      ],
+      "min": [
+        -1,
+        -1,
+        -1
+      ],
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 3,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        1,
+        1
+      ],
+      "min": [
+        0,
+        0
+      ],
+      "type": "VEC2"
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteOffset": 0,
+      "byteLength": 36
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 36,
+      "byteLength": 288
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 324,
+      "byteLength": 288
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 612,
+      "byteLength": 192
+    }
+  ],
+  "buffers": [
+    {
+      "byteLength": 804,
+      "uri": "CubeImageUriSpaces.bin"
+    }
+  ]
+}

models/CubeImageUriSpaces/CubeImageUriSpaces.gltf

@@ -0,0 +1,171 @@
+{
+  "asset": {
+    "version": "2.0"
+  },
+  "scenes": [
+    {
+      "nodes": [
+        0
+      ]
+    }
+  ],
+  "scene": 0,
+  "nodes": [
+    {
+      "mesh": 0
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 2,
+            "POSITION": 1,
+            "TEXCOORD_0": 3
+          },
+          "indices": 0,
+          "mode": 4,
+          "material": 0
+        }
+      ]
+    }
+  ],
+  "materials": [
+    {
+      "pbrMetallicRoughness": {
+        "baseColorTexture": {
+          "index": 0,
+          "texCoord": 0
+        },
+        "baseColorFactor": [
+          1,
+          1,
+          1,
+          1
+        ],
+        "metallicFactor": 1,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "alphaMode": "OPAQUE"
+    }
+  ],
+  "textures": [
+    {
+      "source": 0,
+      "sampler": 0
+    }
+  ],
+  "samplers": [
+    {
+      "wrapS": 33071,
+      "wrapT": 33071
+    }
+  ],
+  "images": [
+    {
+      "uri": "2x2 image has spaces.png"
+    }
+  ],
+  "accessors": [
+    {
+      "bufferView": 0,
+      "byteOffset": 0,
+      "componentType": 5121,
+      "count": 36,
+      "normalized": false,
+      "max": [
+        23
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "bufferView": 1,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        0.5,
+        0.5,
+        0.5
+      ],
+      "min": [
+        -0.5,
+        -0.5,
+        -0.5
+      ],
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 2,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        1,
+        1,
+        1
+      ],
+      "min": [
+        -1,
+        -1,
+        -1
+      ],
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 3,
+      "byteOffset": 0,
+      "componentType": 5126,
+      "count": 24,
+      "normalized": false,
+      "max": [
+        1,
+        1
+      ],
+      "min": [
+        0,
+        0
+      ],
+      "type": "VEC2"
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteOffset": 0,
+      "byteLength": 36
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 36,
+      "byteLength": 288
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 324,
+      "byteLength": 288
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 612,
+      "byteLength": 192
+    }
+  ],
+  "buffers": [
+    {
+      "byteLength": 804,
+      "uri": "CubeImageUriSpaces.bin"
+    }
+  ]
+}

models/Extensions-overwrite-issue261/issue-261.gltf

@@ -0,0 +1,376 @@
+{
+  "accessors": [
+    {
+      "bufferView": 0,
+      "componentType": 5126,
+      "count": 8,
+      "max": [
+        0.5,
+        0.5,
+        0.5
+      ],
+      "min": [
+        -0.5,
+        -0.5,
+        -0.5
+      ],
+      "type": "VEC3"
+    },
+    {
+      "bufferView": 1,
+      "componentType": 5125,
+      "count": 36,
+      "type": "SCALAR"
+    }
+  ],
+  "asset": {
+    "copyright": "NVIDIA Corporation",
+    "generator": "Iray glTF plugin",
+    "version": "2.0"
+  },
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteLength": 96,
+      "byteStride": 12
+    },
+    {
+      "buffer": 0,
+      "byteLength": 144,
+      "byteOffset": 96
+    }
+  ],
+  "buffers": [
+    {
+      "byteLength": 240,
+      "uri": "issue-261.bin"
+    }
+  ],
+  "cameras": [
+    {
+      "extensions": {
+        "NV_Iray": {
+          "mip_burn_highlights": 0.699999988079071,
+          "mip_burn_highlights_per_component": false,
+          "mip_camera_shutter": 4.0,
+          "mip_cm2_factor": 1.0,
+          "mip_crush_blacks": 0.5,
+          "mip_f_number": 1.0,
+          "mip_film_iso": 100.0,
+          "mip_gamma": 2.200000047683716,
+          "mip_saturation": 1.0,
+          "mip_vignetting": 0.00019999999494757503,
+          "mip_whitepoint": [
+            1.0,
+            1.0,
+            1.0,
+            1.0
+          ],
+          "tm_enable_tonemapper": true,
+          "tm_tonemapper": "mia_exposure_photographic"
+        }
+      },
+      "extras": {
+        "resolution": [
+          640,
+          480
+        ]
+      },
+      "name": "default",
+      "perspective": {
+        "aspectRatio": 1.3333333730697632,
+        "yfov": 0.9272952079772949,
+        "zfar": 1000.0,
+        "znear": 0.1
+      },
+      "type": "perspective"
+    }
+  ],
+  "extensions": {
+    "KHR_lights_punctual": {
+      "lights": [
+        {
+          "color": [
+            1.0,
+            1.0,
+            1.0
+          ],
+          "intensity": 1000.0,
+          "name": "light",
+          "type": "point"
+        }
+      ]
+    },
+    "NV_MDL": {
+      "modules": [
+        "mdl::base",
+        "mdl::nvidia::core_definitions",
+        "mdl::state"
+      ],
+      "shaders": [
+        {
+          "definition": "mdl::base::environment_spherical(texture_2d)",
+          "name": "env_shd"
+        },
+        {
+          "arguments": {
+            "base_color": [
+              0.0055217444896698,
+              0.36859095096588135,
+              0.0041161770932376385
+            ],
+            "normal=": 2
+          },
+          "definition": "mdl::nvidia::core_definitions::flex_material",
+          "name": "cube_instance_material"
+        },
+        {
+          "definition": "mdl::state::normal()",
+          "name": "mdl::state::normal_341"
+        },
+        {
+          "arguments": {
+            "base_color": [
+              0.0055217444896698,
+              0.36859095096588135,
+              0.0041161770932376385
+            ],
+            "normal=": 4
+          },
+          "definition": "mdl::nvidia::core_definitions::flex_material",
+          "name": "cube_instance_material"
+        },
+        {
+          "definition": "mdl::state::normal()",
+          "name": "mdl::state::normal_341"
+        }
+      ]
+    }
+  },
+  "extensionsUsed": [
+    "NV_MDL",
+    "NV_Iray",
+    "KHR_lights_punctual"
+  ],
+  "materials": [
+    {
+      "doubleSided": true,
+      "extras": {
+        "mdl_shader": 1
+      },
+      "name": "cube_instance_material",
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.0055217444896698,
+          0.36859095096588135,
+          0.0041161770932376385,
+          1.0
+        ]
+      }
+    }
+  ],
+  "meshes": [
+    {
+      "name": "cube",
+      "primitives": [
+        {
+          "attributes": {
+            "POSITION": 0
+          },
+          "indices": 1,
+          "material": 0,
+          "mode": 4
+        }
+      ]
+    }
+  ],
+  "nodes": [
+    {
+      "camera": 0,
+      "extensions": {
+        "NV_Iray": {
+          "iview:fkey": -1,
+          "iview:fov": 53.130104064941406,
+          "iview:interest": [
+            0.1342654824256897,
+            -0.14356137812137604,
+            0.037264324724674225
+          ],
+          "iview:position": [
+            0.9729073643684387,
+            1.2592438459396362,
+            2.4199187755584717
+          ],
+          "iview:roll": 0.0,
+          "iview:up": [
+            0.0,
+            1.0,
+            0.0
+          ]
+        }
+      },
+      "matrix": [
+        0.9432751389105357,
+        -1.1769874756875739e-16,
+        -0.3320120665176343,
+        0.0,
+        -0.16119596696756341,
+        0.8742297945345237,
+        -0.45797175303889276,
+        0.0,
+        0.290254840694694,
+        0.48551237507207207,
+        0.8246392308792816,
+        0.0,
+        0.9729073377709113,
+        1.2592438262175363,
+        2.419918748461627,
+        1.0
+      ],
+      "name": "CamInst"
+    },
+    {
+      "extensions": {
+        "NV_Iray": {
+          "caustic": true,
+          "caustic_cast": true,
+          "caustic_recv": true,
+          "face_back": true,
+          "face_front": true,
+          "finalgather": true,
+          "finalgather_cast": true,
+          "finalgather_recv": true,
+          "globillum": true,
+          "globillum_cast": true,
+          "globillum_recv": true,
+          "material=": 3,
+          "pickable": true,
+          "reflection_cast": true,
+          "reflection_recv": true,
+          "refraction_cast": true,
+          "refraction_recv": true,
+          "shadow_cast": true,
+          "shadow_recv": true,
+          "transparency_cast": true,
+          "transparency_recv": true,
+          "visible": true
+        }
+      },
+      "mesh": 0,
+      "name": "cube_instance"
+    },
+    {
+      "extensions": {
+        "KHR_lights_punctual": {
+          "light": 0
+        },
+        "NV_Iray": {
+          "shadow_cast": true,
+          "visible": false
+        }
+      },
+      "matrix": [
+        0.6988062355563571,
+        -7.76042172309776e-17,
+        -0.7153110128800992,
+        -0.0,
+        -0.4276881690736487,
+        0.8015668284138362,
+        -0.41781987700564616,
+        -0.0,
+        0.57336957992379,
+        0.5979051928078428,
+        0.5601398979107212,
+        0.0,
+        2.3640632834071384,
+        2.465226204472449,
+        2.309515908392224,
+        1.0
+      ],
+      "name": "light_inst"
+    }
+  ],
+  "scene": 0,
+  "scenes": [
+    {
+      "extensions": {
+        "NV_Iray": {
+          "CP_canny_threshold1": 40,
+          "CP_canny_threshold2": 120,
+          "CP_color_quantization": 8,
+          "IVP_color": [
+            1.0,
+            0.0,
+            0.0,
+            1.0
+          ],
+          "TM_drago_bias": 0.8500000238418579,
+          "TM_drago_gamma2": 2.200000047683716,
+          "TM_drago_saturation": 1.0,
+          "TM_durand_contrast": 4.0,
+          "TM_durand_gamma": 2.200000047683716,
+          "TM_durand_saturation": 1.0,
+          "TM_durand_sigma_color": 2.0,
+          "TM_durand_sigma_space": 2.0,
+          "TM_linear_gamma": 2.200000047683716,
+          "TM_reinhard_color_adapt": 0.8999999761581421,
+          "TM_reinhard_gamma": 1.0,
+          "TM_reinhard_intensity": 0.0,
+          "TM_reinhard_light_adapt": 1.0,
+          "TM_reye_Ywhite": 1000000.0,
+          "TM_reye_bsize": 2,
+          "TM_reye_bthres": 3.0,
+          "TM_reye_gamma": 2.200000047683716,
+          "TM_reye_key": 0.5,
+          "TM_reye_saturation": 1.0,
+          "TM_reye_whitebalance": [
+            1.0,
+            0.9965101480484009,
+            0.9805564880371094,
+            0.0
+          ],
+          "environment_dome_depth": 200.0,
+          "environment_dome_height": 200.0,
+          "environment_dome_mode": "infinite",
+          "environment_dome_position": [
+            0.0,
+            0.0,
+            0.0
+          ],
+          "environment_dome_radius": 100.0,
+          "environment_dome_rotation_angle": 0.0,
+          "environment_dome_width": 200.0,
+          "environment_function=": 0,
+          "environment_function_intensity": 1.9900000095367432,
+          "iray_instancing": "off",
+          "iview::inline_color": [
+            1.0,
+            0.0,
+            0.0,
+            1.0
+          ],
+          "iview::inline_width": 1.0,
+          "iview::magnifier_size": 300,
+          "iview::offset": 10.0,
+          "iview::outline_color": [
+            0.0,
+            0.0,
+            0.0,
+            1.0
+          ],
+          "iview::outline_width": 2.0,
+          "iview::overview": true,
+          "iview::zoom_factor": 1.0,
+          "samples": 4.0,
+          "shadow_cast": true,
+          "shadow_recv": true
+        }
+      },
+      "nodes": [
+        0,
+        1,
+        2
+      ]
+    }
+  ]
+}

tests/fuzzer/README.md

@@ -0,0 +1,46 @@
+# Fuzzing test
+
+Do fuzzing test for TinyGLTF API.
+
+## Supported API
+
+* [x] LoadASCIIFromMemory
+* [ ] LoadBinaryFromMemory
+
+## Requirements
+
+* meson
+* clang with fuzzer support(`-fsanitize=fuzzer`. at least clang 8.0 should work)
+
+## Setup
+
+### Ubuntu 18.04
+
+```
+$ sudo apt install clang++-8
+$ sudo apt install libfuzzer-8-dev
+```
+
+Optionally, if you didn't set `update-alternatives` you can set `clang++` to point to `clang++8`
+
+```
+$ sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-8 10
+$ sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-8 10
+```
+
+## How to compile
+
+```
+$ CXX=clang++ CC=clang meson build
+$ cd build
+$ ninja
+```
+
+## How to run
+
+Increase memory limit. e.g. `-rss_limit_mb=50000`
+
+```
+$ ./fuzz_gltf -rss_limit_mb=20000 -jobs 4
+```
+

tests/fuzzer/fuzz_gltf.cc

@@ -0,0 +1,33 @@
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <vector>
+#include <iostream>
+
+#define STB_IMAGE_IMPLEMENTATION
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#define TINYGLTF_IMPLEMENTATION
+#include "tiny_gltf.h"
+
+static void parse_intCoding4(const uint8_t *data, size_t size)
+{
+
+  tinygltf::Model model;
+  tinygltf::TinyGLTF ctx;
+  std::string err;
+  std::string warn;
+
+  const char *str = reinterpret_cast<const char *>(data);
+
+  bool ret = ctx.LoadASCIIFromString(&model, &err, &warn, str, size, /* base_dir */"" );
+  (void)ret;
+
+}
+
+extern "C"
+int LLVMFuzzerTestOneInput(std::uint8_t const* data, std::size_t size)
+{
+    parse_intCoding4(data, size);
+    return 0;
+}
+

tests/fuzzer/meson.build

@@ -0,0 +1,9 @@
+project('fuzz_tinygltf', 'cpp', default_options : ['cpp_std=c++11'])
+
+incdirs = include_directories('../../')
+executable('fuzz_gltf',
+  'fuzz_gltf.cc',
+  include_directories : incdirs,
+  cpp_args : '-fsanitize=address,fuzzer',
+  link_args : '-fsanitize=address,fuzzer' )
+

tests/tester.cc

@@ -93,6 +93,59 @@ TEST_CASE("extension-with-empty-object", "[issue-97]") {
 
 }
 
+TEST_CASE("extension-overwrite", "[issue-261]") {
+
+  tinygltf::Model model;
+  tinygltf::TinyGLTF ctx;
+  std::string err;
+  std::string warn;
+
+  bool ret = ctx.LoadASCIIFromFile(&model, &err, &warn, "../models/Extensions-overwrite-issue261/issue-261.gltf");
+  if (!err.empty()) {
+    std::cerr << err << std::endl;
+  }
+  REQUIRE(true == ret);
+
+  REQUIRE(model.extensionsUsed.size() == 3);
+  {
+    bool has_ext_lights = false;
+    has_ext_lights |= (model.extensionsUsed[0].compare("KHR_lights_punctual") == 0);
+    has_ext_lights |= (model.extensionsUsed[1].compare("KHR_lights_punctual") == 0);
+    has_ext_lights |= (model.extensionsUsed[2].compare("KHR_lights_punctual") == 0);
+
+    REQUIRE(true == has_ext_lights);
+  }
+
+  {
+    REQUIRE(model.extensions.size() == 2);
+    REQUIRE(model.extensions.count("NV_MDL"));
+    REQUIRE(model.extensions.count("KHR_lights_punctual"));
+  }
+
+  // TODO(syoyo): create temp directory.
+  {
+    ret = ctx.WriteGltfSceneToFile(&model, "issue-261.gltf", true, true);
+    REQUIRE(true == ret);
+
+    tinygltf::Model m;
+
+    // read back serialized glTF
+    bool ret = ctx.LoadASCIIFromFile(&m, &err, &warn, "issue-261.gltf");
+    if (!err.empty()) {
+      std::cerr << err << std::endl;
+    }
+    REQUIRE(true == ret);
+
+    REQUIRE(m.extensionsUsed.size() == 3);
+
+    REQUIRE(m.extensions.size() == 2);
+    REQUIRE(m.extensions.count("NV_MDL"));
+    REQUIRE(m.extensions.count("KHR_lights_punctual"));
+
+  }
+
+}
+
 TEST_CASE("invalid-primitive-indices", "[bounds-checking]") {
   tinygltf::Model model;
   tinygltf::TinyGLTF ctx;
@@ -333,3 +386,45 @@ TEST_CASE("pbr-khr-texture-transform", "[material]") {
   REQUIRE(scale[1] == Approx(-1.0));
 
 }
+
+TEST_CASE("image-uri-spaces", "[issue-236]") {
+
+  tinygltf::Model model;
+  tinygltf::TinyGLTF ctx;
+  std::string err;
+  std::string warn;
+
+  // Test image file with single spaces.
+  bool ret = ctx.LoadASCIIFromFile(&model, &err, &warn, "../models/CubeImageUriSpaces/CubeImageUriSpaces.gltf");
+  if (!err.empty()) {
+    std::cerr << err << std::endl;
+  }
+
+  REQUIRE(true == ret);
+
+  // Test image file with a beginning space, trailing space, and greater than
+  // one consecutive spaces.
+  ret = ctx.LoadASCIIFromFile(&model, &err, &warn, "../models/CubeImageUriSpaces/CubeImageUriMultipleSpaces.gltf");
+  if (!err.empty()) {
+    std::cerr << err << std::endl;
+  }
+
+  REQUIRE(true == ret);
+}
+
+#ifndef TINYGLTF_NO_FS
+TEST_CASE("expandpath-utf-8", "[pr-226]") {
+
+  std::string s1 = "\xe5\xaf\xb9"; // utf-8 string
+
+  std::string ret = tinygltf::ExpandFilePath(s1, /* userdata */nullptr);
+
+  // expected: E5 AF B9
+  REQUIRE(3 == ret.size());
+
+  REQUIRE(0xe5 == static_cast<uint8_t>(ret[0]));
+  REQUIRE(0xaf == static_cast<uint8_t>(ret[1]));
+  REQUIRE(0xb9 == static_cast<uint8_t>(ret[2]));
+
+}
+#endif