--- /dev/null
+---
+# BasedOnStyle: Google
+AccessModifierOffset: -1
+ConstructorInitializerIndentWidth: 4
+AlignEscapedNewlinesLeft: true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakTemplateDeclarations: true
+AlwaysBreakBeforeMultilineStrings: true
+BreakBeforeBinaryOperators: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BinPackParameters: true
+ColumnLimit: 80
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+DerivePointerBinding: true
+ExperimentalAutoDetectBinPacking: false
+IndentCaseLabels: true
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 60
+PenaltyBreakString: 1000
+PenaltyBreakFirstLessLess: 120
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerBindsToType: true
+SpacesBeforeTrailingComments: 2
+Cpp11BracedListStyle: true
+Standard: Cpp11
+IndentWidth: 2
+TabWidth: 8
+UseTab: Never
+BreakBeforeBraces: Attach
+IndentFunctionDeclarationAfterType: true
+SpacesInParentheses: false
+SpacesInAngles: false
+SpaceInEmptyParentheses: false
+SpacesInCStyleCastParentheses: false
+SpaceAfterControlStatementKeyword: true
+SpaceBeforeAssignmentOperators: true
+ContinuationIndentWidth: 4
+...
+
--- /dev/null
+# CodeDocs.xyz Configuration File
+
+# Optional project name, if left empty the GitHub repository name will be used.
+PROJECT_NAME =
+
+# One or more directories and files that contain example code to be included.
+EXAMPLE_PATH =
+
+# One or more directories and files to exclude from documentation generation.
+# Use relative paths with respect to the repository root directory.
+EXCLUDE = test/gtest-1.8.0/
+
+# One or more wildcard patterns to exclude files and directories from document
+# generation.
+EXCLUDE_PATTERNS =
+
+# One or more symbols to exclude from document generation. Symbols can be
+# namespaces, classes, or functions.
+EXCLUDE_SYMBOLS =
+
+# Override the default parser (language) used for each file extension.
+EXTENSION_MAPPING =
+
+# Set the wildcard patterns used to filter out the source-files.
+# If left blank the default is:
+# *.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl,
+# *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php,
+# *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, *.md, *.mm, *.dox, *.py,
+# *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, *.qsf, *.as and *.js.
+FILE_PATTERNS =
+
+# Hide undocumented class members.
+HIDE_UNDOC_MEMBERS =
+
+# Hide undocumented classes.
+HIDE_UNDOC_CLASSES =
+
+# Specify a markdown page whose contents should be used as the main page
+# (index.html). This will override a page marked as \mainpage. For example, a
+# README.md file usually serves as a useful main page.
+USE_MDFILE_AS_MAINPAGE = README.md
+
+# Specify external repository to link documentation with.
+# This is similar to Doxygen's TAGFILES option, but will automatically link to
+# tags of other repositories already using CodeDocs. List each repository to
+# link with by giving its location in the form of owner/repository.
+# For example:
+# TAGLINKS = doxygen/doxygen CodeDocs/osg
+# Note: these repositories must already be built on CodeDocs.
+TAGLINKS =
--- /dev/null
+name: Github PR
+on:
+ push:
+ branches: [ master ]
+ pull_request:
+ branches: [ master ]
+ workflow_dispatch:
+permissions: read-all
+jobs:
+ cmake-build:
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [ubuntu-latest, windows-latest, macos-latest]
+ build: [static, shared]
+ generator: ["Default Generator", "MinGW Makefiles"]
+ exclude:
+ - os: macos-latest
+ build: shared
+ - os: macos-latest
+ generator: "MinGW Makefiles"
+ - os: ubuntu-latest
+ generator: "MinGW Makefiles"
+ env:
+ YAML_BUILD_SHARED_LIBS: ${{ matrix.build == 'shared' && 'ON' || 'OFF' }}
+ YAML_CPP_BUILD_TESTS: 'ON'
+ CMAKE_GENERATOR: >-
+ ${{format(matrix.generator != 'Default Generator' && '-G "{0}"' || '', matrix.generator)}}
+ runs-on: ${{ matrix.os }}
+ steps:
+ - uses: actions/checkout@v2
+
+ - name: Get number of CPU cores
+ uses: SimenB/github-actions-cpu-cores@v1
+
+ - name: Build
+ shell: bash
+ run: |
+ cmake ${{ env.CMAKE_GENERATOR }} -S "${{ github.workspace }}" -B build -DYAML_BUILD_SHARED_LIBS=${{ env.YAML_BUILD_SHARED_LIBS }}
+ cd build && cmake --build . --parallel ${{ steps.cpu-cores.outputs.count }}
+
+ - name: Build Tests
+ shell: bash
+ run: |
+ cmake ${{ env.CMAKE_GENERATOR }} -S "${{ github.workspace }}" -B build -DYAML_BUILD_SHARED_LIBS=${{ env.YAML_BUILD_SHARED_LIBS }} -DYAML_CPP_BUILD_TESTS=${{ env.YAML_CPP_BUILD_TESTS }}
+ cd build && cmake --build . --parallel ${{ steps.cpu-cores.outputs.count }}
+
+ - name: Run Tests
+ shell: bash
+ run: |
+ cd build && ctest -C Debug --output-on-failure --verbose
+
+ bazel-build:
+ strategy:
+ matrix:
+ os: [ubuntu-latest, windows-latest, macos-latest]
+ runs-on: ${{ matrix.os }}
+ steps:
+ - uses: actions/checkout@v2
+
+ - name: Build
+ shell: bash
+ run: |
+ cd "${{ github.workspace }}"
+ bazel build :all
+
+ - name: Test
+ shell: bash
+ run: |
+ cd "${{ github.workspace }}"
+ bazel test test
+
--- /dev/null
+build/
+/tags
+/bazel-*
--- /dev/null
+yaml_cpp_defines = select({
+ # On Windows, ensure static linking is used.
+ "@platforms//os:windows": ["YAML_CPP_STATIC_DEFINE", "YAML_CPP_NO_CONTRIB"],
+ "//conditions:default": [],
+})
+
+cc_library(
+ name = "yaml-cpp_internal",
+ visibility = ["//:__subpackages__"],
+ strip_include_prefix = "src",
+ hdrs = glob(["src/**/*.h"]),
+)
+
+cc_library(
+ name = "yaml-cpp",
+ visibility = ["//visibility:public"],
+ includes = ["include"],
+ hdrs = glob(["include/**/*.h"]),
+ srcs = glob(["src/**/*.cpp", "src/**/*.h"]),
+ defines = yaml_cpp_defines,
+)
--- /dev/null
+# 3.5 is actually available almost everywhere, but this a good minimum
+cmake_minimum_required(VERSION 3.4)
+
+# enable MSVC_RUNTIME_LIBRARY target property
+# see https://cmake.org/cmake/help/latest/policy/CMP0091.html
+if(POLICY CMP0091)
+ cmake_policy(SET CMP0091 NEW)
+endif()
+
+project(YAML_CPP VERSION 0.8.0 LANGUAGES CXX)
+
+set(YAML_CPP_MAIN_PROJECT OFF)
+if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+ set(YAML_CPP_MAIN_PROJECT ON)
+endif()
+
+include(CMakePackageConfigHelpers)
+include(CMakeDependentOption)
+include(CheckCXXCompilerFlag)
+include(GNUInstallDirs)
+include(CTest)
+
+option(YAML_CPP_BUILD_CONTRIB "Enable yaml-cpp contrib in library" ON)
+option(YAML_CPP_BUILD_TOOLS "Enable parse tools" ON)
+option(YAML_BUILD_SHARED_LIBS "Build yaml-cpp shared library" ${BUILD_SHARED_LIBS})
+option(YAML_CPP_INSTALL "Enable generation of yaml-cpp install targets" ${YAML_CPP_MAIN_PROJECT})
+option(YAML_CPP_FORMAT_SOURCE "Format source" ON)
+cmake_dependent_option(YAML_CPP_BUILD_TESTS
+ "Enable yaml-cpp tests" OFF
+ "BUILD_TESTING;YAML_CPP_MAIN_PROJECT" OFF)
+cmake_dependent_option(YAML_MSVC_SHARED_RT
+ "MSVC: Build yaml-cpp with shared runtime libs (/MD)" ON
+ "CMAKE_SYSTEM_NAME MATCHES Windows" OFF)
+
+if (YAML_CPP_FORMAT_SOURCE)
+ find_program(YAML_CPP_CLANG_FORMAT_EXE NAMES clang-format)
+endif()
+
+if (YAML_BUILD_SHARED_LIBS)
+ set(yaml-cpp-type SHARED)
+ set(yaml-cpp-label-postfix "shared")
+else()
+ set(yaml-cpp-type STATIC)
+ set(yaml-cpp-label-postfix "static")
+endif()
+
+set(build-shared $<BOOL:${YAML_BUILD_SHARED_LIBS}>)
+set(build-windows-dll $<AND:$<BOOL:${CMAKE_HOST_WIN32}>,${build-shared}>)
+set(not-msvc $<NOT:$<CXX_COMPILER_ID:MSVC>>)
+set(msvc-shared_rt $<BOOL:${YAML_MSVC_SHARED_RT}>)
+
+if (NOT DEFINED CMAKE_MSVC_RUNTIME_LIBRARY)
+ set(CMAKE_MSVC_RUNTIME_LIBRARY
+ MultiThreaded$<$<CONFIG:Debug>:Debug>$<${msvc-shared_rt}:DLL>)
+endif()
+
+set(contrib-pattern "src/contrib/*.cpp")
+set(src-pattern "src/*.cpp")
+if (CMAKE_VERSION VERSION_GREATER 3.12)
+ list(INSERT contrib-pattern 0 CONFIGURE_DEPENDS)
+ list(INSERT src-pattern 0 CONFIGURE_DEPENDS)
+endif()
+
+file(GLOB yaml-cpp-contrib-sources ${contrib-pattern})
+file(GLOB yaml-cpp-sources ${src-pattern})
+
+set(msvc-rt $<TARGET_PROPERTY:MSVC_RUNTIME_LIBRARY>)
+
+set(msvc-rt-mtd-static $<STREQUAL:${msvc-rt},MultiThreadedDebug>)
+set(msvc-rt-mt-static $<STREQUAL:${msvc-rt},MultiThreaded>)
+
+set(msvc-rt-mtd-dll $<STREQUAL:${msvc-rt},MultiThreadedDebugDLL>)
+set(msvc-rt-mt-dll $<STREQUAL:${msvc-rt},MultiThreadedDLL>)
+
+set(backport-msvc-runtime $<VERSION_LESS:${CMAKE_VERSION},3.15>)
+
+add_library(yaml-cpp ${yaml-cpp-type} "")
+add_library(yaml-cpp::yaml-cpp ALIAS yaml-cpp)
+
+set_property(TARGET yaml-cpp
+ PROPERTY
+ MSVC_RUNTIME_LIBRARY ${CMAKE_MSVC_RUNTIME_LIBRARY})
+set_property(TARGET yaml-cpp
+ PROPERTY
+ CXX_STANDARD_REQUIRED ON)
+
+if (NOT YAML_BUILD_SHARED_LIBS)
+ set_property(TARGET yaml-cpp PROPERTY POSITION_INDEPENDENT_CODE ON)
+endif()
+
+target_include_directories(yaml-cpp
+ PUBLIC
+ $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+ $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+ PRIVATE
+ $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>)
+
+if (NOT DEFINED CMAKE_CXX_STANDARD)
+ set_target_properties(yaml-cpp
+ PROPERTIES
+ CXX_STANDARD 11)
+endif()
+
+if(YAML_CPP_MAIN_PROJECT)
+ target_compile_options(yaml-cpp
+ PRIVATE
+ $<${not-msvc}:-Wall -Wextra -Wshadow -Weffc++ -Wno-long-long>
+ $<${not-msvc}:-pedantic -pedantic-errors>)
+endif()
+
+target_compile_options(yaml-cpp
+ PRIVATE
+ $<$<AND:${backport-msvc-runtime},${msvc-rt-mtd-static}>:-MTd>
+ $<$<AND:${backport-msvc-runtime},${msvc-rt-mt-static}>:-MT>
+ $<$<AND:${backport-msvc-runtime},${msvc-rt-mtd-dll}>:-MDd>
+ $<$<AND:${backport-msvc-runtime},${msvc-rt-mt-dll}>:-MD>
+
+ # /wd4127 = disable warning C4127 "conditional expression is constant"
+ # http://msdn.microsoft.com/en-us/library/6t66728h.aspx
+ # /wd4355 = disable warning C4355 "'this' : used in base member initializer list
+ # http://msdn.microsoft.com/en-us/library/3c594ae3.aspx
+ $<$<CXX_COMPILER_ID:MSVC>:/W3 /wd4127 /wd4355>)
+
+target_compile_definitions(yaml-cpp
+ PUBLIC
+ $<$<NOT:$<BOOL:${YAML_BUILD_SHARED_LIBS}>>:YAML_CPP_STATIC_DEFINE>
+ PRIVATE
+ $<${build-windows-dll}:${PROJECT_NAME}_DLL>
+ $<$<NOT:$<BOOL:${YAML_CPP_BUILD_CONTRIB}>>:YAML_CPP_NO_CONTRIB>)
+
+target_sources(yaml-cpp
+ PRIVATE
+ $<$<BOOL:${YAML_CPP_BUILD_CONTRIB}>:${yaml-cpp-contrib-sources}>
+ ${yaml-cpp-sources})
+
+if (NOT DEFINED CMAKE_DEBUG_POSTFIX)
+ set(CMAKE_DEBUG_POSTFIX "d")
+endif()
+
+set_target_properties(yaml-cpp PROPERTIES
+ VERSION "${PROJECT_VERSION}"
+ SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}"
+ PROJECT_LABEL "yaml-cpp ${yaml-cpp-label-postfix}"
+ DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}")
+
+set(CONFIG_EXPORT_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/yaml-cpp")
+set(EXPORT_TARGETS yaml-cpp)
+configure_package_config_file(
+ "${PROJECT_SOURCE_DIR}/yaml-cpp-config.cmake.in"
+ "${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake"
+ INSTALL_DESTINATION "${CONFIG_EXPORT_DIR}"
+ PATH_VARS CMAKE_INSTALL_INCLUDEDIR CMAKE_INSTALL_LIBDIR CONFIG_EXPORT_DIR YAML_BUILD_SHARED_LIBS)
+unset(EXPORT_TARGETS)
+
+write_basic_package_version_file(
+ "${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake"
+ COMPATIBILITY AnyNewerVersion)
+
+configure_file(yaml-cpp.pc.in yaml-cpp.pc @ONLY)
+
+if (YAML_CPP_INSTALL)
+ install(TARGETS yaml-cpp
+ EXPORT yaml-cpp-targets
+ RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+ LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+ ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+ install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/
+ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+ FILES_MATCHING PATTERN "*.h")
+ install(EXPORT yaml-cpp-targets
+ NAMESPACE yaml-cpp::
+ DESTINATION "${CONFIG_EXPORT_DIR}")
+ install(FILES
+ "${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake"
+ "${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake"
+ DESTINATION "${CONFIG_EXPORT_DIR}")
+ install(FILES "${PROJECT_BINARY_DIR}/yaml-cpp.pc"
+ DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+endif()
+unset(CONFIG_EXPORT_DIR)
+
+if(YAML_CPP_BUILD_TESTS)
+ add_subdirectory(test)
+endif()
+
+if(YAML_CPP_BUILD_TOOLS)
+ add_subdirectory(util)
+endif()
+
+if (YAML_CPP_FORMAT_SOURCE AND YAML_CPP_CLANG_FORMAT_EXE)
+ add_custom_target(format
+ COMMAND clang-format --style=file -i $<TARGET_PROPERTY:yaml-cpp,SOURCES>
+ COMMAND_EXPAND_LISTS
+ COMMENT "Running clang-format"
+ VERBATIM)
+endif()
+
+# uninstall target
+if(NOT TARGET uninstall)
+ configure_file(
+ "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
+ "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+ IMMEDIATE @ONLY)
+
+ add_custom_target(uninstall
+ COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+endif()
--- /dev/null
+# Style
+
+This project is formatted with [clang-format][fmt] using the style file at the root of the repository. Please run clang-format before sending a pull request.
+
+In general, try to follow the style of surrounding code. We mostly follow the [Google C++ style guide][cpp-style].
+
+Commit messages should be in the imperative mood, as described in the [Git contributing file][git-contrib]:
+
+> Describe your changes in imperative mood, e.g. "make xyzzy do frotz"
+> instead of "[This patch] makes xyzzy do frotz" or "[I] changed xyzzy
+> to do frotz", as if you are giving orders to the codebase to change
+> its behaviour.
+
+[fmt]: http://clang.llvm.org/docs/ClangFormat.html
+[cpp-style]: https://google.github.io/styleguide/cppguide.html
+[git-contrib]: http://git.kernel.org/cgit/git/git.git/tree/Documentation/SubmittingPatches?id=HEAD
+
+# Tests
+
+Please verify the tests pass by running the target `test/yaml-cpp-tests`.
+
+If you are adding functionality, add tests accordingly.
+
+# Pull request process
+
+Every pull request undergoes a code review. Unfortunately, github's code review process isn't great, but we'll manage. During the code review, if you make changes, add new commits to the pull request for each change. Once the code review is complete, rebase against the master branch and squash into a single commit.
--- /dev/null
+Copyright (c) 2008-2015 Jesse Beder.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
--- /dev/null
+# yaml-cpp  [](https://codedocs.xyz/jbeder/yaml-cpp/)
+
+`yaml-cpp` is a [YAML](http://www.yaml.org/) parser and emitter in C++ matching the [YAML 1.2 spec](http://www.yaml.org/spec/1.2/spec.html).
+
+## Usage
+
+See [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial) and [How to Emit YAML](https://github.com/jbeder/yaml-cpp/wiki/How-To-Emit-YAML) for reference. For the old API (until 0.5.0), see [How To Parse A Document](https://github.com/jbeder/yaml-cpp/wiki/How-To-Parse-A-Document-(Old-API)).
+
+## Any Problems?
+
+If you find a bug, post an [issue](https://github.com/jbeder/yaml-cpp/issues)! If you have questions about how to use yaml-cpp, please post it on http://stackoverflow.com and tag it [`yaml-cpp`](http://stackoverflow.com/questions/tagged/yaml-cpp).
+
+## How to Build
+
+`yaml-cpp` uses [CMake](http://www.cmake.org) to support cross-platform building. Install [CMake](http://www.cmake.org) _(Resources -> Download)_ before proceeding. The basic steps to build are:
+
+**Note:** If you don't use the provided installer for your platform, make sure that you add `CMake`'s bin folder to your path.
+
+#### 1. Navigate into the source directory, create build folder and run `CMake`:
+
+```sh
+mkdir build
+cd build
+cmake [-G generator] [-DYAML_BUILD_SHARED_LIBS=on|OFF] ..
+```
+
+ * The `generator` option is the build system you'd like to use. Run `cmake` without arguments to see a full list of available generators.
+ * On Windows, you might use "Visual Studio 12 2013" (VS 2013 32-bits), or "Visual Studio 14 2015 Win64" (VS 2015 64-bits).
+ * On OS X, you might use "Xcode".
+ * On a UNIX-like system, omit the option (for a Makefile).
+
+ * `yaml-cpp` builds a static library by default, you may want to build a shared library by specifying `-DYAML_BUILD_SHARED_LIBS=ON`.
+
+ * For more options on customizing the build, see the [CMakeLists.txt](https://github.com/jbeder/yaml-cpp/blob/master/CMakeLists.txt) file.
+
+#### 2. Build it!
+ * The command you'll need to run depends on the generator you chose earlier.
+
+**Note:** To clean up, just remove the `build` directory.
+
+## Recent Releases
+
+[yaml-cpp 0.6.0](https://github.com/jbeder/yaml-cpp/releases/tag/yaml-cpp-0.6.0) released! This release requires C++11, and no longer depends on Boost.
+
+[yaml-cpp 0.3.0](https://github.com/jbeder/yaml-cpp/releases/tag/release-0.3.0) is still available if you want the old API.
+
+**The old API will continue to be supported, and will still receive bugfixes!** The 0.3.x and 0.4.x versions will be old API releases, and 0.5.x and above will all be new API releases.
+
+# API Documentation
+
+The autogenerated API reference is hosted on [CodeDocs](https://codedocs.xyz/jbeder/yaml-cpp/index.html)
+
+# Third Party Integrations
+
+The following projects are not officially supported:
+
+- [Qt wrapper](https://gist.github.com/brcha/d392b2fe5f1e427cc8a6)
+- [UnrealEngine Wrapper](https://github.com/jwindgassen/UnrealYAML)
--- /dev/null
+# Security Policy
+
+## Supported Versions
+
+Security updates are applied only to the latest release.
+
+## Reporting a Vulnerability
+
+If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released.
+
+Please disclose it at [security advisory](https://github.com/jbeder/yaml-cpp/security/advisories/new).
+
+This project is maintained by a team of volunteers on a reasonable-effort basis. As such, vulnerabilities will be disclosed in a best effort base.
--- /dev/null
+workspace(name = "com_github_jbeder_yaml_cpp")
+
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+
+http_archive(
+ name = "com_google_googletest",
+ strip_prefix = "googletest-release-1.8.1",
+ url = "https://github.com/google/googletest/archive/release-1.8.1.tar.gz",
+ sha256 = "9bf1fe5182a604b4135edc1a425ae356c9ad15e9b23f9f12a02e80184c3a249c",
+)
--- /dev/null
+if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+ message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt")
+endif()
+
+file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
+string(REGEX REPLACE "\n" ";" files "${files}")
+foreach(file ${files})
+ message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
+ if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+ exec_program(
+ "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
+ OUTPUT_VARIABLE rm_out
+ RETURN_VALUE rm_retval
+ )
+ if(NOT "${rm_retval}" STREQUAL 0)
+ message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
+ endif()
+ else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+ message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
+ endif()
+endforeach()
--- /dev/null
+# The following is a list of breaking changes to yaml-cpp, by version #
+
+# New API #
+
+## HEAD ##
+
+ * Throws an exception when trying to parse a negative number as an unsigned integer.
+ * Supports the `as<int8_t>`/`as<uint8_t>`, which throws an exception when the value exceeds the range of `int8_t`/`uint8_t`.
+
+## 0.6.0 ##
+
+ * Requires C++11.
+
+## 0.5.3 ##
+
+_none_
+
+## 0.5.2 ##
+
+_none_
+
+## 0.5.1 ##
+
+ * `Node::clear` was replaced by `Node::reset`, which takes an optional node, similar to smart pointers.
+
+## 0.5.0 ##
+
+Initial version of the new API.
+
+# Old API #
+
+## 0.3.0 ##
+
+_none_
+
+## 0.2.7 ##
+
+ * `YAML::Binary` now takes `const unsigned char *` for the binary data (instead of `const char *`).
+
+## 0.2.6 ##
+
+ * `Node::GetType()` is now `Node::Type()`, and returns an enum `NodeType::value`, where:
+> > ` struct NodeType { enum value { Null, Scalar, Sequence, Map }; }; `
+ * `Node::GetTag()` is now `Node::Tag()`
+ * `Node::Identity()` is removed, and `Node::IsAlias()` and `Node::IsReferenced()` have been merged into `Node::IsAliased()`. The reason: there's no reason to distinguish an alias node from its anchor - whichever happens to be emitted first will be the anchor, and the rest will be aliases.
+ * `Node::Read<T>` is now `Node::to<T>`. This wasn't a documented function, so it shouldn't break anything.
+ * `Node`'s comparison operators (for example, `operator == (const Node&, const T&)`) have all been removed. These weren't documented either (they were just used for the tests), so this shouldn't break anything either.
+ * The emitter no longer produces the document start by default - if you want it, you can supply it with the manipulator `YAML::BeginDoc`.
+
+## 0.2.5 ##
+
+This wiki was started with v0.2.5.
\ No newline at end of file
--- /dev/null
+## Contents ##
+
+
+
+# Basic Emitting #
+
+The model for emitting YAML is `std::ostream` manipulators. A `YAML::Emitter` objects acts as an output stream, and its output can be retrieved through the `c_str()` function (as in `std::string`). For a simple example:
+
+```cpp
+#include "yaml-cpp/yaml.h"
+
+int main()
+{
+ YAML::Emitter out;
+ out << "Hello, World!";
+
+ std::cout << "Here's the output YAML:\n" << out.c_str(); // prints "Hello, World!"
+ return 0;
+}
+```
+
+# Simple Lists and Maps #
+
+A `YAML::Emitter` object acts as a state machine, and we use manipulators to move it between states. Here's a simple sequence:
+
+```cpp
+YAML::Emitter out;
+out << YAML::BeginSeq;
+out << "eggs";
+out << "bread";
+out << "milk";
+out << YAML::EndSeq;
+```
+
+produces
+
+```yaml
+- eggs
+- bread
+- milk
+```
+
+A simple map:
+
+```cpp
+YAML::Emitter out;
+out << YAML::BeginMap;
+out << YAML::Key << "name";
+out << YAML::Value << "Ryan Braun";
+out << YAML::Key << "position";
+out << YAML::Value << "LF";
+out << YAML::EndMap;
+```
+
+produces
+
+```yaml
+name: Ryan Braun
+position: LF
+```
+
+These elements can, of course, be nested:
+
+```cpp
+YAML::Emitter out;
+out << YAML::BeginMap;
+out << YAML::Key << "name";
+out << YAML::Value << "Barack Obama";
+out << YAML::Key << "children";
+out << YAML::Value << YAML::BeginSeq << "Sasha" << "Malia" << YAML::EndSeq;
+out << YAML::EndMap;
+```
+
+produces
+
+```yaml
+name: Barack Obama
+children:
+ - Sasha
+ - Malia
+```
+
+# Using Manipulators #
+
+To deviate from standard formatting, you can use manipulators to modify the output format. For example,
+
+```cpp
+YAML::Emitter out;
+out << YAML::Literal << "A\n B\n C";
+```
+
+produces
+
+```yaml
+|
+A
+ B
+ C
+```
+and
+
+```cpp
+YAML::Emitter out;
+out << YAML::Flow;
+out << YAML::BeginSeq << 2 << 3 << 5 << 7 << 11 << YAML::EndSeq;
+```
+
+produces
+
+```yaml
+[2, 3, 5, 7, 11]
+```
+
+Comments act like manipulators:
+
+```cpp
+YAML::Emitter out;
+out << YAML::BeginMap;
+out << YAML::Key << "method";
+out << YAML::Value << "least squares";
+out << YAML::Comment("should we change this method?");
+out << YAML::EndMap;
+```
+
+produces
+
+```yaml
+method: least squares # should we change this method?
+```
+
+And so do aliases/anchors:
+
+```cpp
+YAML::Emitter out;
+out << YAML::BeginSeq;
+out << YAML::Anchor("fred");
+out << YAML::BeginMap;
+out << YAML::Key << "name" << YAML::Value << "Fred";
+out << YAML::Key << "age" << YAML::Value << "42";
+out << YAML::EndMap;
+out << YAML::Alias("fred");
+out << YAML::EndSeq;
+```
+
+produces
+
+```yaml
+- &fred
+ name: Fred
+ age: 42
+- *fred
+```
+
+# STL Containers, and Other Overloads #
+We overload `operator <<` for `std::vector`, `std::list`, and `std::map`, so you can write stuff like:
+
+```cpp
+std::vector <int> squares;
+squares.push_back(1);
+squares.push_back(4);
+squares.push_back(9);
+squares.push_back(16);
+
+std::map <std::string, int> ages;
+ages["Daniel"] = 26;
+ages["Jesse"] = 24;
+
+YAML::Emitter out;
+out << YAML::BeginSeq;
+out << YAML::Flow << squares;
+out << ages;
+out << YAML::EndSeq;
+```
+
+produces
+
+```yaml
+- [1, 4, 9, 16]
+-
+ Daniel: 26
+ Jesse: 24
+```
+
+Of course, you can overload `operator <<` for your own types:
+
+```cpp
+struct Vec3 { int x; int y; int z; };
+YAML::Emitter& operator << (YAML::Emitter& out, const Vec3& v) {
+ out << YAML::Flow;
+ out << YAML::BeginSeq << v.x << v.y << v.z << YAML::EndSeq;
+ return out;
+}
+```
+and it'll play nicely with everything else.
+
+# Using Existing Nodes #
+
+We also overload `operator << ` for `YAML::Node`s in both APIs, so you can output existing Nodes. Of course, Nodes in the old API are read-only, so it's tricky to emit them if you want to modify them. So use the new API!
+
+# Output Encoding #
+
+The output is always UTF-8. By default, yaml-cpp will output as much as it can without escaping any characters. If you want to restrict the output to ASCII, use the manipulator `YAML::EscapeNonAscii`:
+
+```cpp
+emitter.SetOutputCharset(YAML::EscapeNonAscii);
+```
+
+# Lifetime of Manipulators #
+
+Manipulators affect the **next** output item in the stream. If that item is a `BeginSeq` or `BeginMap`, the manipulator lasts until the corresponding `EndSeq` or `EndMap`. (However, within that sequence or map, you can override the manipulator locally, etc.; in effect, there's a "manipulator stack" behind the scenes.)
+
+If you want to permanently change a setting, there are global setters corresponding to each manipulator, e.g.:
+
+```cpp
+YAML::Emitter out;
+out.SetIndent(4);
+out.SetMapStyle(YAML::Flow);
+```
+
+# When Something Goes Wrong #
+
+If something goes wrong when you're emitting a document, it must be something like forgetting a `YAML::EndSeq`, or a misplaced `YAML::Key`. In this case, emitting silently fails (no more output is emitted) and an error flag is set. For example:
+
+```cpp
+YAML::Emitter out;
+assert(out.good());
+out << YAML::Key;
+assert(!out.good());
+std::cout << "Emitter error: " << out.GetLastError() << "\n";
+```
\ No newline at end of file
--- /dev/null
+_The following describes the old API. For the new API, see the [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial)._
+
+## Contents ##
+
+
+# Basic Parsing #
+
+The parser accepts streams, not file names, so you need to first load the file. Since a YAML file can contain many documents, you can grab them one-by-one. A simple way to parse a YAML file might be:
+
+```
+#include <fstream>
+#include "yaml-cpp/yaml.h"
+
+int main()
+{
+ std::ifstream fin("test.yaml");
+ YAML::Parser parser(fin);
+
+ YAML::Node doc;
+ while(parser.GetNextDocument(doc)) {
+ // ...
+ }
+
+ return 0;
+}
+```
+
+# Reading From the Document #
+
+Suppose we have a document consisting only of a scalar. We can read that scalar like this:
+
+```
+YAML::Node doc; // let's say we've already parsed this document
+std::string scalar;
+doc >> scalar;
+std::cout << "That scalar was: " << scalar << std::endl;
+```
+
+How about sequences? Let's say our document now consists only of a sequences of scalars. We can use an iterator:
+
+```
+YAML::Node doc; // already parsed
+for(YAML::Iterator it=doc.begin();it!=doc.end();++it) {
+ std::string scalar;
+ *it >> scalar;
+ std::cout << "Found scalar: " << scalar << std::endl;
+}
+```
+
+... or we can just loop through:
+
+```
+YAML::Node doc; // already parsed
+for(unsigned i=0;i<doc.size();i++) {
+ std::string scalar;
+ doc[i] >> scalar;
+ std::cout << "Found scalar: " << scalar << std::endl;
+}
+```
+
+And finally maps. For now, let's say our document is a map with all keys/values being scalars. Again, we can iterate:
+
+```
+YAML::Node doc; // already parsed
+for(YAML::Iterator it=doc.begin();it!=doc.end();++it) {
+ std::string key, value;
+ it.first() >> key;
+ it.second() >> value;
+ std::cout << "Key: " << key << ", value: " << value << std::endl;
+}
+```
+
+Note that dereferencing a map iterator is undefined; instead, use the `first` and `second` methods to get the key and value nodes, respectively.
+
+Alternatively, we can pick off the values one-by-one, if we know the keys:
+
+```
+YAML::Node doc; // already parsed
+std::string name;
+doc["name"] >> name;
+int age;
+doc["age"] >> age;
+std::cout << "Found entry with name '" << name << "' and age '" << age << "'\n";
+```
+
+One thing to be keep in mind: reading a map by key (as immediately above) requires looping through all entries until we find the right key, which is an O(n) operation. So if you're reading the entire map this way, it'll be O(n^2). For small n, this isn't a big deal, but I wouldn't recommend reading maps with a very large number of entries (>100, say) this way.
+
+## Optional Keys ##
+
+If you try to access a key that doesn't exist, `yaml-cpp` throws an exception (see [When Something Goes Wrong](https://github.com/jbeder/yaml-cpp/wiki/How-To-Parse-A-Document-(Old-API)#When_Something_Goes_Wrong). If you have optional keys, it's often easier to use `FindValue` instead of `operator[]`:
+
+```
+YAML::Node doc; // already parsed
+if(const YAML::Node *pName = doc.FindValue("name")) {
+ std::string name;
+ *pName >> name;
+ std::cout << "Key 'name' exists, with value '" << name << "'\n";
+} else {
+ std::cout << "Key 'name' doesn't exist\n";
+}
+```
+
+# Getting More Complicated #
+
+The above three methods can be combined to read from an arbitrary document. But we can make life a lot easier. Suppose we're reading 3-vectors (i.e., vectors with three components), so we've got a structure looking like this:
+
+```
+struct Vec3 {
+ float x, y, z;
+};
+```
+
+We can read this in one operation by overloading the extraction (>>) operator:
+
+```
+void operator >> (const YAML::Node& node, Vec3& v)
+{
+ node[0] >> v.x;
+ node[1] >> v.y;
+ node[2] >> v.z;
+}
+
+// now it's a piece of cake to read it
+YAML::Node doc; // already parsed
+Vec3 v;
+doc >> v;
+std::cout << "Here's the vector: (" << v.x << ", " << v.y << ", " << v.z << ")\n";
+```
+
+# A Complete Example #
+
+Here's a complete example of how to parse a complex YAML file:
+
+`monsters.yaml`
+
+```
+- name: Ogre
+ position: [0, 5, 0]
+ powers:
+ - name: Club
+ damage: 10
+ - name: Fist
+ damage: 8
+- name: Dragon
+ position: [1, 0, 10]
+ powers:
+ - name: Fire Breath
+ damage: 25
+ - name: Claws
+ damage: 15
+- name: Wizard
+ position: [5, -3, 0]
+ powers:
+ - name: Acid Rain
+ damage: 50
+ - name: Staff
+ damage: 3
+```
+
+`main.cpp`
+
+```
+#include "yaml-cpp/yaml.h"
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+
+// our data types
+struct Vec3 {
+ float x, y, z;
+};
+
+struct Power {
+ std::string name;
+ int damage;
+};
+
+struct Monster {
+ std::string name;
+ Vec3 position;
+ std::vector <Power> powers;
+};
+
+// now the extraction operators for these types
+void operator >> (const YAML::Node& node, Vec3& v) {
+ node[0] >> v.x;
+ node[1] >> v.y;
+ node[2] >> v.z;
+}
+
+void operator >> (const YAML::Node& node, Power& power) {
+ node["name"] >> power.name;
+ node["damage"] >> power.damage;
+}
+
+void operator >> (const YAML::Node& node, Monster& monster) {
+ node["name"] >> monster.name;
+ node["position"] >> monster.position;
+ const YAML::Node& powers = node["powers"];
+ for(unsigned i=0;i<powers.size();i++) {
+ Power power;
+ powers[i] >> power;
+ monster.powers.push_back(power);
+ }
+}
+
+int main()
+{
+ std::ifstream fin("monsters.yaml");
+ YAML::Parser parser(fin);
+ YAML::Node doc;
+ parser.GetNextDocument(doc);
+ for(unsigned i=0;i<doc.size();i++) {
+ Monster monster;
+ doc[i] >> monster;
+ std::cout << monster.name << "\n";
+ }
+
+ return 0;
+}
+```
+
+# When Something Goes Wrong #
+
+... we throw an exception (all exceptions are derived from `YAML::Exception`). If there's a parsing exception (i.e., a malformed YAML document), we throw a `YAML::ParserException`:
+
+```
+try {
+ std::ifstream fin("test.yaml");
+ YAML::Parser parser(fin);
+ YAML::Node doc;
+ parser.GetNextDocument(doc);
+ // do stuff
+} catch(YAML::ParserException& e) {
+ std::cout << e.what() << "\n";
+}
+```
+
+If you make a programming error (say, trying to read a scalar from a sequence node, or grabbing a key that doesn't exist), we throw some kind of `YAML::RepresentationException`. To prevent this, you can check what kind of node something is:
+
+```
+ YAML::Node node;
+ YAML::NodeType::value type = node.Type(); // should be:
+ // YAML::NodeType::Null
+ // YAML::NodeType::Scalar
+ // YAML::NodeType::Sequence
+ // YAML::NodeType::Map
+```
+
+# Note about copying `YAML::Node` #
+
+Currently `YAML::Node` is non-copyable, so you need to do something like
+
+```
+ const YAML::Node& node = doc["whatever"];
+```
+
+This is intended behavior. If you want to copy a node, use the `Clone` function:
+
+```
+ std::auto_ptr<YAML::Node> pCopy = myOtherNode.Clone();
+```
+
+The intent is that if you'd like to keep a `YAML::Node` around for longer than the document will stay in scope, you can clone it and store it as long as you like.
\ No newline at end of file
--- /dev/null
+# Encodings and `yaml-cpp` #
+
+`yaml-cpp` will parse any file as specified by the [YAML 1.2 spec](http://www.yaml.org/spec/1.2/spec.html#id2570322). Internally, it stores all strings in UTF-8, and representation is done with UTF-8. This means that in
+
+```
+std::string str;
+node >> str;
+```
+
+`str` will be UTF-8. Similarly, if you're accessing a map by string key, you need to pass the key in UTF-8. If your application uses a different encoding, you need to convert to and from UTF-8 to work with `yaml-cpp`. (It's possible we'll add some small conversion functions, but for now it's restricted.)
+
+---
+
+For convenience, Richard Weeks has kindly provided a google gadget that converts Unicode to a string literal. It's a Google Gadget, so unfortunately it does not work on GitHub. Patches welcome to port it to a usable format here:
+
+```
+<wiki:gadget url="http://hosting.gmodules.com/ig/gadgets/file/111180078345548400783/c-style-utf8-encoder.xml"/>
+```
\ No newline at end of file
--- /dev/null
+# Introduction #
+
+A typical example, loading a configuration file, might look like this:
+
+```cpp
+YAML::Node config = YAML::LoadFile("config.yaml");
+
+if (config["lastLogin"]) {
+ std::cout << "Last logged in: " << config["lastLogin"].as<DateTime>() << "\n";
+}
+
+const std::string username = config["username"].as<std::string>();
+const std::string password = config["password"].as<std::string>();
+login(username, password);
+config["lastLogin"] = getCurrentDateTime();
+
+std::ofstream fout("config.yaml");
+fout << config;
+```
+
+# Basic Parsing and Node Editing #
+
+All nodes in a YAML document (including the root) are represented by `YAML::Node`. You can check what kind it is:
+
+```cpp
+YAML::Node node = YAML::Load("[1, 2, 3]");
+assert(node.Type() == YAML::NodeType::Sequence);
+assert(node.IsSequence()); // a shortcut!
+```
+
+Collection nodes (sequences and maps) act somewhat like STL vectors and maps:
+
+```cpp
+YAML::Node primes = YAML::Load("[2, 3, 5, 7, 11]");
+for (std::size_t i=0;i<primes.size();i++) {
+ std::cout << primes[i].as<int>() << "\n";
+}
+// or:
+for (YAML::const_iterator it=primes.begin();it!=primes.end();++it) {
+ std::cout << it->as<int>() << "\n";
+}
+
+primes.push_back(13);
+assert(primes.size() == 6);
+```
+
+and
+
+```cpp
+YAML::Node lineup = YAML::Load("{1B: Prince Fielder, 2B: Rickie Weeks, LF: Ryan Braun}");
+for(YAML::const_iterator it=lineup.begin();it!=lineup.end();++it) {
+ std::cout << "Playing at " << it->first.as<std::string>() << " is " << it->second.as<std::string>() << "\n";
+}
+
+lineup["RF"] = "Corey Hart";
+lineup["C"] = "Jonathan Lucroy";
+assert(lineup.size() == 5);
+```
+
+Querying for keys does **not** create them automatically (this makes handling optional map entries very easy)
+
+```cpp
+YAML::Node node = YAML::Load("{name: Brewers, city: Milwaukee}");
+if (node["name"]) {
+ std::cout << node["name"].as<std::string>() << "\n";
+}
+if (node["mascot"]) {
+ std::cout << node["mascot"].as<std::string>() << "\n";
+}
+assert(node.size() == 2); // the previous call didn't create a node
+```
+
+If you're not sure what kind of data you're getting, you can query the type of a node:
+
+```cpp
+switch (node.Type()) {
+ case Null: // ...
+ case Scalar: // ...
+ case Sequence: // ...
+ case Map: // ...
+ case Undefined: // ...
+}
+```
+
+or ask directly whether it's a particular type, e.g.:
+
+```cpp
+if (node.IsSequence()) {
+ // ...
+}
+```
+
+# Building Nodes #
+
+You can build `YAML::Node` from scratch:
+
+```cpp
+YAML::Node node; // starts out as null
+node["key"] = "value"; // it now is a map node
+node["seq"].push_back("first element"); // node["seq"] automatically becomes a sequence
+node["seq"].push_back("second element");
+
+node["mirror"] = node["seq"][0]; // this creates an alias
+node["seq"][0] = "1st element"; // this also changes node["mirror"]
+node["mirror"] = "element #1"; // and this changes node["seq"][0] - they're really the "same" node
+
+node["self"] = node; // you can even create self-aliases
+node[node["mirror"]] = node["seq"]; // and strange loops :)
+```
+
+The above node is now:
+
+```yaml
+&1
+key: value
+&2 seq: [&3 "element #1", second element]
+mirror: *3
+self: *1
+*3 : *2
+```
+
+# How Sequences Turn Into Maps #
+
+Sequences can be turned into maps by asking for non-integer keys. For example,
+
+```cpp
+YAML::Node node = YAML::Load("[1, 2, 3]");
+node[1] = 5; // still a sequence, [1, 5, 3]
+node.push_back(-3) // still a sequence, [1, 5, 3, -3]
+node["key"] = "value"; // now it's a map! {0: 1, 1: 5, 2: 3, 3: -3, key: value}
+```
+
+Indexing a sequence node by an index that's not in its range will _usually_ turn it into a map, but if the index is one past the end of the sequence, then the sequence will grow by one to accommodate it. (That's the **only** exception to this rule.) For example,
+
+```cpp
+YAML::Node node = YAML::Load("[1, 2, 3]");
+node[3] = 4; // still a sequence, [1, 2, 3, 4]
+node[10] = 10; // now it's a map! {0: 1, 1: 2, 2: 3, 3: 4, 10: 10}
+```
+
+# Converting To/From Native Data Types #
+
+Yaml-cpp has built-in conversion to and from most built-in data types, as well as `std::vector`, `std::list`, and `std::map`. The following examples demonstrate when those conversions are used:
+
+```cpp
+YAML::Node node = YAML::Load("{pi: 3.14159, [0, 1]: integers}");
+
+// this needs the conversion from Node to double
+double pi = node["pi"].as<double>();
+
+// this needs the conversion from double to Node
+node["e"] = 2.71828;
+
+// this needs the conversion from Node to std::vector<int> (*not* the other way around!)
+std::vector<int> v;
+v.push_back(0);
+v.push_back(1);
+std::string str = node[v].as<std::string>();
+```
+
+To use yaml-cpp with your own data types, you need to specialize the YAML::convert<> template class. For example, suppose you had a simple `Vec3` class:
+
+```cpp
+struct Vec3 { double x, y, z; /* etc - make sure you have overloaded operator== */ };
+```
+
+You could write
+
+```cpp
+namespace YAML {
+template<>
+struct convert<Vec3> {
+ static Node encode(const Vec3& rhs) {
+ Node node;
+ node.push_back(rhs.x);
+ node.push_back(rhs.y);
+ node.push_back(rhs.z);
+ return node;
+ }
+
+ static bool decode(const Node& node, Vec3& rhs) {
+ if(!node.IsSequence() || node.size() != 3) {
+ return false;
+ }
+
+ rhs.x = node[0].as<double>();
+ rhs.y = node[1].as<double>();
+ rhs.z = node[2].as<double>();
+ return true;
+ }
+};
+}
+```
+
+Then you could use `Vec3` wherever you could use any other type:
+
+```cpp
+YAML::Node node = YAML::Load("start: [1, 3, 0]");
+Vec3 v = node["start"].as<Vec3>();
+node["end"] = Vec3(2, -1, 0);
+```
\ No newline at end of file
--- /dev/null
+theme: jekyll-theme-slate
\ No newline at end of file
--- /dev/null
+To learn how to use the library, see the [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial) and [How To Emit YAML](https://github.com/jbeder/yaml-cpp/wiki/How-To-Emit-YAML)
--- /dev/null
+#ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstddef>
+
+namespace YAML {
+using anchor_t = std::size_t;
+const anchor_t NullAnchor = 0;
+}
+
+#endif // ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <vector>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+YAML_CPP_API std::string EncodeBase64(const unsigned char *data,
+ std::size_t size);
+YAML_CPP_API std::vector<unsigned char> DecodeBase64(const std::string &input);
+
+class YAML_CPP_API Binary {
+ public:
+ Binary(const unsigned char *data_, std::size_t size_)
+ : m_data{}, m_unownedData(data_), m_unownedSize(size_) {}
+ Binary() : Binary(nullptr, 0) {}
+ Binary(const Binary &) = default;
+ Binary(Binary &&) = default;
+ Binary &operator=(const Binary &) = default;
+ Binary &operator=(Binary &&) = default;
+
+ bool owned() const { return !m_unownedData; }
+ std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; }
+ const unsigned char *data() const {
+ return owned() ? &m_data[0] : m_unownedData;
+ }
+
+ void swap(std::vector<unsigned char> &rhs) {
+ if (m_unownedData) {
+ m_data.swap(rhs);
+ rhs.clear();
+ rhs.resize(m_unownedSize);
+ std::copy(m_unownedData, m_unownedData + m_unownedSize, rhs.begin());
+ m_unownedData = nullptr;
+ m_unownedSize = 0;
+ } else {
+ m_data.swap(rhs);
+ }
+ }
+
+ bool operator==(const Binary &rhs) const {
+ const std::size_t s = size();
+ if (s != rhs.size())
+ return false;
+ const unsigned char *d1 = data();
+ const unsigned char *d2 = rhs.data();
+ for (std::size_t i = 0; i < s; i++) {
+ if (*d1++ != *d2++)
+ return false;
+ }
+ return true;
+ }
+
+ bool operator!=(const Binary &rhs) const { return !(*this == rhs); }
+
+ private:
+ std::vector<unsigned char> m_data;
+ const unsigned char *m_unownedData;
+ std::size_t m_unownedSize;
+};
+} // namespace YAML
+
+#endif // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <vector>
+
+#include "../anchor.h"
+
+namespace YAML {
+/**
+ * An object that stores and retrieves values correlating to {@link anchor_t}
+ * values.
+ *
+ * <p>Efficient implementation that can make assumptions about how
+ * {@code anchor_t} values are assigned by the {@link Parser} class.
+ */
+template <class T>
+class AnchorDict {
+ public:
+ AnchorDict() : m_data{} {}
+ void Register(anchor_t anchor, T value) {
+ if (anchor > m_data.size()) {
+ m_data.resize(anchor);
+ }
+ m_data[anchor - 1] = value;
+ }
+
+ T Get(anchor_t anchor) const { return m_data[anchor - 1]; }
+
+ private:
+ std::vector<T> m_data;
+};
+} // namespace YAML
+
+#endif // ANCHORDICT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/mark.h"
+#include <string>
+
+namespace YAML {
+class Parser;
+
+// GraphBuilderInterface
+// . Abstraction of node creation
+// . pParentNode is always nullptr or the return value of one of the NewXXX()
+// functions.
+class GraphBuilderInterface {
+ public:
+ virtual ~GraphBuilderInterface() = 0;
+
+ // Create and return a new node with a null value.
+ virtual void *NewNull(const Mark &mark, void *pParentNode) = 0;
+
+ // Create and return a new node with the given tag and value.
+ virtual void *NewScalar(const Mark &mark, const std::string &tag,
+ void *pParentNode, const std::string &value) = 0;
+
+ // Create and return a new sequence node
+ virtual void *NewSequence(const Mark &mark, const std::string &tag,
+ void *pParentNode) = 0;
+
+ // Add pNode to pSequence. pNode was created with one of the NewXxx()
+ // functions and pSequence with NewSequence().
+ virtual void AppendToSequence(void *pSequence, void *pNode) = 0;
+
+ // Note that no moew entries will be added to pSequence
+ virtual void SequenceComplete(void *pSequence) { (void)pSequence; }
+
+ // Create and return a new map node
+ virtual void *NewMap(const Mark &mark, const std::string &tag,
+ void *pParentNode) = 0;
+
+ // Add the pKeyNode => pValueNode mapping to pMap. pKeyNode and pValueNode
+ // were created with one of the NewXxx() methods and pMap with NewMap().
+ virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) = 0;
+
+ // Note that no more assignments will be made in pMap
+ virtual void MapComplete(void *pMap) { (void)pMap; }
+
+ // Return the node that should be used in place of an alias referencing
+ // pNode (pNode by default)
+ virtual void *AnchorReference(const Mark &mark, void *pNode) {
+ (void)mark;
+ return pNode;
+ }
+};
+
+// Typesafe wrapper for GraphBuilderInterface. Assumes that Impl defines
+// Node, Sequence, and Map types. Sequence and Map must derive from Node
+// (unless Node is defined as void). Impl must also implement function with
+// all of the same names as the virtual functions in GraphBuilderInterface
+// -- including the ones with default implementations -- but with the
+// prototypes changed to accept an explicit Node*, Sequence*, or Map* where
+// appropriate.
+template <class Impl>
+class GraphBuilder : public GraphBuilderInterface {
+ public:
+ typedef typename Impl::Node Node;
+ typedef typename Impl::Sequence Sequence;
+ typedef typename Impl::Map Map;
+
+ GraphBuilder(Impl &impl) : m_impl(impl) {
+ Map *pMap = nullptr;
+ Sequence *pSeq = nullptr;
+ Node *pNode = nullptr;
+
+ // Type consistency checks
+ pNode = pMap;
+ pNode = pSeq;
+ }
+
+ GraphBuilderInterface &AsBuilderInterface() { return *this; }
+
+ virtual void *NewNull(const Mark &mark, void *pParentNode) {
+ return CheckType<Node>(m_impl.NewNull(mark, AsNode(pParentNode)));
+ }
+
+ virtual void *NewScalar(const Mark &mark, const std::string &tag,
+ void *pParentNode, const std::string &value) {
+ return CheckType<Node>(
+ m_impl.NewScalar(mark, tag, AsNode(pParentNode), value));
+ }
+
+ virtual void *NewSequence(const Mark &mark, const std::string &tag,
+ void *pParentNode) {
+ return CheckType<Sequence>(
+ m_impl.NewSequence(mark, tag, AsNode(pParentNode)));
+ }
+ virtual void AppendToSequence(void *pSequence, void *pNode) {
+ m_impl.AppendToSequence(AsSequence(pSequence), AsNode(pNode));
+ }
+ virtual void SequenceComplete(void *pSequence) {
+ m_impl.SequenceComplete(AsSequence(pSequence));
+ }
+
+ virtual void *NewMap(const Mark &mark, const std::string &tag,
+ void *pParentNode) {
+ return CheckType<Map>(m_impl.NewMap(mark, tag, AsNode(pParentNode)));
+ }
+ virtual void AssignInMap(void *pMap, void *pKeyNode, void *pValueNode) {
+ m_impl.AssignInMap(AsMap(pMap), AsNode(pKeyNode), AsNode(pValueNode));
+ }
+ virtual void MapComplete(void *pMap) { m_impl.MapComplete(AsMap(pMap)); }
+
+ virtual void *AnchorReference(const Mark &mark, void *pNode) {
+ return CheckType<Node>(m_impl.AnchorReference(mark, AsNode(pNode)));
+ }
+
+ private:
+ Impl &m_impl;
+
+ // Static check for pointer to T
+ template <class T, class U>
+ static T *CheckType(U *p) {
+ return p;
+ }
+
+ static Node *AsNode(void *pNode) { return static_cast<Node *>(pNode); }
+ static Sequence *AsSequence(void *pSeq) {
+ return static_cast<Sequence *>(pSeq);
+ }
+ static Map *AsMap(void *pMap) { return static_cast<Map *>(pMap); }
+};
+
+void *BuildGraphOfNextDocument(Parser &parser,
+ GraphBuilderInterface &graphBuilder);
+
+template <class Impl>
+typename Impl::Node *BuildGraphOfNextDocument(Parser &parser, Impl &impl) {
+ GraphBuilder<Impl> graphBuilder(impl);
+ return static_cast<typename Impl::Node *>(
+ BuildGraphOfNextDocument(parser, graphBuilder));
+}
+}
+
+#endif // GRAPHBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef DEPTH_GUARD_H_00000000000000000000000000000000000000000000000000000000
+#define DEPTH_GUARD_H_00000000000000000000000000000000000000000000000000000000
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "exceptions.h"
+
+namespace YAML {
+
+/**
+ * @brief The DeepRecursion class
+ * An exception class which is thrown by DepthGuard. Ideally it should be
+ * a member of DepthGuard. However, DepthGuard is a templated class which means
+ * that any catch points would then need to know the template parameters. It is
+ * simpler for clients to not have to know at the catch point what was the
+ * maximum depth.
+ */
+class DeepRecursion : public ParserException {
+public:
+ virtual ~DeepRecursion() = default;
+
+ DeepRecursion(int depth, const Mark& mark_, const std::string& msg_);
+
+ // Returns the recursion depth when the exception was thrown
+ int depth() const {
+ return m_depth;
+ }
+
+private:
+ int m_depth = 0;
+};
+
+/**
+ * @brief The DepthGuard class
+ * DepthGuard takes a reference to an integer. It increments the integer upon
+ * construction of DepthGuard and decrements the integer upon destruction.
+ *
+ * If the integer would be incremented past max_depth, then an exception is
+ * thrown. This is ideally geared toward guarding against deep recursion.
+ *
+ * @param max_depth
+ * compile-time configurable maximum depth.
+ */
+template <int max_depth = 2000>
+class DepthGuard final {
+public:
+ DepthGuard(int & depth_, const Mark& mark_, const std::string& msg_) : m_depth(depth_) {
+ ++m_depth;
+ if ( max_depth <= m_depth ) {
+ throw DeepRecursion{m_depth, mark_, msg_};
+ }
+ }
+
+ DepthGuard(const DepthGuard & copy_ctor) = delete;
+ DepthGuard(DepthGuard && move_ctor) = delete;
+ DepthGuard & operator=(const DepthGuard & copy_assign) = delete;
+ DepthGuard & operator=(DepthGuard && move_assign) = delete;
+
+ ~DepthGuard() {
+ --m_depth;
+ }
+
+ int current_depth() const {
+ return m_depth;
+ }
+
+private:
+ int & m_depth;
+};
+
+} // namespace YAML
+
+#endif // DEPTH_GUARD_H_00000000000000000000000000000000000000000000000000000000
--- /dev/null
+#ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+// Definition YAML_CPP_STATIC_DEFINE using to building YAML-CPP as static
+// library (definition created by CMake or defined manually)
+
+// Definition yaml_cpp_EXPORTS using to building YAML-CPP as dll/so library
+// (definition created by CMake or defined manually)
+
+#ifdef YAML_CPP_STATIC_DEFINE
+# define YAML_CPP_API
+# define YAML_CPP_NO_EXPORT
+#else
+# if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
+# ifndef YAML_CPP_API
+# ifdef yaml_cpp_EXPORTS
+ /* We are building this library */
+# pragma message( "Defining YAML_CPP_API for DLL export" )
+# define YAML_CPP_API __declspec(dllexport)
+# else
+ /* We are using this library */
+# pragma message( "Defining YAML_CPP_API for DLL import" )
+# define YAML_CPP_API __declspec(dllimport)
+# endif
+# endif
+# ifndef YAML_CPP_NO_EXPORT
+# define YAML_CPP_NO_EXPORT
+# endif
+# else /* No _MSC_VER */
+# ifndef YAML_CPP_API
+# ifdef yaml_cpp_EXPORTS
+ /* We are building this library */
+# define YAML_CPP_API __attribute__((visibility("default")))
+# else
+ /* We are using this library */
+# define YAML_CPP_API __attribute__((visibility("default")))
+# endif
+# endif
+# ifndef YAML_CPP_NO_EXPORT
+# define YAML_CPP_NO_EXPORT __attribute__((visibility("hidden")))
+# endif
+# endif /* _MSC_VER */
+#endif /* YAML_CPP_STATIC_DEFINE */
+
+#ifndef YAML_CPP_DEPRECATED
+# ifdef _MSC_VER
+# define YAML_CPP_DEPRECATED __declspec(deprecated)
+# else
+# define YAML_CPP_DEPRECATED __attribute__ ((__deprecated__))
+# endif
+#endif
+
+#ifndef YAML_CPP_DEPRECATED_EXPORT
+# define YAML_CPP_DEPRECATED_EXPORT YAML_CPP_API YAML_CPP_DEPRECATED
+#endif
+
+#ifndef YAML_CPP_DEPRECATED_NO_EXPORT
+# define YAML_CPP_DEPRECATED_NO_EXPORT YAML_CPP_NO_EXPORT YAML_CPP_DEPRECATED
+#endif
+
+#endif /* DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 */
--- /dev/null
+#ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <stack>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+
+namespace YAML {
+struct Mark;
+} // namespace YAML
+
+namespace YAML {
+class Emitter;
+
+class EmitFromEvents : public EventHandler {
+ public:
+ EmitFromEvents(Emitter& emitter);
+
+ void OnDocumentStart(const Mark& mark) override;
+ void OnDocumentEnd() override;
+
+ void OnNull(const Mark& mark, anchor_t anchor) override;
+ void OnAlias(const Mark& mark, anchor_t anchor) override;
+ void OnScalar(const Mark& mark, const std::string& tag,
+ anchor_t anchor, const std::string& value) override;
+
+ void OnSequenceStart(const Mark& mark, const std::string& tag,
+ anchor_t anchor, EmitterStyle::value style) override;
+ void OnSequenceEnd() override;
+
+ void OnMapStart(const Mark& mark, const std::string& tag,
+ anchor_t anchor, EmitterStyle::value style) override;
+ void OnMapEnd() override;
+
+ private:
+ void BeginNode();
+ void EmitProps(const std::string& tag, anchor_t anchor);
+
+ private:
+ Emitter& m_emitter;
+
+ struct State {
+ enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue };
+ };
+ std::stack<State::value> m_stateStack;
+};
+}
+
+#endif // EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cmath>
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+#include "yaml-cpp/binary.h"
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/emitterdef.h"
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/null.h"
+#include "yaml-cpp/ostream_wrapper.h"
+
+namespace YAML {
+class Binary;
+struct _Null;
+} // namespace YAML
+
+namespace YAML {
+class EmitterState;
+
+class YAML_CPP_API Emitter {
+ public:
+ Emitter();
+ explicit Emitter(std::ostream& stream);
+ Emitter(const Emitter&) = delete;
+ Emitter& operator=(const Emitter&) = delete;
+ ~Emitter();
+
+ // output
+ const char* c_str() const;
+ std::size_t size() const;
+
+ // state checking
+ bool good() const;
+ const std::string GetLastError() const;
+
+ // global setters
+ bool SetOutputCharset(EMITTER_MANIP value);
+ bool SetStringFormat(EMITTER_MANIP value);
+ bool SetBoolFormat(EMITTER_MANIP value);
+ bool SetNullFormat(EMITTER_MANIP value);
+ bool SetIntBase(EMITTER_MANIP value);
+ bool SetSeqFormat(EMITTER_MANIP value);
+ bool SetMapFormat(EMITTER_MANIP value);
+ bool SetIndent(std::size_t n);
+ bool SetPreCommentIndent(std::size_t n);
+ bool SetPostCommentIndent(std::size_t n);
+ bool SetFloatPrecision(std::size_t n);
+ bool SetDoublePrecision(std::size_t n);
+ void RestoreGlobalModifiedSettings();
+
+ // local setters
+ Emitter& SetLocalValue(EMITTER_MANIP value);
+ Emitter& SetLocalIndent(const _Indent& indent);
+ Emitter& SetLocalPrecision(const _Precision& precision);
+
+ // overloads of write
+ Emitter& Write(const std::string& str);
+ Emitter& Write(bool b);
+ Emitter& Write(char ch);
+ Emitter& Write(const _Alias& alias);
+ Emitter& Write(const _Anchor& anchor);
+ Emitter& Write(const _Tag& tag);
+ Emitter& Write(const _Comment& comment);
+ Emitter& Write(const _Null& n);
+ Emitter& Write(const Binary& binary);
+
+ template <typename T>
+ Emitter& WriteIntegralType(T value);
+
+ template <typename T>
+ Emitter& WriteStreamable(T value);
+
+ private:
+ template <typename T>
+ void SetStreamablePrecision(std::stringstream&) {}
+ std::size_t GetFloatPrecision() const;
+ std::size_t GetDoublePrecision() const;
+
+ void PrepareIntegralStream(std::stringstream& stream) const;
+ void StartedScalar();
+
+ private:
+ void EmitBeginDoc();
+ void EmitEndDoc();
+ void EmitBeginSeq();
+ void EmitEndSeq();
+ void EmitBeginMap();
+ void EmitEndMap();
+ void EmitNewline();
+ void EmitKindTag();
+ void EmitTag(bool verbatim, const _Tag& tag);
+
+ void PrepareNode(EmitterNodeType::value child);
+ void PrepareTopNode(EmitterNodeType::value child);
+ void FlowSeqPrepareNode(EmitterNodeType::value child);
+ void BlockSeqPrepareNode(EmitterNodeType::value child);
+
+ void FlowMapPrepareNode(EmitterNodeType::value child);
+
+ void FlowMapPrepareLongKey(EmitterNodeType::value child);
+ void FlowMapPrepareLongKeyValue(EmitterNodeType::value child);
+ void FlowMapPrepareSimpleKey(EmitterNodeType::value child);
+ void FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child);
+
+ void BlockMapPrepareNode(EmitterNodeType::value child);
+
+ void BlockMapPrepareLongKey(EmitterNodeType::value child);
+ void BlockMapPrepareLongKeyValue(EmitterNodeType::value child);
+ void BlockMapPrepareSimpleKey(EmitterNodeType::value child);
+ void BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child);
+
+ void SpaceOrIndentTo(bool requireSpace, std::size_t indent);
+
+ const char* ComputeFullBoolName(bool b) const;
+ const char* ComputeNullName() const;
+ bool CanEmitNewline() const;
+
+ private:
+ std::unique_ptr<EmitterState> m_pState;
+ ostream_wrapper m_stream;
+};
+
+template <typename T>
+inline Emitter& Emitter::WriteIntegralType(T value) {
+ if (!good())
+ return *this;
+
+ PrepareNode(EmitterNodeType::Scalar);
+
+ std::stringstream stream;
+ PrepareIntegralStream(stream);
+ stream << value;
+ m_stream << stream.str();
+
+ StartedScalar();
+
+ return *this;
+}
+
+template <typename T>
+inline Emitter& Emitter::WriteStreamable(T value) {
+ if (!good())
+ return *this;
+
+ PrepareNode(EmitterNodeType::Scalar);
+
+ std::stringstream stream;
+ SetStreamablePrecision<T>(stream);
+
+ bool special = false;
+ if (std::is_floating_point<T>::value) {
+ if ((std::numeric_limits<T>::has_quiet_NaN ||
+ std::numeric_limits<T>::has_signaling_NaN) &&
+ std::isnan(value)) {
+ special = true;
+ stream << ".nan";
+ } else if (std::numeric_limits<T>::has_infinity && std::isinf(value)) {
+ special = true;
+ if (std::signbit(value)) {
+ stream << "-.inf";
+ } else {
+ stream << ".inf";
+ }
+ }
+ }
+
+ if (!special) {
+ stream << value;
+ }
+ m_stream << stream.str();
+
+ StartedScalar();
+
+ return *this;
+}
+
+template <>
+inline void Emitter::SetStreamablePrecision<float>(std::stringstream& stream) {
+ stream.precision(static_cast<std::streamsize>(GetFloatPrecision()));
+}
+
+template <>
+inline void Emitter::SetStreamablePrecision<double>(std::stringstream& stream) {
+ stream.precision(static_cast<std::streamsize>(GetDoublePrecision()));
+}
+
+// overloads of insertion
+inline Emitter& operator<<(Emitter& emitter, const std::string& v) {
+ return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, bool v) {
+ return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, char v) {
+ return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned char v) {
+ return emitter.Write(static_cast<char>(v));
+}
+inline Emitter& operator<<(Emitter& emitter, const _Alias& v) {
+ return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Anchor& v) {
+ return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Tag& v) {
+ return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Comment& v) {
+ return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const _Null& v) {
+ return emitter.Write(v);
+}
+inline Emitter& operator<<(Emitter& emitter, const Binary& b) {
+ return emitter.Write(b);
+}
+
+inline Emitter& operator<<(Emitter& emitter, const char* v) {
+ return emitter.Write(std::string(v));
+}
+
+inline Emitter& operator<<(Emitter& emitter, int v) {
+ return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned int v) {
+ return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, short v) {
+ return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned short v) {
+ return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, long v) {
+ return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned long v) {
+ return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, long long v) {
+ return emitter.WriteIntegralType(v);
+}
+inline Emitter& operator<<(Emitter& emitter, unsigned long long v) {
+ return emitter.WriteIntegralType(v);
+}
+
+inline Emitter& operator<<(Emitter& emitter, float v) {
+ return emitter.WriteStreamable(v);
+}
+inline Emitter& operator<<(Emitter& emitter, double v) {
+ return emitter.WriteStreamable(v);
+}
+
+inline Emitter& operator<<(Emitter& emitter, EMITTER_MANIP value) {
+ return emitter.SetLocalValue(value);
+}
+
+inline Emitter& operator<<(Emitter& emitter, _Indent indent) {
+ return emitter.SetLocalIndent(indent);
+}
+
+inline Emitter& operator<<(Emitter& emitter, _Precision precision) {
+ return emitter.SetLocalPrecision(precision);
+}
+} // namespace YAML
+
+#endif // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML {
+struct EmitterNodeType {
+ enum value { NoType, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap };
+};
+}
+
+#endif // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+namespace YAML {
+enum EMITTER_MANIP {
+ // general manipulators
+ Auto,
+ TagByKind,
+ Newline,
+
+ // output character set
+ EmitNonAscii,
+ EscapeNonAscii,
+ EscapeAsJson,
+
+ // string manipulators
+ // Auto, // duplicate
+ SingleQuoted,
+ DoubleQuoted,
+ Literal,
+
+ // null manipulators
+ LowerNull,
+ UpperNull,
+ CamelNull,
+ TildeNull,
+
+ // bool manipulators
+ YesNoBool, // yes, no
+ TrueFalseBool, // true, false
+ OnOffBool, // on, off
+ UpperCase, // TRUE, N
+ LowerCase, // f, yes
+ CamelCase, // No, Off
+ LongBool, // yes, On
+ ShortBool, // y, t
+
+ // int manipulators
+ Dec,
+ Hex,
+ Oct,
+
+ // document manipulators
+ BeginDoc,
+ EndDoc,
+
+ // sequence manipulators
+ BeginSeq,
+ EndSeq,
+ Flow,
+ Block,
+
+ // map manipulators
+ BeginMap,
+ EndMap,
+ Key,
+ Value,
+ // Flow, // duplicate
+ // Block, // duplicate
+ // Auto, // duplicate
+ LongKey
+};
+
+struct _Indent {
+ _Indent(int value_) : value(value_) {}
+ int value;
+};
+
+inline _Indent Indent(int value) { return _Indent(value); }
+
+struct _Alias {
+ _Alias(const std::string& content_) : content(content_) {}
+ std::string content;
+};
+
+inline _Alias Alias(const std::string& content) { return _Alias(content); }
+
+struct _Anchor {
+ _Anchor(const std::string& content_) : content(content_) {}
+ std::string content;
+};
+
+inline _Anchor Anchor(const std::string& content) { return _Anchor(content); }
+
+struct _Tag {
+ struct Type {
+ enum value { Verbatim, PrimaryHandle, NamedHandle };
+ };
+
+ explicit _Tag(const std::string& prefix_, const std::string& content_,
+ Type::value type_)
+ : prefix(prefix_), content(content_), type(type_) {}
+ std::string prefix;
+ std::string content;
+ Type::value type;
+};
+
+inline _Tag VerbatimTag(const std::string& content) {
+ return _Tag("", content, _Tag::Type::Verbatim);
+}
+
+inline _Tag LocalTag(const std::string& content) {
+ return _Tag("", content, _Tag::Type::PrimaryHandle);
+}
+
+inline _Tag LocalTag(const std::string& prefix, const std::string content) {
+ return _Tag(prefix, content, _Tag::Type::NamedHandle);
+}
+
+inline _Tag SecondaryTag(const std::string& content) {
+ return _Tag("", content, _Tag::Type::NamedHandle);
+}
+
+struct _Comment {
+ _Comment(const std::string& content_) : content(content_) {}
+ std::string content;
+};
+
+inline _Comment Comment(const std::string& content) { return _Comment(content); }
+
+struct _Precision {
+ _Precision(int floatPrecision_, int doublePrecision_)
+ : floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {}
+
+ int floatPrecision;
+ int doublePrecision;
+};
+
+inline _Precision FloatPrecision(int n) { return _Precision(n, -1); }
+
+inline _Precision DoublePrecision(int n) { return _Precision(-1, n); }
+
+inline _Precision Precision(int n) { return _Precision(n, n); }
+}
+
+#endif // EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML {
+struct EmitterStyle {
+ enum value { Default, Block, Flow };
+};
+}
+
+#endif // EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/emitterstyle.h"
+
+namespace YAML {
+struct Mark;
+
+class EventHandler {
+ public:
+ virtual ~EventHandler() = default;
+
+ virtual void OnDocumentStart(const Mark& mark) = 0;
+ virtual void OnDocumentEnd() = 0;
+
+ virtual void OnNull(const Mark& mark, anchor_t anchor) = 0;
+ virtual void OnAlias(const Mark& mark, anchor_t anchor) = 0;
+ virtual void OnScalar(const Mark& mark, const std::string& tag,
+ anchor_t anchor, const std::string& value) = 0;
+
+ virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+ anchor_t anchor, EmitterStyle::value style) = 0;
+ virtual void OnSequenceEnd() = 0;
+
+ virtual void OnMapStart(const Mark& mark, const std::string& tag,
+ anchor_t anchor, EmitterStyle::value style) = 0;
+ virtual void OnMapEnd() = 0;
+
+ virtual void OnAnchor(const Mark& /*mark*/,
+ const std::string& /*anchor_name*/) {
+ // empty default implementation for compatibility
+ }
+};
+} // namespace YAML
+
+#endif // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/noexcept.h"
+#include "yaml-cpp/traits.h"
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+namespace YAML {
+// error messages
+namespace ErrorMsg {
+const char* const YAML_DIRECTIVE_ARGS =
+ "YAML directives must have exactly one argument";
+const char* const YAML_VERSION = "bad YAML version: ";
+const char* const YAML_MAJOR_VERSION = "YAML major version too large";
+const char* const REPEATED_YAML_DIRECTIVE = "repeated YAML directive";
+const char* const TAG_DIRECTIVE_ARGS =
+ "TAG directives must have exactly two arguments";
+const char* const REPEATED_TAG_DIRECTIVE = "repeated TAG directive";
+const char* const CHAR_IN_TAG_HANDLE =
+ "illegal character found while scanning tag handle";
+const char* const TAG_WITH_NO_SUFFIX = "tag handle with no suffix";
+const char* const END_OF_VERBATIM_TAG = "end of verbatim tag not found";
+const char* const END_OF_MAP = "end of map not found";
+const char* const END_OF_MAP_FLOW = "end of map flow not found";
+const char* const END_OF_SEQ = "end of sequence not found";
+const char* const END_OF_SEQ_FLOW = "end of sequence flow not found";
+const char* const MULTIPLE_TAGS =
+ "cannot assign multiple tags to the same node";
+const char* const MULTIPLE_ANCHORS =
+ "cannot assign multiple anchors to the same node";
+const char* const MULTIPLE_ALIASES =
+ "cannot assign multiple aliases to the same node";
+const char* const ALIAS_CONTENT =
+ "aliases can't have any content, *including* tags";
+const char* const INVALID_HEX = "bad character found while scanning hex number";
+const char* const INVALID_UNICODE = "invalid unicode: ";
+const char* const INVALID_ESCAPE = "unknown escape character: ";
+const char* const UNKNOWN_TOKEN = "unknown token";
+const char* const DOC_IN_SCALAR = "illegal document indicator in scalar";
+const char* const EOF_IN_SCALAR = "illegal EOF in scalar";
+const char* const CHAR_IN_SCALAR = "illegal character in scalar";
+const char* const TAB_IN_INDENTATION =
+ "illegal tab when looking for indentation";
+const char* const FLOW_END = "illegal flow end";
+const char* const BLOCK_ENTRY = "illegal block entry";
+const char* const MAP_KEY = "illegal map key";
+const char* const MAP_VALUE = "illegal map value";
+const char* const ALIAS_NOT_FOUND = "alias not found after *";
+const char* const ANCHOR_NOT_FOUND = "anchor not found after &";
+const char* const CHAR_IN_ALIAS =
+ "illegal character found while scanning alias";
+const char* const CHAR_IN_ANCHOR =
+ "illegal character found while scanning anchor";
+const char* const ZERO_INDENT_IN_BLOCK =
+ "cannot set zero indentation for a block scalar";
+const char* const CHAR_IN_BLOCK = "unexpected character in block scalar";
+const char* const AMBIGUOUS_ANCHOR =
+ "cannot assign the same alias to multiple nodes";
+const char* const UNKNOWN_ANCHOR = "the referenced anchor is not defined: ";
+
+const char* const INVALID_NODE =
+ "invalid node; this may result from using a map iterator as a sequence "
+ "iterator, or vice-versa";
+const char* const INVALID_SCALAR = "invalid scalar";
+const char* const KEY_NOT_FOUND = "key not found";
+const char* const BAD_CONVERSION = "bad conversion";
+const char* const BAD_DEREFERENCE = "bad dereference";
+const char* const BAD_SUBSCRIPT = "operator[] call on a scalar";
+const char* const BAD_PUSHBACK = "appending to a non-sequence";
+const char* const BAD_INSERT = "inserting in a non-convertible-to-map";
+
+const char* const UNMATCHED_GROUP_TAG = "unmatched group tag";
+const char* const UNEXPECTED_END_SEQ = "unexpected end sequence token";
+const char* const UNEXPECTED_END_MAP = "unexpected end map token";
+const char* const SINGLE_QUOTED_CHAR =
+ "invalid character in single-quoted string";
+const char* const INVALID_ANCHOR = "invalid anchor";
+const char* const INVALID_ALIAS = "invalid alias";
+const char* const INVALID_TAG = "invalid tag";
+const char* const BAD_FILE = "bad file";
+
+template <typename T>
+inline const std::string KEY_NOT_FOUND_WITH_KEY(
+ const T&, typename disable_if<is_numeric<T>>::type* = 0) {
+ return KEY_NOT_FOUND;
+}
+
+inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) {
+ std::stringstream stream;
+ stream << KEY_NOT_FOUND << ": " << key;
+ return stream.str();
+}
+
+inline const std::string KEY_NOT_FOUND_WITH_KEY(const char* key) {
+ std::stringstream stream;
+ stream << KEY_NOT_FOUND << ": " << key;
+ return stream.str();
+}
+
+template <typename T>
+inline const std::string KEY_NOT_FOUND_WITH_KEY(
+ const T& key, typename enable_if<is_numeric<T>>::type* = 0) {
+ std::stringstream stream;
+ stream << KEY_NOT_FOUND << ": " << key;
+ return stream.str();
+}
+
+template <typename T>
+inline const std::string BAD_SUBSCRIPT_WITH_KEY(
+ const T&, typename disable_if<is_numeric<T>>::type* = nullptr) {
+ return BAD_SUBSCRIPT;
+}
+
+inline const std::string BAD_SUBSCRIPT_WITH_KEY(const std::string& key) {
+ std::stringstream stream;
+ stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")";
+ return stream.str();
+}
+
+inline const std::string BAD_SUBSCRIPT_WITH_KEY(const char* key) {
+ std::stringstream stream;
+ stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")";
+ return stream.str();
+}
+
+template <typename T>
+inline const std::string BAD_SUBSCRIPT_WITH_KEY(
+ const T& key, typename enable_if<is_numeric<T>>::type* = nullptr) {
+ std::stringstream stream;
+ stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")";
+ return stream.str();
+}
+
+inline const std::string INVALID_NODE_WITH_KEY(const std::string& key) {
+ std::stringstream stream;
+ if (key.empty()) {
+ return INVALID_NODE;
+ }
+ stream << "invalid node; first invalid key: \"" << key << "\"";
+ return stream.str();
+}
+} // namespace ErrorMsg
+
+class YAML_CPP_API Exception : public std::runtime_error {
+ public:
+ Exception(const Mark& mark_, const std::string& msg_)
+ : std::runtime_error(build_what(mark_, msg_)), mark(mark_), msg(msg_) {}
+ ~Exception() YAML_CPP_NOEXCEPT override;
+
+ Exception(const Exception&) = default;
+
+ Mark mark;
+ std::string msg;
+
+ private:
+ static const std::string build_what(const Mark& mark,
+ const std::string& msg) {
+ if (mark.is_null()) {
+ return msg;
+ }
+
+ std::stringstream output;
+ output << "yaml-cpp: error at line " << mark.line + 1 << ", column "
+ << mark.column + 1 << ": " << msg;
+ return output.str();
+ }
+};
+
+class YAML_CPP_API ParserException : public Exception {
+ public:
+ ParserException(const Mark& mark_, const std::string& msg_)
+ : Exception(mark_, msg_) {}
+ ParserException(const ParserException&) = default;
+ ~ParserException() YAML_CPP_NOEXCEPT override;
+};
+
+class YAML_CPP_API RepresentationException : public Exception {
+ public:
+ RepresentationException(const Mark& mark_, const std::string& msg_)
+ : Exception(mark_, msg_) {}
+ RepresentationException(const RepresentationException&) = default;
+ ~RepresentationException() YAML_CPP_NOEXCEPT override;
+};
+
+// representation exceptions
+class YAML_CPP_API InvalidScalar : public RepresentationException {
+ public:
+ InvalidScalar(const Mark& mark_)
+ : RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {}
+ InvalidScalar(const InvalidScalar&) = default;
+ ~InvalidScalar() YAML_CPP_NOEXCEPT override;
+};
+
+class YAML_CPP_API KeyNotFound : public RepresentationException {
+ public:
+ template <typename T>
+ KeyNotFound(const Mark& mark_, const T& key_)
+ : RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) {
+ }
+ KeyNotFound(const KeyNotFound&) = default;
+ ~KeyNotFound() YAML_CPP_NOEXCEPT override;
+};
+
+template <typename T>
+class YAML_CPP_API TypedKeyNotFound : public KeyNotFound {
+ public:
+ TypedKeyNotFound(const Mark& mark_, const T& key_)
+ : KeyNotFound(mark_, key_), key(key_) {}
+ ~TypedKeyNotFound() YAML_CPP_NOEXCEPT override = default;
+
+ T key;
+};
+
+template <typename T>
+inline TypedKeyNotFound<T> MakeTypedKeyNotFound(const Mark& mark,
+ const T& key) {
+ return TypedKeyNotFound<T>(mark, key);
+}
+
+class YAML_CPP_API InvalidNode : public RepresentationException {
+ public:
+ InvalidNode(const std::string& key)
+ : RepresentationException(Mark::null_mark(),
+ ErrorMsg::INVALID_NODE_WITH_KEY(key)) {}
+ InvalidNode(const InvalidNode&) = default;
+ ~InvalidNode() YAML_CPP_NOEXCEPT override;
+};
+
+class YAML_CPP_API BadConversion : public RepresentationException {
+ public:
+ explicit BadConversion(const Mark& mark_)
+ : RepresentationException(mark_, ErrorMsg::BAD_CONVERSION) {}
+ BadConversion(const BadConversion&) = default;
+ ~BadConversion() YAML_CPP_NOEXCEPT override;
+};
+
+template <typename T>
+class TypedBadConversion : public BadConversion {
+ public:
+ explicit TypedBadConversion(const Mark& mark_) : BadConversion(mark_) {}
+};
+
+class YAML_CPP_API BadDereference : public RepresentationException {
+ public:
+ BadDereference()
+ : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {}
+ BadDereference(const BadDereference&) = default;
+ ~BadDereference() YAML_CPP_NOEXCEPT override;
+};
+
+class YAML_CPP_API BadSubscript : public RepresentationException {
+ public:
+ template <typename Key>
+ BadSubscript(const Mark& mark_, const Key& key)
+ : RepresentationException(mark_, ErrorMsg::BAD_SUBSCRIPT_WITH_KEY(key)) {}
+ BadSubscript(const BadSubscript&) = default;
+ ~BadSubscript() YAML_CPP_NOEXCEPT override;
+};
+
+class YAML_CPP_API BadPushback : public RepresentationException {
+ public:
+ BadPushback()
+ : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {}
+ BadPushback(const BadPushback&) = default;
+ ~BadPushback() YAML_CPP_NOEXCEPT override;
+};
+
+class YAML_CPP_API BadInsert : public RepresentationException {
+ public:
+ BadInsert()
+ : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {}
+ BadInsert(const BadInsert&) = default;
+ ~BadInsert() YAML_CPP_NOEXCEPT override;
+};
+
+class YAML_CPP_API EmitterException : public Exception {
+ public:
+ EmitterException(const std::string& msg_)
+ : Exception(Mark::null_mark(), msg_) {}
+ EmitterException(const EmitterException&) = default;
+ ~EmitterException() YAML_CPP_NOEXCEPT override;
+};
+
+class YAML_CPP_API BadFile : public Exception {
+ public:
+ explicit BadFile(const std::string& filename)
+ : Exception(Mark::null_mark(),
+ std::string(ErrorMsg::BAD_FILE) + ": " + filename) {}
+ BadFile(const BadFile&) = default;
+ ~BadFile() YAML_CPP_NOEXCEPT override;
+};
+} // namespace YAML
+
+#endif // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+struct YAML_CPP_API Mark {
+ Mark() : pos(0), line(0), column(0) {}
+
+ static const Mark null_mark() { return Mark(-1, -1, -1); }
+
+ bool is_null() const { return pos == -1 && line == -1 && column == -1; }
+
+ int pos;
+ int line, column;
+
+ private:
+ Mark(int pos_, int line_, int column_)
+ : pos(pos_), line(line_), column(column_) {}
+};
+}
+
+#endif // MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <array>
+#include <cmath>
+#include <limits>
+#include <list>
+#include <map>
+#include <unordered_map>
+#include <sstream>
+#include <type_traits>
+#include <valarray>
+#include <vector>
+
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif
+
+#include "yaml-cpp/binary.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/type.h"
+#include "yaml-cpp/null.h"
+
+
+namespace YAML {
+class Binary;
+struct _Null;
+template <typename T>
+struct convert;
+} // namespace YAML
+
+namespace YAML {
+namespace conversion {
+inline bool IsInfinity(const std::string& input) {
+ return input == ".inf" || input == ".Inf" || input == ".INF" ||
+ input == "+.inf" || input == "+.Inf" || input == "+.INF";
+}
+
+inline bool IsNegativeInfinity(const std::string& input) {
+ return input == "-.inf" || input == "-.Inf" || input == "-.INF";
+}
+
+inline bool IsNaN(const std::string& input) {
+ return input == ".nan" || input == ".NaN" || input == ".NAN";
+}
+}
+
+// Node
+template <>
+struct convert<Node> {
+ static Node encode(const Node& rhs) { return rhs; }
+
+ static bool decode(const Node& node, Node& rhs) {
+ rhs.reset(node);
+ return true;
+ }
+};
+
+// std::string
+template <>
+struct convert<std::string> {
+ static Node encode(const std::string& rhs) { return Node(rhs); }
+
+ static bool decode(const Node& node, std::string& rhs) {
+ if (!node.IsScalar())
+ return false;
+ rhs = node.Scalar();
+ return true;
+ }
+};
+
+// C-strings can only be encoded
+template <>
+struct convert<const char*> {
+ static Node encode(const char* rhs) { return Node(rhs); }
+};
+
+template <>
+struct convert<char*> {
+ static Node encode(const char* rhs) { return Node(rhs); }
+};
+
+template <std::size_t N>
+struct convert<char[N]> {
+ static Node encode(const char* rhs) { return Node(rhs); }
+};
+
+#if __cplusplus >= 201703L
+template <>
+struct convert<std::string_view> {
+ static Node encode(std::string_view rhs) { return Node(std::string(rhs)); }
+
+ static bool decode(const Node& node, std::string_view& rhs) {
+ if (!node.IsScalar())
+ return false;
+ rhs = node.Scalar();
+ return true;
+ }
+};
+#endif
+
+template <>
+struct convert<_Null> {
+ static Node encode(const _Null& /* rhs */) { return Node(); }
+
+ static bool decode(const Node& node, _Null& /* rhs */) {
+ return node.IsNull();
+ }
+};
+
+namespace conversion {
+template <typename T>
+typename std::enable_if< std::is_floating_point<T>::value, void>::type
+inner_encode(const T& rhs, std::stringstream& stream){
+ if (std::isnan(rhs)) {
+ stream << ".nan";
+ } else if (std::isinf(rhs)) {
+ if (std::signbit(rhs)) {
+ stream << "-.inf";
+ } else {
+ stream << ".inf";
+ }
+ } else {
+ stream << rhs;
+ }
+}
+
+template <typename T>
+typename std::enable_if<!std::is_floating_point<T>::value, void>::type
+inner_encode(const T& rhs, std::stringstream& stream){
+ stream << rhs;
+}
+
+template <typename T>
+typename std::enable_if<(std::is_same<T, unsigned char>::value ||
+ std::is_same<T, signed char>::value), bool>::type
+ConvertStreamTo(std::stringstream& stream, T& rhs) {
+ int num;
+ if ((stream >> std::noskipws >> num) && (stream >> std::ws).eof()) {
+ if (num >= (std::numeric_limits<T>::min)() &&
+ num <= (std::numeric_limits<T>::max)()) {
+ rhs = static_cast<T>(num);
+ return true;
+ }
+ }
+ return false;
+}
+
+template <typename T>
+typename std::enable_if<!(std::is_same<T, unsigned char>::value ||
+ std::is_same<T, signed char>::value), bool>::type
+ConvertStreamTo(std::stringstream& stream, T& rhs) {
+ if ((stream >> std::noskipws >> rhs) && (stream >> std::ws).eof()) {
+ return true;
+ }
+ return false;
+}
+}
+
+#define YAML_DEFINE_CONVERT_STREAMABLE(type, negative_op) \
+ template <> \
+ struct convert<type> { \
+ \
+ static Node encode(const type& rhs) { \
+ std::stringstream stream; \
+ stream.precision(std::numeric_limits<type>::max_digits10); \
+ conversion::inner_encode(rhs, stream); \
+ return Node(stream.str()); \
+ } \
+ \
+ static bool decode(const Node& node, type& rhs) { \
+ if (node.Type() != NodeType::Scalar) { \
+ return false; \
+ } \
+ const std::string& input = node.Scalar(); \
+ std::stringstream stream(input); \
+ stream.unsetf(std::ios::dec); \
+ if ((stream.peek() == '-') && std::is_unsigned<type>::value) { \
+ return false; \
+ } \
+ if (conversion::ConvertStreamTo(stream, rhs)) { \
+ return true; \
+ } \
+ if (std::numeric_limits<type>::has_infinity) { \
+ if (conversion::IsInfinity(input)) { \
+ rhs = std::numeric_limits<type>::infinity(); \
+ return true; \
+ } else if (conversion::IsNegativeInfinity(input)) { \
+ rhs = negative_op std::numeric_limits<type>::infinity(); \
+ return true; \
+ } \
+ } \
+ \
+ if (std::numeric_limits<type>::has_quiet_NaN) { \
+ if (conversion::IsNaN(input)) { \
+ rhs = std::numeric_limits<type>::quiet_NaN(); \
+ return true; \
+ } \
+ } \
+ \
+ return false; \
+ } \
+ }
+
+#define YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(type) \
+ YAML_DEFINE_CONVERT_STREAMABLE(type, -)
+
+#define YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(type) \
+ YAML_DEFINE_CONVERT_STREAMABLE(type, +)
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(int);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(short);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long long);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned short);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long long);
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(char);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(signed char);
+YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned char);
+
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(float);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(double);
+YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long double);
+
+#undef YAML_DEFINE_CONVERT_STREAMABLE_SIGNED
+#undef YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED
+#undef YAML_DEFINE_CONVERT_STREAMABLE
+
+// bool
+template <>
+struct convert<bool> {
+ static Node encode(bool rhs) { return rhs ? Node("true") : Node("false"); }
+
+ YAML_CPP_API static bool decode(const Node& node, bool& rhs);
+};
+
+// std::map
+template <typename K, typename V, typename C, typename A>
+struct convert<std::map<K, V, C, A>> {
+ static Node encode(const std::map<K, V, C, A>& rhs) {
+ Node node(NodeType::Map);
+ for (const auto& element : rhs)
+ node.force_insert(element.first, element.second);
+ return node;
+ }
+
+ static bool decode(const Node& node, std::map<K, V, C, A>& rhs) {
+ if (!node.IsMap())
+ return false;
+
+ rhs.clear();
+ for (const auto& element : node)
+#if defined(__GNUC__) && __GNUC__ < 4
+ // workaround for GCC 3:
+ rhs[element.first.template as<K>()] = element.second.template as<V>();
+#else
+ rhs[element.first.as<K>()] = element.second.as<V>();
+#endif
+ return true;
+ }
+};
+
+// std::unordered_map
+template <typename K, typename V, typename H, typename P, typename A>
+struct convert<std::unordered_map<K, V, H, P, A>> {
+ static Node encode(const std::unordered_map<K, V, H, P, A>& rhs) {
+ Node node(NodeType::Map);
+ for (const auto& element : rhs)
+ node.force_insert(element.first, element.second);
+ return node;
+ }
+
+ static bool decode(const Node& node, std::unordered_map<K, V, H, P, A>& rhs) {
+ if (!node.IsMap())
+ return false;
+
+ rhs.clear();
+ for (const auto& element : node)
+#if defined(__GNUC__) && __GNUC__ < 4
+ // workaround for GCC 3:
+ rhs[element.first.template as<K>()] = element.second.template as<V>();
+#else
+ rhs[element.first.as<K>()] = element.second.as<V>();
+#endif
+ return true;
+ }
+};
+
+// std::vector
+template <typename T, typename A>
+struct convert<std::vector<T, A>> {
+ static Node encode(const std::vector<T, A>& rhs) {
+ Node node(NodeType::Sequence);
+ for (const auto& element : rhs)
+ node.push_back(element);
+ return node;
+ }
+
+ static bool decode(const Node& node, std::vector<T, A>& rhs) {
+ if (!node.IsSequence())
+ return false;
+
+ rhs.clear();
+ for (const auto& element : node)
+#if defined(__GNUC__) && __GNUC__ < 4
+ // workaround for GCC 3:
+ rhs.push_back(element.template as<T>());
+#else
+ rhs.push_back(element.as<T>());
+#endif
+ return true;
+ }
+};
+
+// std::list
+template <typename T, typename A>
+struct convert<std::list<T,A>> {
+ static Node encode(const std::list<T,A>& rhs) {
+ Node node(NodeType::Sequence);
+ for (const auto& element : rhs)
+ node.push_back(element);
+ return node;
+ }
+
+ static bool decode(const Node& node, std::list<T,A>& rhs) {
+ if (!node.IsSequence())
+ return false;
+
+ rhs.clear();
+ for (const auto& element : node)
+#if defined(__GNUC__) && __GNUC__ < 4
+ // workaround for GCC 3:
+ rhs.push_back(element.template as<T>());
+#else
+ rhs.push_back(element.as<T>());
+#endif
+ return true;
+ }
+};
+
+// std::array
+template <typename T, std::size_t N>
+struct convert<std::array<T, N>> {
+ static Node encode(const std::array<T, N>& rhs) {
+ Node node(NodeType::Sequence);
+ for (const auto& element : rhs) {
+ node.push_back(element);
+ }
+ return node;
+ }
+
+ static bool decode(const Node& node, std::array<T, N>& rhs) {
+ if (!isNodeValid(node)) {
+ return false;
+ }
+
+ for (auto i = 0u; i < node.size(); ++i) {
+#if defined(__GNUC__) && __GNUC__ < 4
+ // workaround for GCC 3:
+ rhs[i] = node[i].template as<T>();
+#else
+ rhs[i] = node[i].as<T>();
+#endif
+ }
+ return true;
+ }
+
+ private:
+ static bool isNodeValid(const Node& node) {
+ return node.IsSequence() && node.size() == N;
+ }
+};
+
+
+// std::valarray
+template <typename T>
+struct convert<std::valarray<T>> {
+ static Node encode(const std::valarray<T>& rhs) {
+ Node node(NodeType::Sequence);
+ for (const auto& element : rhs) {
+ node.push_back(element);
+ }
+ return node;
+ }
+
+ static bool decode(const Node& node, std::valarray<T>& rhs) {
+ if (!node.IsSequence()) {
+ return false;
+ }
+
+ rhs.resize(node.size());
+ for (auto i = 0u; i < node.size(); ++i) {
+#if defined(__GNUC__) && __GNUC__ < 4
+ // workaround for GCC 3:
+ rhs[i] = node[i].template as<T>();
+#else
+ rhs[i] = node[i].as<T>();
+#endif
+ }
+ return true;
+ }
+};
+
+
+// std::pair
+template <typename T, typename U>
+struct convert<std::pair<T, U>> {
+ static Node encode(const std::pair<T, U>& rhs) {
+ Node node(NodeType::Sequence);
+ node.push_back(rhs.first);
+ node.push_back(rhs.second);
+ return node;
+ }
+
+ static bool decode(const Node& node, std::pair<T, U>& rhs) {
+ if (!node.IsSequence())
+ return false;
+ if (node.size() != 2)
+ return false;
+
+#if defined(__GNUC__) && __GNUC__ < 4
+ // workaround for GCC 3:
+ rhs.first = node[0].template as<T>();
+#else
+ rhs.first = node[0].as<T>();
+#endif
+#if defined(__GNUC__) && __GNUC__ < 4
+ // workaround for GCC 3:
+ rhs.second = node[1].template as<U>();
+#else
+ rhs.second = node[1].as<U>();
+#endif
+ return true;
+ }
+};
+
+// binary
+template <>
+struct convert<Binary> {
+ static Node encode(const Binary& rhs) {
+ return Node(EncodeBase64(rhs.data(), rhs.size()));
+ }
+
+ static bool decode(const Node& node, Binary& rhs) {
+ if (!node.IsScalar())
+ return false;
+
+ std::vector<unsigned char> data = DecodeBase64(node.Scalar());
+ if (data.empty() && !node.Scalar().empty())
+ return false;
+
+ rhs.swap(data);
+ return true;
+ }
+};
+}
+
+#endif // NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/node/detail/node_data.h"
+
+#include <algorithm>
+#include <type_traits>
+
+namespace YAML {
+namespace detail {
+template <typename Key, typename Enable = void>
+struct get_idx {
+ static node* get(const std::vector<node*>& /* sequence */,
+ const Key& /* key */, shared_memory_holder /* pMemory */) {
+ return nullptr;
+ }
+};
+
+template <typename Key>
+struct get_idx<Key,
+ typename std::enable_if<std::is_unsigned<Key>::value &&
+ !std::is_same<Key, bool>::value>::type> {
+ static node* get(const std::vector<node*>& sequence, const Key& key,
+ shared_memory_holder /* pMemory */) {
+ return key < sequence.size() ? sequence[key] : nullptr;
+ }
+
+ static node* get(std::vector<node*>& sequence, const Key& key,
+ shared_memory_holder pMemory) {
+ if (key > sequence.size() || (key > 0 && !sequence[key - 1]->is_defined()))
+ return nullptr;
+ if (key == sequence.size())
+ sequence.push_back(&pMemory->create_node());
+ return sequence[key];
+ }
+};
+
+template <typename Key>
+struct get_idx<Key, typename std::enable_if<std::is_signed<Key>::value>::type> {
+ static node* get(const std::vector<node*>& sequence, const Key& key,
+ shared_memory_holder pMemory) {
+ return key >= 0 ? get_idx<std::size_t>::get(
+ sequence, static_cast<std::size_t>(key), pMemory)
+ : nullptr;
+ }
+ static node* get(std::vector<node*>& sequence, const Key& key,
+ shared_memory_holder pMemory) {
+ return key >= 0 ? get_idx<std::size_t>::get(
+ sequence, static_cast<std::size_t>(key), pMemory)
+ : nullptr;
+ }
+};
+
+template <typename Key, typename Enable = void>
+struct remove_idx {
+ static bool remove(std::vector<node*>&, const Key&, std::size_t&) {
+ return false;
+ }
+};
+
+template <typename Key>
+struct remove_idx<
+ Key, typename std::enable_if<std::is_unsigned<Key>::value &&
+ !std::is_same<Key, bool>::value>::type> {
+
+ static bool remove(std::vector<node*>& sequence, const Key& key,
+ std::size_t& seqSize) {
+ if (key >= sequence.size()) {
+ return false;
+ } else {
+ sequence.erase(sequence.begin() + key);
+ if (seqSize > key) {
+ --seqSize;
+ }
+ return true;
+ }
+ }
+};
+
+template <typename Key>
+struct remove_idx<Key,
+ typename std::enable_if<std::is_signed<Key>::value>::type> {
+
+ static bool remove(std::vector<node*>& sequence, const Key& key,
+ std::size_t& seqSize) {
+ return key >= 0 ? remove_idx<std::size_t>::remove(
+ sequence, static_cast<std::size_t>(key), seqSize)
+ : false;
+ }
+};
+
+template <typename T>
+inline bool node::equals(const T& rhs, shared_memory_holder pMemory) {
+ T lhs;
+ if (convert<T>::decode(Node(*this, pMemory), lhs)) {
+ return lhs == rhs;
+ }
+ return false;
+}
+
+inline bool node::equals(const char* rhs, shared_memory_holder pMemory) {
+ std::string lhs;
+ if (convert<std::string>::decode(Node(*this, std::move(pMemory)), lhs)) {
+ return lhs == rhs;
+ }
+ return false;
+}
+
+// indexing
+template <typename Key>
+inline node* node_data::get(const Key& key,
+ shared_memory_holder pMemory) const {
+ switch (m_type) {
+ case NodeType::Map:
+ break;
+ case NodeType::Undefined:
+ case NodeType::Null:
+ return nullptr;
+ case NodeType::Sequence:
+ if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory))
+ return pNode;
+ return nullptr;
+ case NodeType::Scalar:
+ throw BadSubscript(m_mark, key);
+ }
+
+ auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
+ return m.first->equals(key, pMemory);
+ });
+
+ return it != m_map.end() ? it->second : nullptr;
+}
+
+template <typename Key>
+inline node& node_data::get(const Key& key, shared_memory_holder pMemory) {
+ switch (m_type) {
+ case NodeType::Map:
+ break;
+ case NodeType::Undefined:
+ case NodeType::Null:
+ case NodeType::Sequence:
+ if (node* pNode = get_idx<Key>::get(m_sequence, key, pMemory)) {
+ m_type = NodeType::Sequence;
+ return *pNode;
+ }
+
+ convert_to_map(pMemory);
+ break;
+ case NodeType::Scalar:
+ throw BadSubscript(m_mark, key);
+ }
+
+ auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
+ return m.first->equals(key, pMemory);
+ });
+
+ if (it != m_map.end()) {
+ return *it->second;
+ }
+
+ node& k = convert_to_node(key, pMemory);
+ node& v = pMemory->create_node();
+ insert_map_pair(k, v);
+ return v;
+}
+
+template <typename Key>
+inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) {
+ if (m_type == NodeType::Sequence) {
+ return remove_idx<Key>::remove(m_sequence, key, m_seqSize);
+ }
+
+ if (m_type == NodeType::Map) {
+ kv_pairs::iterator it = m_undefinedPairs.begin();
+ while (it != m_undefinedPairs.end()) {
+ kv_pairs::iterator jt = std::next(it);
+ if (it->first->equals(key, pMemory)) {
+ m_undefinedPairs.erase(it);
+ }
+ it = jt;
+ }
+
+ auto iter = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) {
+ return m.first->equals(key, pMemory);
+ });
+
+ if (iter != m_map.end()) {
+ m_map.erase(iter);
+ return true;
+ }
+ }
+
+ return false;
+}
+
+// map
+template <typename Key, typename Value>
+inline void node_data::force_insert(const Key& key, const Value& value,
+ shared_memory_holder pMemory) {
+ switch (m_type) {
+ case NodeType::Map:
+ break;
+ case NodeType::Undefined:
+ case NodeType::Null:
+ case NodeType::Sequence:
+ convert_to_map(pMemory);
+ break;
+ case NodeType::Scalar:
+ throw BadInsert();
+ }
+
+ node& k = convert_to_node(key, pMemory);
+ node& v = convert_to_node(value, pMemory);
+ insert_map_pair(k, v);
+}
+
+template <typename T>
+inline node& node_data::convert_to_node(const T& rhs,
+ shared_memory_holder pMemory) {
+ Node value = convert<T>::encode(rhs);
+ value.EnsureNodeExists();
+ pMemory->merge(*value.m_pMemory);
+ return *value.m_pNode;
+}
+}
+}
+
+#endif // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/detail/node_iterator.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/ptr.h"
+#include <cstddef>
+#include <iterator>
+
+
+namespace YAML {
+namespace detail {
+struct iterator_value;
+
+template <typename V>
+class iterator_base {
+
+ private:
+ template <typename>
+ friend class iterator_base;
+ struct enabler {};
+ using base_type = node_iterator;
+
+ struct proxy {
+ explicit proxy(const V& x) : m_ref(x) {}
+ V* operator->() { return std::addressof(m_ref); }
+ operator V*() { return std::addressof(m_ref); }
+
+ V m_ref;
+ };
+
+ public:
+ using iterator_category = std::forward_iterator_tag;
+ using value_type = V;
+ using difference_type = std::ptrdiff_t;
+ using pointer = V*;
+ using reference = V;
+
+ public:
+ iterator_base() : m_iterator(), m_pMemory() {}
+ explicit iterator_base(base_type rhs, shared_memory_holder pMemory)
+ : m_iterator(rhs), m_pMemory(pMemory) {}
+
+ template <class W>
+ iterator_base(const iterator_base<W>& rhs,
+ typename std::enable_if<std::is_convertible<W*, V*>::value,
+ enabler>::type = enabler())
+ : m_iterator(rhs.m_iterator), m_pMemory(rhs.m_pMemory) {}
+
+ iterator_base<V>& operator++() {
+ ++m_iterator;
+ return *this;
+ }
+
+ iterator_base<V> operator++(int) {
+ iterator_base<V> iterator_pre(*this);
+ ++(*this);
+ return iterator_pre;
+ }
+
+ template <typename W>
+ bool operator==(const iterator_base<W>& rhs) const {
+ return m_iterator == rhs.m_iterator;
+ }
+
+ template <typename W>
+ bool operator!=(const iterator_base<W>& rhs) const {
+ return m_iterator != rhs.m_iterator;
+ }
+
+ value_type operator*() const {
+ const typename base_type::value_type& v = *m_iterator;
+ if (v.pNode)
+ return value_type(Node(*v, m_pMemory));
+ if (v.first && v.second)
+ return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory));
+ return value_type();
+ }
+
+ proxy operator->() const { return proxy(**this); }
+
+ private:
+ base_type m_iterator;
+ shared_memory_holder m_pMemory;
+};
+} // namespace detail
+} // namespace YAML
+
+#endif // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+#include <list>
+#include <utility>
+#include <vector>
+
+namespace YAML {
+
+namespace detail {
+struct iterator_value;
+template <typename V>
+class iterator_base;
+}
+
+using iterator = detail::iterator_base<detail::iterator_value>;
+using const_iterator = detail::iterator_base<const detail::iterator_value>;
+}
+
+#endif // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <set>
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/ptr.h"
+
+namespace YAML {
+namespace detail {
+class node;
+} // namespace detail
+} // namespace YAML
+
+namespace YAML {
+namespace detail {
+class YAML_CPP_API memory {
+ public:
+ memory() : m_nodes{} {}
+ node& create_node();
+ void merge(const memory& rhs);
+
+ private:
+ using Nodes = std::set<shared_node>;
+ Nodes m_nodes;
+};
+
+class YAML_CPP_API memory_holder {
+ public:
+ memory_holder() : m_pMemory(new memory) {}
+
+ node& create_node() { return m_pMemory->create_node(); }
+ void merge(memory_holder& rhs);
+
+ private:
+ shared_memory m_pMemory;
+};
+} // namespace detail
+} // namespace YAML
+
+#endif // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/node/detail/node_ref.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.h"
+#include <set>
+#include <atomic>
+
+namespace YAML {
+namespace detail {
+class node {
+ private:
+ struct less {
+ bool operator ()(const node* l, const node* r) const {return l->m_index < r->m_index;}
+ };
+
+ public:
+ node() : m_pRef(new node_ref), m_dependencies{}, m_index{} {}
+ node(const node&) = delete;
+ node& operator=(const node&) = delete;
+
+ bool is(const node& rhs) const { return m_pRef == rhs.m_pRef; }
+ const node_ref* ref() const { return m_pRef.get(); }
+
+ bool is_defined() const { return m_pRef->is_defined(); }
+ const Mark& mark() const { return m_pRef->mark(); }
+ NodeType::value type() const { return m_pRef->type(); }
+
+ const std::string& scalar() const { return m_pRef->scalar(); }
+ const std::string& tag() const { return m_pRef->tag(); }
+ EmitterStyle::value style() const { return m_pRef->style(); }
+
+ template <typename T>
+ bool equals(const T& rhs, shared_memory_holder pMemory);
+ bool equals(const char* rhs, shared_memory_holder pMemory);
+
+ void mark_defined() {
+ if (is_defined())
+ return;
+
+ m_pRef->mark_defined();
+ for (node* dependency : m_dependencies)
+ dependency->mark_defined();
+ m_dependencies.clear();
+ }
+
+ void add_dependency(node& rhs) {
+ if (is_defined())
+ rhs.mark_defined();
+ else
+ m_dependencies.insert(&rhs);
+ }
+
+ void set_ref(const node& rhs) {
+ if (rhs.is_defined())
+ mark_defined();
+ m_pRef = rhs.m_pRef;
+ }
+ void set_data(const node& rhs) {
+ if (rhs.is_defined())
+ mark_defined();
+ m_pRef->set_data(*rhs.m_pRef);
+ }
+
+ void set_mark(const Mark& mark) { m_pRef->set_mark(mark); }
+
+ void set_type(NodeType::value type) {
+ if (type != NodeType::Undefined)
+ mark_defined();
+ m_pRef->set_type(type);
+ }
+ void set_null() {
+ mark_defined();
+ m_pRef->set_null();
+ }
+ void set_scalar(const std::string& scalar) {
+ mark_defined();
+ m_pRef->set_scalar(scalar);
+ }
+ void set_tag(const std::string& tag) {
+ mark_defined();
+ m_pRef->set_tag(tag);
+ }
+
+ // style
+ void set_style(EmitterStyle::value style) {
+ mark_defined();
+ m_pRef->set_style(style);
+ }
+
+ // size/iterator
+ std::size_t size() const { return m_pRef->size(); }
+
+ const_node_iterator begin() const {
+ return static_cast<const node_ref&>(*m_pRef).begin();
+ }
+ node_iterator begin() { return m_pRef->begin(); }
+
+ const_node_iterator end() const {
+ return static_cast<const node_ref&>(*m_pRef).end();
+ }
+ node_iterator end() { return m_pRef->end(); }
+
+ // sequence
+ void push_back(node& input, shared_memory_holder pMemory) {
+ m_pRef->push_back(input, pMemory);
+ input.add_dependency(*this);
+ m_index = m_amount.fetch_add(1);
+ }
+ void insert(node& key, node& value, shared_memory_holder pMemory) {
+ m_pRef->insert(key, value, pMemory);
+ key.add_dependency(*this);
+ value.add_dependency(*this);
+ }
+
+ // indexing
+ template <typename Key>
+ node* get(const Key& key, shared_memory_holder pMemory) const {
+ // NOTE: this returns a non-const node so that the top-level Node can wrap
+ // it, and returns a pointer so that it can be nullptr (if there is no such
+ // key).
+ return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
+ }
+ template <typename Key>
+ node& get(const Key& key, shared_memory_holder pMemory) {
+ node& value = m_pRef->get(key, pMemory);
+ value.add_dependency(*this);
+ return value;
+ }
+ template <typename Key>
+ bool remove(const Key& key, shared_memory_holder pMemory) {
+ return m_pRef->remove(key, pMemory);
+ }
+
+ node* get(node& key, shared_memory_holder pMemory) const {
+ // NOTE: this returns a non-const node so that the top-level Node can wrap
+ // it, and returns a pointer so that it can be nullptr (if there is no such
+ // key).
+ return static_cast<const node_ref&>(*m_pRef).get(key, pMemory);
+ }
+ node& get(node& key, shared_memory_holder pMemory) {
+ node& value = m_pRef->get(key, pMemory);
+ key.add_dependency(*this);
+ value.add_dependency(*this);
+ return value;
+ }
+ bool remove(node& key, shared_memory_holder pMemory) {
+ return m_pRef->remove(key, pMemory);
+ }
+
+ // map
+ template <typename Key, typename Value>
+ void force_insert(const Key& key, const Value& value,
+ shared_memory_holder pMemory) {
+ m_pRef->force_insert(key, value, pMemory);
+ }
+
+ private:
+ shared_node_ref m_pRef;
+ using nodes = std::set<node*, less>;
+ nodes m_dependencies;
+ size_t m_index;
+ static YAML_CPP_API std::atomic<size_t> m_amount;
+};
+} // namespace detail
+} // namespace YAML
+
+#endif // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <list>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/detail/node_iterator.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.h"
+
+namespace YAML {
+namespace detail {
+class node;
+} // namespace detail
+} // namespace YAML
+
+namespace YAML {
+namespace detail {
+class YAML_CPP_API node_data {
+ public:
+ node_data();
+ node_data(const node_data&) = delete;
+ node_data& operator=(const node_data&) = delete;
+
+ void mark_defined();
+ void set_mark(const Mark& mark);
+ void set_type(NodeType::value type);
+ void set_tag(const std::string& tag);
+ void set_null();
+ void set_scalar(const std::string& scalar);
+ void set_style(EmitterStyle::value style);
+
+ bool is_defined() const { return m_isDefined; }
+ const Mark& mark() const { return m_mark; }
+ NodeType::value type() const {
+ return m_isDefined ? m_type : NodeType::Undefined;
+ }
+ const std::string& scalar() const { return m_scalar; }
+ const std::string& tag() const { return m_tag; }
+ EmitterStyle::value style() const { return m_style; }
+
+ // size/iterator
+ std::size_t size() const;
+
+ const_node_iterator begin() const;
+ node_iterator begin();
+
+ const_node_iterator end() const;
+ node_iterator end();
+
+ // sequence
+ void push_back(node& node, const shared_memory_holder& pMemory);
+ void insert(node& key, node& value, const shared_memory_holder& pMemory);
+
+ // indexing
+ template <typename Key>
+ node* get(const Key& key, shared_memory_holder pMemory) const;
+ template <typename Key>
+ node& get(const Key& key, shared_memory_holder pMemory);
+ template <typename Key>
+ bool remove(const Key& key, shared_memory_holder pMemory);
+
+ node* get(node& key, const shared_memory_holder& pMemory) const;
+ node& get(node& key, const shared_memory_holder& pMemory);
+ bool remove(node& key, const shared_memory_holder& pMemory);
+
+ // map
+ template <typename Key, typename Value>
+ void force_insert(const Key& key, const Value& value,
+ shared_memory_holder pMemory);
+
+ public:
+ static const std::string& empty_scalar();
+
+ private:
+ void compute_seq_size() const;
+ void compute_map_size() const;
+
+ void reset_sequence();
+ void reset_map();
+
+ void insert_map_pair(node& key, node& value);
+ void convert_to_map(const shared_memory_holder& pMemory);
+ void convert_sequence_to_map(const shared_memory_holder& pMemory);
+
+ template <typename T>
+ static node& convert_to_node(const T& rhs, shared_memory_holder pMemory);
+
+ private:
+ bool m_isDefined;
+ Mark m_mark;
+ NodeType::value m_type;
+ std::string m_tag;
+ EmitterStyle::value m_style;
+
+ // scalar
+ std::string m_scalar;
+
+ // sequence
+ using node_seq = std::vector<node *>;
+ node_seq m_sequence;
+
+ mutable std::size_t m_seqSize;
+
+ // map
+ using node_map = std::vector<std::pair<node*, node*>>;
+ node_map m_map;
+
+ using kv_pair = std::pair<node*, node*>;
+ using kv_pairs = std::list<kv_pair>;
+ mutable kv_pairs m_undefinedPairs;
+};
+}
+}
+
+#endif // VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/ptr.h"
+#include <cstddef>
+#include <iterator>
+#include <memory>
+#include <map>
+#include <utility>
+#include <vector>
+
+namespace YAML {
+namespace detail {
+struct iterator_type {
+ enum value { NoneType, Sequence, Map };
+};
+
+template <typename V>
+struct node_iterator_value : public std::pair<V*, V*> {
+ using kv = std::pair<V*, V*>;
+
+ node_iterator_value() : kv(), pNode(nullptr) {}
+ explicit node_iterator_value(V& rhs) : kv(), pNode(&rhs) {}
+ explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(nullptr) {}
+
+ V& operator*() const { return *pNode; }
+ V& operator->() const { return *pNode; }
+
+ V* pNode;
+};
+
+using node_seq = std::vector<node *>;
+using node_map = std::vector<std::pair<node*, node*>>;
+
+template <typename V>
+struct node_iterator_type {
+ using seq = node_seq::iterator;
+ using map = node_map::iterator;
+};
+
+template <typename V>
+struct node_iterator_type<const V> {
+ using seq = node_seq::const_iterator;
+ using map = node_map::const_iterator;
+};
+
+template <typename V>
+class node_iterator_base {
+ private:
+ struct enabler {};
+
+ struct proxy {
+ explicit proxy(const node_iterator_value<V>& x) : m_ref(x) {}
+ node_iterator_value<V>* operator->() { return std::addressof(m_ref); }
+ operator node_iterator_value<V>*() { return std::addressof(m_ref); }
+
+ node_iterator_value<V> m_ref;
+ };
+
+ public:
+ using iterator_category = std::forward_iterator_tag;
+ using value_type = node_iterator_value<V>;
+ using difference_type = std::ptrdiff_t;
+ using pointer = node_iterator_value<V>*;
+ using reference = node_iterator_value<V>;
+ using SeqIter = typename node_iterator_type<V>::seq;
+ using MapIter = typename node_iterator_type<V>::map;
+
+ node_iterator_base()
+ : m_type(iterator_type::NoneType), m_seqIt(), m_mapIt(), m_mapEnd() {}
+ explicit node_iterator_base(SeqIter seqIt)
+ : m_type(iterator_type::Sequence),
+ m_seqIt(seqIt),
+ m_mapIt(),
+ m_mapEnd() {}
+ explicit node_iterator_base(MapIter mapIt, MapIter mapEnd)
+ : m_type(iterator_type::Map),
+ m_seqIt(),
+ m_mapIt(mapIt),
+ m_mapEnd(mapEnd) {
+ m_mapIt = increment_until_defined(m_mapIt);
+ }
+
+ template <typename W>
+ node_iterator_base(const node_iterator_base<W>& rhs,
+ typename std::enable_if<std::is_convertible<W*, V*>::value,
+ enabler>::type = enabler())
+ : m_type(rhs.m_type),
+ m_seqIt(rhs.m_seqIt),
+ m_mapIt(rhs.m_mapIt),
+ m_mapEnd(rhs.m_mapEnd) {}
+
+ template <typename>
+ friend class node_iterator_base;
+
+ template <typename W>
+ bool operator==(const node_iterator_base<W>& rhs) const {
+ if (m_type != rhs.m_type)
+ return false;
+
+ switch (m_type) {
+ case iterator_type::NoneType:
+ return true;
+ case iterator_type::Sequence:
+ return m_seqIt == rhs.m_seqIt;
+ case iterator_type::Map:
+ return m_mapIt == rhs.m_mapIt;
+ }
+ return true;
+ }
+
+ template <typename W>
+ bool operator!=(const node_iterator_base<W>& rhs) const {
+ return !(*this == rhs);
+ }
+
+ node_iterator_base<V>& operator++() {
+ switch (m_type) {
+ case iterator_type::NoneType:
+ break;
+ case iterator_type::Sequence:
+ ++m_seqIt;
+ break;
+ case iterator_type::Map:
+ ++m_mapIt;
+ m_mapIt = increment_until_defined(m_mapIt);
+ break;
+ }
+ return *this;
+ }
+
+ node_iterator_base<V> operator++(int) {
+ node_iterator_base<V> iterator_pre(*this);
+ ++(*this);
+ return iterator_pre;
+ }
+
+ value_type operator*() const {
+ switch (m_type) {
+ case iterator_type::NoneType:
+ return value_type();
+ case iterator_type::Sequence:
+ return value_type(**m_seqIt);
+ case iterator_type::Map:
+ return value_type(*m_mapIt->first, *m_mapIt->second);
+ }
+ return value_type();
+ }
+
+ proxy operator->() const { return proxy(**this); }
+
+ MapIter increment_until_defined(MapIter it) {
+ while (it != m_mapEnd && !is_defined(it))
+ ++it;
+ return it;
+ }
+
+ bool is_defined(MapIter it) const {
+ return it->first->is_defined() && it->second->is_defined();
+ }
+
+ private:
+ typename iterator_type::value m_type;
+
+ SeqIter m_seqIt;
+ MapIter m_mapIt, m_mapEnd;
+};
+
+using node_iterator = node_iterator_base<node>;
+using const_node_iterator = node_iterator_base<const node>;
+}
+}
+
+#endif // VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/type.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/detail/node_data.h"
+
+namespace YAML {
+namespace detail {
+class node_ref {
+ public:
+ node_ref() : m_pData(new node_data) {}
+ node_ref(const node_ref&) = delete;
+ node_ref& operator=(const node_ref&) = delete;
+
+ bool is_defined() const { return m_pData->is_defined(); }
+ const Mark& mark() const { return m_pData->mark(); }
+ NodeType::value type() const { return m_pData->type(); }
+ const std::string& scalar() const { return m_pData->scalar(); }
+ const std::string& tag() const { return m_pData->tag(); }
+ EmitterStyle::value style() const { return m_pData->style(); }
+
+ void mark_defined() { m_pData->mark_defined(); }
+ void set_data(const node_ref& rhs) { m_pData = rhs.m_pData; }
+
+ void set_mark(const Mark& mark) { m_pData->set_mark(mark); }
+ void set_type(NodeType::value type) { m_pData->set_type(type); }
+ void set_tag(const std::string& tag) { m_pData->set_tag(tag); }
+ void set_null() { m_pData->set_null(); }
+ void set_scalar(const std::string& scalar) { m_pData->set_scalar(scalar); }
+ void set_style(EmitterStyle::value style) { m_pData->set_style(style); }
+
+ // size/iterator
+ std::size_t size() const { return m_pData->size(); }
+
+ const_node_iterator begin() const {
+ return static_cast<const node_data&>(*m_pData).begin();
+ }
+ node_iterator begin() { return m_pData->begin(); }
+
+ const_node_iterator end() const {
+ return static_cast<const node_data&>(*m_pData).end();
+ }
+ node_iterator end() { return m_pData->end(); }
+
+ // sequence
+ void push_back(node& node, shared_memory_holder pMemory) {
+ m_pData->push_back(node, pMemory);
+ }
+ void insert(node& key, node& value, shared_memory_holder pMemory) {
+ m_pData->insert(key, value, pMemory);
+ }
+
+ // indexing
+ template <typename Key>
+ node* get(const Key& key, shared_memory_holder pMemory) const {
+ return static_cast<const node_data&>(*m_pData).get(key, pMemory);
+ }
+ template <typename Key>
+ node& get(const Key& key, shared_memory_holder pMemory) {
+ return m_pData->get(key, pMemory);
+ }
+ template <typename Key>
+ bool remove(const Key& key, shared_memory_holder pMemory) {
+ return m_pData->remove(key, pMemory);
+ }
+
+ node* get(node& key, shared_memory_holder pMemory) const {
+ return static_cast<const node_data&>(*m_pData).get(key, pMemory);
+ }
+ node& get(node& key, shared_memory_holder pMemory) {
+ return m_pData->get(key, pMemory);
+ }
+ bool remove(node& key, shared_memory_holder pMemory) {
+ return m_pData->remove(key, pMemory);
+ }
+
+ // map
+ template <typename Key, typename Value>
+ void force_insert(const Key& key, const Value& value,
+ shared_memory_holder pMemory) {
+ m_pData->force_insert(key, value, pMemory);
+ }
+
+ private:
+ shared_node_data m_pData;
+};
+}
+}
+
+#endif // VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <iosfwd>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+class Emitter;
+class Node;
+
+/**
+ * Emits the node to the given {@link Emitter}. If there is an error in writing,
+ * {@link Emitter#good} will return false.
+ */
+YAML_CPP_API Emitter& operator<<(Emitter& out, const Node& node);
+
+/** Emits the node to the given output stream. */
+YAML_CPP_API std::ostream& operator<<(std::ostream& out, const Node& node);
+
+/** Converts the node to a YAML string. */
+YAML_CPP_API std::string Dump(const Node& node);
+} // namespace YAML
+
+#endif // NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/exceptions.h"
+#include "yaml-cpp/node/detail/memory.h"
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/node.h"
+#include <sstream>
+#include <string>
+
+namespace YAML {
+inline Node::Node()
+ : m_isValid(true), m_invalidKey{}, m_pMemory(nullptr), m_pNode(nullptr) {}
+
+inline Node::Node(NodeType::value type)
+ : m_isValid(true),
+ m_invalidKey{},
+ m_pMemory(new detail::memory_holder),
+ m_pNode(&m_pMemory->create_node()) {
+ m_pNode->set_type(type);
+}
+
+template <typename T>
+inline Node::Node(const T& rhs)
+ : m_isValid(true),
+ m_invalidKey{},
+ m_pMemory(new detail::memory_holder),
+ m_pNode(&m_pMemory->create_node()) {
+ Assign(rhs);
+}
+
+inline Node::Node(const detail::iterator_value& rhs)
+ : m_isValid(rhs.m_isValid),
+ m_invalidKey(rhs.m_invalidKey),
+ m_pMemory(rhs.m_pMemory),
+ m_pNode(rhs.m_pNode) {}
+
+inline Node::Node(const Node&) = default;
+
+inline Node::Node(Zombie)
+ : m_isValid(false), m_invalidKey{}, m_pMemory{}, m_pNode(nullptr) {}
+
+inline Node::Node(Zombie, const std::string& key)
+ : m_isValid(false), m_invalidKey(key), m_pMemory{}, m_pNode(nullptr) {}
+
+inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory)
+ : m_isValid(true), m_invalidKey{}, m_pMemory(pMemory), m_pNode(&node) {}
+
+inline Node::~Node() = default;
+
+inline void Node::EnsureNodeExists() const {
+ if (!m_isValid)
+ throw InvalidNode(m_invalidKey);
+ if (!m_pNode) {
+ m_pMemory.reset(new detail::memory_holder);
+ m_pNode = &m_pMemory->create_node();
+ m_pNode->set_null();
+ }
+}
+
+inline bool Node::IsDefined() const {
+ if (!m_isValid) {
+ return false;
+ }
+ return m_pNode ? m_pNode->is_defined() : true;
+}
+
+inline Mark Node::Mark() const {
+ if (!m_isValid) {
+ throw InvalidNode(m_invalidKey);
+ }
+ return m_pNode ? m_pNode->mark() : Mark::null_mark();
+}
+
+inline NodeType::value Node::Type() const {
+ if (!m_isValid)
+ throw InvalidNode(m_invalidKey);
+ return m_pNode ? m_pNode->type() : NodeType::Null;
+}
+
+// access
+
+// template helpers
+template <typename T, typename S>
+struct as_if {
+ explicit as_if(const Node& node_) : node(node_) {}
+ const Node& node;
+
+ T operator()(const S& fallback) const {
+ if (!node.m_pNode)
+ return fallback;
+
+ T t;
+ if (convert<T>::decode(node, t))
+ return t;
+ return fallback;
+ }
+};
+
+template <typename S>
+struct as_if<std::string, S> {
+ explicit as_if(const Node& node_) : node(node_) {}
+ const Node& node;
+
+ std::string operator()(const S& fallback) const {
+ if (node.Type() == NodeType::Null)
+ return "null";
+ if (node.Type() != NodeType::Scalar)
+ return fallback;
+ return node.Scalar();
+ }
+};
+
+template <typename T>
+struct as_if<T, void> {
+ explicit as_if(const Node& node_) : node(node_) {}
+ const Node& node;
+
+ T operator()() const {
+ if (!node.m_pNode)
+ throw TypedBadConversion<T>(node.Mark());
+
+ T t;
+ if (convert<T>::decode(node, t))
+ return t;
+ throw TypedBadConversion<T>(node.Mark());
+ }
+};
+
+template <>
+struct as_if<std::string, void> {
+ explicit as_if(const Node& node_) : node(node_) {}
+ const Node& node;
+
+ std::string operator()() const {
+ if (node.Type() == NodeType::Null)
+ return "null";
+ if (node.Type() != NodeType::Scalar)
+ throw TypedBadConversion<std::string>(node.Mark());
+ return node.Scalar();
+ }
+};
+
+// access functions
+template <typename T>
+inline T Node::as() const {
+ if (!m_isValid)
+ throw InvalidNode(m_invalidKey);
+ return as_if<T, void>(*this)();
+}
+
+template <typename T, typename S>
+inline T Node::as(const S& fallback) const {
+ if (!m_isValid)
+ return fallback;
+ return as_if<T, S>(*this)(fallback);
+}
+
+inline const std::string& Node::Scalar() const {
+ if (!m_isValid)
+ throw InvalidNode(m_invalidKey);
+ return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar();
+}
+
+inline const std::string& Node::Tag() const {
+ if (!m_isValid)
+ throw InvalidNode(m_invalidKey);
+ return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar();
+}
+
+inline void Node::SetTag(const std::string& tag) {
+ EnsureNodeExists();
+ m_pNode->set_tag(tag);
+}
+
+inline EmitterStyle::value Node::Style() const {
+ if (!m_isValid)
+ throw InvalidNode(m_invalidKey);
+ return m_pNode ? m_pNode->style() : EmitterStyle::Default;
+}
+
+inline void Node::SetStyle(EmitterStyle::value style) {
+ EnsureNodeExists();
+ m_pNode->set_style(style);
+}
+
+// assignment
+inline bool Node::is(const Node& rhs) const {
+ if (!m_isValid || !rhs.m_isValid)
+ throw InvalidNode(m_invalidKey);
+ if (!m_pNode || !rhs.m_pNode)
+ return false;
+ return m_pNode->is(*rhs.m_pNode);
+}
+
+template <typename T>
+inline Node& Node::operator=(const T& rhs) {
+ Assign(rhs);
+ return *this;
+}
+
+inline Node& Node::operator=(const Node& rhs) {
+ if (is(rhs))
+ return *this;
+ AssignNode(rhs);
+ return *this;
+}
+
+inline void Node::reset(const YAML::Node& rhs) {
+ if (!m_isValid || !rhs.m_isValid)
+ throw InvalidNode(m_invalidKey);
+ m_pMemory = rhs.m_pMemory;
+ m_pNode = rhs.m_pNode;
+}
+
+template <typename T>
+inline void Node::Assign(const T& rhs) {
+ if (!m_isValid)
+ throw InvalidNode(m_invalidKey);
+ AssignData(convert<T>::encode(rhs));
+}
+
+template <>
+inline void Node::Assign(const std::string& rhs) {
+ EnsureNodeExists();
+ m_pNode->set_scalar(rhs);
+}
+
+inline void Node::Assign(const char* rhs) {
+ EnsureNodeExists();
+ m_pNode->set_scalar(rhs);
+}
+
+inline void Node::Assign(char* rhs) {
+ EnsureNodeExists();
+ m_pNode->set_scalar(rhs);
+}
+
+inline void Node::AssignData(const Node& rhs) {
+ EnsureNodeExists();
+ rhs.EnsureNodeExists();
+
+ m_pNode->set_data(*rhs.m_pNode);
+ m_pMemory->merge(*rhs.m_pMemory);
+}
+
+inline void Node::AssignNode(const Node& rhs) {
+ if (!m_isValid)
+ throw InvalidNode(m_invalidKey);
+ rhs.EnsureNodeExists();
+
+ if (!m_pNode) {
+ m_pNode = rhs.m_pNode;
+ m_pMemory = rhs.m_pMemory;
+ return;
+ }
+
+ m_pNode->set_ref(*rhs.m_pNode);
+ m_pMemory->merge(*rhs.m_pMemory);
+ m_pNode = rhs.m_pNode;
+}
+
+// size/iterator
+inline std::size_t Node::size() const {
+ if (!m_isValid)
+ throw InvalidNode(m_invalidKey);
+ return m_pNode ? m_pNode->size() : 0;
+}
+
+inline const_iterator Node::begin() const {
+ if (!m_isValid)
+ return const_iterator();
+ return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory)
+ : const_iterator();
+}
+
+inline iterator Node::begin() {
+ if (!m_isValid)
+ return iterator();
+ return m_pNode ? iterator(m_pNode->begin(), m_pMemory) : iterator();
+}
+
+inline const_iterator Node::end() const {
+ if (!m_isValid)
+ return const_iterator();
+ return m_pNode ? const_iterator(m_pNode->end(), m_pMemory) : const_iterator();
+}
+
+inline iterator Node::end() {
+ if (!m_isValid)
+ return iterator();
+ return m_pNode ? iterator(m_pNode->end(), m_pMemory) : iterator();
+}
+
+// sequence
+template <typename T>
+inline void Node::push_back(const T& rhs) {
+ if (!m_isValid)
+ throw InvalidNode(m_invalidKey);
+ push_back(Node(rhs));
+}
+
+inline void Node::push_back(const Node& rhs) {
+ EnsureNodeExists();
+ rhs.EnsureNodeExists();
+
+ m_pNode->push_back(*rhs.m_pNode, m_pMemory);
+ m_pMemory->merge(*rhs.m_pMemory);
+}
+
+template<typename Key>
+std::string key_to_string(const Key& key) {
+ return streamable_to_string<Key, is_streamable<std::stringstream, Key>::value>().impl(key);
+}
+
+// indexing
+template <typename Key>
+inline const Node Node::operator[](const Key& key) const {
+ EnsureNodeExists();
+ detail::node* value =
+ static_cast<const detail::node&>(*m_pNode).get(key, m_pMemory);
+ if (!value) {
+ return Node(ZombieNode, key_to_string(key));
+ }
+ return Node(*value, m_pMemory);
+}
+
+template <typename Key>
+inline Node Node::operator[](const Key& key) {
+ EnsureNodeExists();
+ detail::node& value = m_pNode->get(key, m_pMemory);
+ return Node(value, m_pMemory);
+}
+
+template <typename Key>
+inline bool Node::remove(const Key& key) {
+ EnsureNodeExists();
+ return m_pNode->remove(key, m_pMemory);
+}
+
+inline const Node Node::operator[](const Node& key) const {
+ EnsureNodeExists();
+ key.EnsureNodeExists();
+ m_pMemory->merge(*key.m_pMemory);
+ detail::node* value =
+ static_cast<const detail::node&>(*m_pNode).get(*key.m_pNode, m_pMemory);
+ if (!value) {
+ return Node(ZombieNode, key_to_string(key));
+ }
+ return Node(*value, m_pMemory);
+}
+
+inline Node Node::operator[](const Node& key) {
+ EnsureNodeExists();
+ key.EnsureNodeExists();
+ m_pMemory->merge(*key.m_pMemory);
+ detail::node& value = m_pNode->get(*key.m_pNode, m_pMemory);
+ return Node(value, m_pMemory);
+}
+
+inline bool Node::remove(const Node& key) {
+ EnsureNodeExists();
+ key.EnsureNodeExists();
+ return m_pNode->remove(*key.m_pNode, m_pMemory);
+}
+
+// map
+template <typename Key, typename Value>
+inline void Node::force_insert(const Key& key, const Value& value) {
+ EnsureNodeExists();
+ m_pNode->force_insert(key, value, m_pMemory);
+}
+
+// free functions
+inline bool operator==(const Node& lhs, const Node& rhs) { return lhs.is(rhs); }
+} // namespace YAML
+
+#endif // NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/detail/iterator_fwd.h"
+#include "yaml-cpp/node/detail/iterator.h"
+#include <list>
+#include <utility>
+#include <vector>
+
+// Assert in place so gcc + libc++ combination properly builds
+static_assert(std::is_constructible<YAML::Node, const YAML::Node&>::value, "Node must be copy constructable");
+
+namespace YAML {
+namespace detail {
+struct iterator_value : public Node, std::pair<Node, Node> {
+ iterator_value() = default;
+ explicit iterator_value(const Node& rhs)
+ : Node(rhs),
+ std::pair<Node, Node>(Node(Node::ZombieNode), Node(Node::ZombieNode)) {}
+ explicit iterator_value(const Node& key, const Node& value)
+ : Node(Node::ZombieNode), std::pair<Node, Node>(key, value) {}
+};
+}
+}
+
+#endif // VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <stdexcept>
+#include <string>
+
+#include "yaml-cpp/dll.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/node/detail/iterator_fwd.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.h"
+
+namespace YAML {
+namespace detail {
+class node;
+class node_data;
+struct iterator_value;
+} // namespace detail
+} // namespace YAML
+
+namespace YAML {
+class YAML_CPP_API Node {
+ public:
+ friend class NodeBuilder;
+ friend class NodeEvents;
+ friend struct detail::iterator_value;
+ friend class detail::node;
+ friend class detail::node_data;
+ template <typename>
+ friend class detail::iterator_base;
+ template <typename T, typename S>
+ friend struct as_if;
+
+ using iterator = YAML::iterator;
+ using const_iterator = YAML::const_iterator;
+
+ Node();
+ explicit Node(NodeType::value type);
+ template <typename T>
+ explicit Node(const T& rhs);
+ explicit Node(const detail::iterator_value& rhs);
+ Node(const Node& rhs);
+ ~Node();
+
+ YAML::Mark Mark() const;
+ NodeType::value Type() const;
+ bool IsDefined() const;
+ bool IsNull() const { return Type() == NodeType::Null; }
+ bool IsScalar() const { return Type() == NodeType::Scalar; }
+ bool IsSequence() const { return Type() == NodeType::Sequence; }
+ bool IsMap() const { return Type() == NodeType::Map; }
+
+ // bool conversions
+ explicit operator bool() const { return IsDefined(); }
+ bool operator!() const { return !IsDefined(); }
+
+ // access
+ template <typename T>
+ T as() const;
+ template <typename T, typename S>
+ T as(const S& fallback) const;
+ const std::string& Scalar() const;
+
+ const std::string& Tag() const;
+ void SetTag(const std::string& tag);
+
+ // style
+ // WARNING: This API might change in future releases.
+ EmitterStyle::value Style() const;
+ void SetStyle(EmitterStyle::value style);
+
+ // assignment
+ bool is(const Node& rhs) const;
+ template <typename T>
+ Node& operator=(const T& rhs);
+ Node& operator=(const Node& rhs);
+ void reset(const Node& rhs = Node());
+
+ // size/iterator
+ std::size_t size() const;
+
+ const_iterator begin() const;
+ iterator begin();
+
+ const_iterator end() const;
+ iterator end();
+
+ // sequence
+ template <typename T>
+ void push_back(const T& rhs);
+ void push_back(const Node& rhs);
+
+ // indexing
+ template <typename Key>
+ const Node operator[](const Key& key) const;
+ template <typename Key>
+ Node operator[](const Key& key);
+ template <typename Key>
+ bool remove(const Key& key);
+
+ const Node operator[](const Node& key) const;
+ Node operator[](const Node& key);
+ bool remove(const Node& key);
+
+ // map
+ template <typename Key, typename Value>
+ void force_insert(const Key& key, const Value& value);
+
+ private:
+ enum Zombie { ZombieNode };
+ explicit Node(Zombie);
+ explicit Node(Zombie, const std::string&);
+ explicit Node(detail::node& node, detail::shared_memory_holder pMemory);
+
+ void EnsureNodeExists() const;
+
+ template <typename T>
+ void Assign(const T& rhs);
+ void Assign(const char* rhs);
+ void Assign(char* rhs);
+
+ void AssignData(const Node& rhs);
+ void AssignNode(const Node& rhs);
+
+ private:
+ bool m_isValid;
+ // String representation of invalid key, if the node is invalid.
+ std::string m_invalidKey;
+ mutable detail::shared_memory_holder m_pMemory;
+ mutable detail::node* m_pNode;
+};
+
+YAML_CPP_API bool operator==(const Node& lhs, const Node& rhs);
+
+YAML_CPP_API Node Clone(const Node& node);
+
+template <typename T>
+struct convert;
+}
+
+#endif // NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+class Node;
+
+/**
+ * Loads the input string as a single YAML document.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ */
+YAML_CPP_API Node Load(const std::string& input);
+
+/**
+ * Loads the input string as a single YAML document.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ */
+YAML_CPP_API Node Load(const char* input);
+
+/**
+ * Loads the input stream as a single YAML document.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ */
+YAML_CPP_API Node Load(std::istream& input);
+
+/**
+ * Loads the input file as a single YAML document.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ * @throws {@link BadFile} if the file cannot be loaded.
+ */
+YAML_CPP_API Node LoadFile(const std::string& filename);
+
+/**
+ * Loads the input string as a list of YAML documents.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ */
+YAML_CPP_API std::vector<Node> LoadAll(const std::string& input);
+
+/**
+ * Loads the input string as a list of YAML documents.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ */
+YAML_CPP_API std::vector<Node> LoadAll(const char* input);
+
+/**
+ * Loads the input stream as a list of YAML documents.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ */
+YAML_CPP_API std::vector<Node> LoadAll(std::istream& input);
+
+/**
+ * Loads the input file as a list of YAML documents.
+ *
+ * @throws {@link ParserException} if it is malformed.
+ * @throws {@link BadFile} if the file cannot be loaded.
+ */
+YAML_CPP_API std::vector<Node> LoadAllFromFile(const std::string& filename);
+} // namespace YAML
+
+#endif // VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <memory>
+
+namespace YAML {
+namespace detail {
+class node;
+class node_ref;
+class node_data;
+class memory;
+class memory_holder;
+
+using shared_node = std::shared_ptr<node>;
+using shared_node_ref = std::shared_ptr<node_ref>;
+using shared_node_data = std::shared_ptr<node_data>;
+using shared_memory_holder = std::shared_ptr<memory_holder>;
+using shared_memory = std::shared_ptr<memory>;
+}
+}
+
+#endif // VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+namespace YAML {
+struct NodeType {
+ enum value { Undefined, Null, Scalar, Sequence, Map };
+};
+}
+
+#endif // VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef NOEXCEPT_H_768872DA_476C_11EA_88B8_90B11C0C0FF8
+#define NOEXCEPT_H_768872DA_476C_11EA_88B8_90B11C0C0FF8
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+// This is here for compatibility with older versions of Visual Studio
+// which don't support noexcept.
+#if defined(_MSC_VER) && _MSC_VER < 1900
+ #define YAML_CPP_NOEXCEPT _NOEXCEPT
+#else
+ #define YAML_CPP_NOEXCEPT noexcept
+#endif
+
+#endif
--- /dev/null
+#ifndef NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/dll.h"
+#include <string>
+
+namespace YAML {
+class Node;
+
+struct YAML_CPP_API _Null {};
+inline bool operator==(const _Null&, const _Null&) { return true; }
+inline bool operator!=(const _Null&, const _Null&) { return false; }
+
+YAML_CPP_API bool IsNull(const Node& node); // old API only
+YAML_CPP_API bool IsNullString(const std::string& str);
+
+extern YAML_CPP_API _Null Null;
+}
+
+#endif // NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <vector>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+class YAML_CPP_API ostream_wrapper {
+ public:
+ ostream_wrapper();
+ explicit ostream_wrapper(std::ostream& stream);
+ ostream_wrapper(const ostream_wrapper&) = delete;
+ ostream_wrapper(ostream_wrapper&&) = delete;
+ ostream_wrapper& operator=(const ostream_wrapper&) = delete;
+ ostream_wrapper& operator=(ostream_wrapper&&) = delete;
+ ~ostream_wrapper();
+
+ void write(const std::string& str);
+ void write(const char* str, std::size_t size);
+
+ void set_comment() { m_comment = true; }
+
+ const char* str() const {
+ if (m_pStream) {
+ return nullptr;
+ } else {
+ m_buffer[m_pos] = '\0';
+ return &m_buffer[0];
+ }
+ }
+
+ std::size_t row() const { return m_row; }
+ std::size_t col() const { return m_col; }
+ std::size_t pos() const { return m_pos; }
+ bool comment() const { return m_comment; }
+
+ private:
+ void update_pos(char ch);
+
+ private:
+ mutable std::vector<char> m_buffer;
+ std::ostream* const m_pStream;
+
+ std::size_t m_pos;
+ std::size_t m_row, m_col;
+ bool m_comment;
+};
+
+template <std::size_t N>
+inline ostream_wrapper& operator<<(ostream_wrapper& stream,
+ const char (&str)[N]) {
+ stream.write(str, N - 1);
+ return stream;
+}
+
+inline ostream_wrapper& operator<<(ostream_wrapper& stream,
+ const std::string& str) {
+ stream.write(str);
+ return stream;
+}
+
+inline ostream_wrapper& operator<<(ostream_wrapper& stream, char ch) {
+ stream.write(&ch, 1);
+ return stream;
+}
+} // namespace YAML
+
+#endif // OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <ios>
+#include <memory>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+class EventHandler;
+class Node;
+class Scanner;
+struct Directives;
+struct Token;
+
+/**
+ * A parser turns a stream of bytes into one stream of "events" per YAML
+ * document in the input stream.
+ */
+class YAML_CPP_API Parser {
+ public:
+ /** Constructs an empty parser (with no input. */
+ Parser();
+
+ Parser(const Parser&) = delete;
+ Parser(Parser&&) = delete;
+ Parser& operator=(const Parser&) = delete;
+ Parser& operator=(Parser&&) = delete;
+
+ /**
+ * Constructs a parser from the given input stream. The input stream must
+ * live as long as the parser.
+ */
+ explicit Parser(std::istream& in);
+
+ ~Parser();
+
+ /** Evaluates to true if the parser has some valid input to be read. */
+ explicit operator bool() const;
+
+ /**
+ * Resets the parser with the given input stream. Any existing state is
+ * erased.
+ */
+ void Load(std::istream& in);
+
+ /**
+ * Handles the next document by calling events on the {@code eventHandler}.
+ *
+ * @throw a ParserException on error.
+ * @return false if there are no more documents
+ */
+ bool HandleNextDocument(EventHandler& eventHandler);
+
+ void PrintTokens(std::ostream& out);
+
+ private:
+ /**
+ * Reads any directives that are next in the queue, setting the internal
+ * {@code m_pDirectives} state.
+ */
+ void ParseDirectives();
+
+ void HandleDirective(const Token& token);
+
+ /**
+ * Handles a "YAML" directive, which should be of the form 'major.minor' (like
+ * a version number).
+ */
+ void HandleYamlDirective(const Token& token);
+
+ /**
+ * Handles a "TAG" directive, which should be of the form 'handle prefix',
+ * where 'handle' is converted to 'prefix' in the file.
+ */
+ void HandleTagDirective(const Token& token);
+
+ private:
+ std::unique_ptr<Scanner> m_pScanner;
+ std::unique_ptr<Directives> m_pDirectives;
+};
+} // namespace YAML
+
+#endif // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <vector>
+#include <list>
+#include <set>
+#include <map>
+
+namespace YAML {
+template <typename Seq>
+inline Emitter& EmitSeq(Emitter& emitter, const Seq& seq) {
+ emitter << BeginSeq;
+ for (const auto& v : seq)
+ emitter << v;
+ emitter << EndSeq;
+ return emitter;
+}
+
+template <typename T>
+inline Emitter& operator<<(Emitter& emitter, const std::vector<T>& v) {
+ return EmitSeq(emitter, v);
+}
+
+template <typename T>
+inline Emitter& operator<<(Emitter& emitter, const std::list<T>& v) {
+ return EmitSeq(emitter, v);
+}
+
+template <typename T>
+inline Emitter& operator<<(Emitter& emitter, const std::set<T>& v) {
+ return EmitSeq(emitter, v);
+}
+
+template <typename K, typename V>
+inline Emitter& operator<<(Emitter& emitter, const std::map<K, V>& m) {
+ emitter << BeginMap;
+ for (const auto& v : m)
+ emitter << Key << v.first << Value << v.second;
+ emitter << EndMap;
+ return emitter;
+}
+}
+
+#endif // STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <type_traits>
+#include <utility>
+#include <string>
+#include <sstream>
+
+namespace YAML {
+template <typename>
+struct is_numeric {
+ enum { value = false };
+};
+
+template <>
+struct is_numeric<char> {
+ enum { value = true };
+};
+template <>
+struct is_numeric<unsigned char> {
+ enum { value = true };
+};
+template <>
+struct is_numeric<int> {
+ enum { value = true };
+};
+template <>
+struct is_numeric<unsigned int> {
+ enum { value = true };
+};
+template <>
+struct is_numeric<long int> {
+ enum { value = true };
+};
+template <>
+struct is_numeric<unsigned long int> {
+ enum { value = true };
+};
+template <>
+struct is_numeric<short int> {
+ enum { value = true };
+};
+template <>
+struct is_numeric<unsigned short int> {
+ enum { value = true };
+};
+#if defined(_MSC_VER) && (_MSC_VER < 1310)
+template <>
+struct is_numeric<__int64> {
+ enum { value = true };
+};
+template <>
+struct is_numeric<unsigned __int64> {
+ enum { value = true };
+};
+#else
+template <>
+struct is_numeric<long long> {
+ enum { value = true };
+};
+template <>
+struct is_numeric<unsigned long long> {
+ enum { value = true };
+};
+#endif
+template <>
+struct is_numeric<float> {
+ enum { value = true };
+};
+template <>
+struct is_numeric<double> {
+ enum { value = true };
+};
+template <>
+struct is_numeric<long double> {
+ enum { value = true };
+};
+
+template <bool, class T = void>
+struct enable_if_c {
+ using type = T;
+};
+
+template <class T>
+struct enable_if_c<false, T> {};
+
+template <class Cond, class T = void>
+struct enable_if : public enable_if_c<Cond::value, T> {};
+
+template <bool, class T = void>
+struct disable_if_c {
+ using type = T;
+};
+
+template <class T>
+struct disable_if_c<true, T> {};
+
+template <class Cond, class T = void>
+struct disable_if : public disable_if_c<Cond::value, T> {};
+}
+
+template <typename S, typename T>
+struct is_streamable {
+ template <typename StreamT, typename ValueT>
+ static auto test(int)
+ -> decltype(std::declval<StreamT&>() << std::declval<ValueT>(), std::true_type());
+
+ template <typename, typename>
+ static auto test(...) -> std::false_type;
+
+ static const bool value = decltype(test<S, T>(0))::value;
+};
+
+template<typename Key, bool Streamable>
+struct streamable_to_string {
+ static std::string impl(const Key& key) {
+ std::stringstream ss;
+ ss << key;
+ return ss.str();
+ }
+};
+
+template<typename Key>
+struct streamable_to_string<Key, false> {
+ static std::string impl(const Key&) {
+ return "";
+ }
+};
+#endif // TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/parser.h"
+#include "yaml-cpp/emitter.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/stlemitter.h"
+#include "yaml-cpp/exceptions.h"
+
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/convert.h"
+#include "yaml-cpp/node/iterator.h"
+#include "yaml-cpp/node/detail/impl.h"
+#include "yaml-cpp/node/parse.h"
+#include "yaml-cpp/node/emit.h"
+
+#endif // YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+*** With CMake ***
+
+yaml-cpp uses CMake to support cross-platform building. In a UNIX-like system, the basic steps to build are:
+
+1. Download and install CMake (if you don't have root privileges, just install to a local directory, like ~/bin)
+
+2. From the source directory, run:
+
+mkdir build
+cd build
+cmake ..
+
+and then the usual
+
+make
+make install
+
+3. To clean up, just remove the 'build' directory.
+
+*** Without CMake ***
+
+If you don't want to use CMake, just add all .cpp files to a makefile. yaml-cpp does not need any special build settings, so no 'configure' file is necessary.
+
+(Note: this is pretty tedious. It's sooo much easier to use CMake.)
--- /dev/null
+#include "yaml-cpp/binary.h"
+
+#include <cctype>
+
+namespace YAML {
+static const char encoding[] =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+std::string EncodeBase64(const unsigned char *data, std::size_t size) {
+ const char PAD = '=';
+
+ std::string ret;
+ ret.resize(4 * size / 3 + 3);
+ char *out = &ret[0];
+
+ std::size_t chunks = size / 3;
+ std::size_t remainder = size % 3;
+
+ for (std::size_t i = 0; i < chunks; i++, data += 3) {
+ *out++ = encoding[data[0] >> 2];
+ *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)];
+ *out++ = encoding[((data[1] & 0xf) << 2) | (data[2] >> 6)];
+ *out++ = encoding[data[2] & 0x3f];
+ }
+
+ switch (remainder) {
+ case 0:
+ break;
+ case 1:
+ *out++ = encoding[data[0] >> 2];
+ *out++ = encoding[((data[0] & 0x3) << 4)];
+ *out++ = PAD;
+ *out++ = PAD;
+ break;
+ case 2:
+ *out++ = encoding[data[0] >> 2];
+ *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)];
+ *out++ = encoding[((data[1] & 0xf) << 2)];
+ *out++ = PAD;
+ break;
+ }
+
+ ret.resize(out - &ret[0]);
+ return ret;
+}
+
+static const unsigned char decoding[] = {
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255,
+ 255, 255, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255,
+ 255, 0, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+ 25, 255, 255, 255, 255, 255, 255, 26, 27, 28, 29, 30, 31, 32, 33,
+ 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+ 49, 50, 51, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+ 255,
+};
+
+std::vector<unsigned char> DecodeBase64(const std::string &input) {
+ using ret_type = std::vector<unsigned char>;
+ if (input.empty())
+ return ret_type();
+
+ ret_type ret(3 * input.size() / 4 + 1);
+ unsigned char *out = &ret[0];
+
+ unsigned value = 0;
+ for (std::size_t i = 0, cnt = 0; i < input.size(); i++) {
+ if (std::isspace(static_cast<unsigned char>(input[i]))) {
+ // skip newlines
+ continue;
+ }
+ unsigned char d = decoding[static_cast<unsigned char>(input[i])];
+ if (d == 255)
+ return ret_type();
+
+ value = (value << 6) | d;
+ if (cnt % 4 == 3) {
+ *out++ = value >> 16;
+ if (i > 0 && input[i - 1] != '=')
+ *out++ = value >> 8;
+ if (input[i] != '=')
+ *out++ = value;
+ }
+ ++cnt;
+ }
+
+ ret.resize(out - &ret[0]);
+ return ret;
+}
+} // namespace YAML
--- /dev/null
+#ifndef COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cassert>
+#include <stack>
+
+namespace YAML {
+struct CollectionType {
+ enum value { NoCollection, BlockMap, BlockSeq, FlowMap, FlowSeq, CompactMap };
+};
+
+class CollectionStack {
+ public:
+ CollectionStack() : collectionStack{} {}
+ CollectionType::value GetCurCollectionType() const {
+ if (collectionStack.empty())
+ return CollectionType::NoCollection;
+ return collectionStack.top();
+ }
+
+ void PushCollectionType(CollectionType::value type) {
+ collectionStack.push(type);
+ }
+ void PopCollectionType(CollectionType::value type) {
+ assert(type == GetCurCollectionType());
+ (void)type;
+ collectionStack.pop();
+ }
+
+ private:
+ std::stack<CollectionType::value> collectionStack;
+};
+} // namespace YAML
+
+#endif // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include "graphbuilderadapter.h"
+
+#include "yaml-cpp/parser.h" // IWYU pragma: keep
+
+namespace YAML {
+class GraphBuilderInterface;
+
+void* BuildGraphOfNextDocument(Parser& parser,
+ GraphBuilderInterface& graphBuilder) {
+ GraphBuilderAdapter eventHandler(graphBuilder);
+ if (parser.HandleNextDocument(eventHandler)) {
+ return eventHandler.RootNode();
+ }
+ return nullptr;
+}
+} // namespace YAML
--- /dev/null
+#include "graphbuilderadapter.h"
+#include "yaml-cpp/contrib/graphbuilder.h"
+
+namespace YAML {
+struct Mark;
+
+int GraphBuilderAdapter::ContainerFrame::sequenceMarker;
+
+void GraphBuilderAdapter::OnNull(const Mark &mark, anchor_t anchor) {
+ void *pParent = GetCurrentParent();
+ void *pNode = m_builder.NewNull(mark, pParent);
+ RegisterAnchor(anchor, pNode);
+
+ DispositionNode(pNode);
+}
+
+void GraphBuilderAdapter::OnAlias(const Mark &mark, anchor_t anchor) {
+ void *pReffedNode = m_anchors.Get(anchor);
+ DispositionNode(m_builder.AnchorReference(mark, pReffedNode));
+}
+
+void GraphBuilderAdapter::OnScalar(const Mark &mark, const std::string &tag,
+ anchor_t anchor, const std::string &value) {
+ void *pParent = GetCurrentParent();
+ void *pNode = m_builder.NewScalar(mark, tag, pParent, value);
+ RegisterAnchor(anchor, pNode);
+
+ DispositionNode(pNode);
+}
+
+void GraphBuilderAdapter::OnSequenceStart(const Mark &mark,
+ const std::string &tag,
+ anchor_t anchor,
+ EmitterStyle::value /* style */) {
+ void *pNode = m_builder.NewSequence(mark, tag, GetCurrentParent());
+ m_containers.push(ContainerFrame(pNode));
+ RegisterAnchor(anchor, pNode);
+}
+
+void GraphBuilderAdapter::OnSequenceEnd() {
+ void *pSequence = m_containers.top().pContainer;
+ m_containers.pop();
+
+ DispositionNode(pSequence);
+}
+
+void GraphBuilderAdapter::OnMapStart(const Mark &mark, const std::string &tag,
+ anchor_t anchor,
+ EmitterStyle::value /* style */) {
+ void *pNode = m_builder.NewMap(mark, tag, GetCurrentParent());
+ m_containers.push(ContainerFrame(pNode, m_pKeyNode));
+ m_pKeyNode = nullptr;
+ RegisterAnchor(anchor, pNode);
+}
+
+void GraphBuilderAdapter::OnMapEnd() {
+ void *pMap = m_containers.top().pContainer;
+ m_pKeyNode = m_containers.top().pPrevKeyNode;
+ m_containers.pop();
+ DispositionNode(pMap);
+}
+
+void *GraphBuilderAdapter::GetCurrentParent() const {
+ if (m_containers.empty()) {
+ return nullptr;
+ }
+ return m_containers.top().pContainer;
+}
+
+void GraphBuilderAdapter::RegisterAnchor(anchor_t anchor, void *pNode) {
+ if (anchor) {
+ m_anchors.Register(anchor, pNode);
+ }
+}
+
+void GraphBuilderAdapter::DispositionNode(void *pNode) {
+ if (m_containers.empty()) {
+ m_pRootNode = pNode;
+ return;
+ }
+
+ void *pContainer = m_containers.top().pContainer;
+ if (m_containers.top().isMap()) {
+ if (m_pKeyNode) {
+ m_builder.AssignInMap(pContainer, m_pKeyNode, pNode);
+ m_pKeyNode = nullptr;
+ } else {
+ m_pKeyNode = pNode;
+ }
+ } else {
+ m_builder.AppendToSequence(pContainer, pNode);
+ }
+}
+} // namespace YAML
--- /dev/null
+#ifndef GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstdlib>
+#include <map>
+#include <stack>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/contrib/anchordict.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+
+namespace YAML {
+class GraphBuilderInterface;
+struct Mark;
+} // namespace YAML
+
+namespace YAML {
+class GraphBuilderAdapter : public EventHandler {
+ public:
+ GraphBuilderAdapter(GraphBuilderInterface& builder)
+ : m_builder(builder),
+ m_containers{},
+ m_anchors{},
+ m_pRootNode(nullptr),
+ m_pKeyNode(nullptr) {}
+ GraphBuilderAdapter(const GraphBuilderAdapter&) = delete;
+ GraphBuilderAdapter(GraphBuilderAdapter&&) = delete;
+ GraphBuilderAdapter& operator=(const GraphBuilderAdapter&) = delete;
+ GraphBuilderAdapter& operator=(GraphBuilderAdapter&&) = delete;
+
+ virtual void OnDocumentStart(const Mark& mark) { (void)mark; }
+ virtual void OnDocumentEnd() {}
+
+ virtual void OnNull(const Mark& mark, anchor_t anchor);
+ virtual void OnAlias(const Mark& mark, anchor_t anchor);
+ virtual void OnScalar(const Mark& mark, const std::string& tag,
+ anchor_t anchor, const std::string& value);
+
+ virtual void OnSequenceStart(const Mark& mark, const std::string& tag,
+ anchor_t anchor, EmitterStyle::value style);
+ virtual void OnSequenceEnd();
+
+ virtual void OnMapStart(const Mark& mark, const std::string& tag,
+ anchor_t anchor, EmitterStyle::value style);
+ virtual void OnMapEnd();
+
+ void* RootNode() const { return m_pRootNode; }
+
+ private:
+ struct ContainerFrame {
+ ContainerFrame(void* pSequence)
+ : pContainer(pSequence), pPrevKeyNode(&sequenceMarker) {}
+ ContainerFrame(void* pMap, void* pPreviousKeyNode)
+ : pContainer(pMap), pPrevKeyNode(pPreviousKeyNode) {}
+
+ void* pContainer;
+ void* pPrevKeyNode;
+
+ bool isMap() const { return pPrevKeyNode != &sequenceMarker; }
+
+ private:
+ static int sequenceMarker;
+ };
+ typedef std::stack<ContainerFrame> ContainerStack;
+ typedef AnchorDict<void*> AnchorMap;
+
+ GraphBuilderInterface& m_builder;
+ ContainerStack m_containers;
+ AnchorMap m_anchors;
+ void* m_pRootNode;
+ void* m_pKeyNode;
+
+ void* GetCurrentParent() const;
+ void RegisterAnchor(anchor_t anchor, void* pNode);
+ void DispositionNode(void* pNode);
+};
+} // namespace YAML
+
+#endif // GRAPHBUILDERADAPTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?> \r
+<!-- MSVC Debugger visualization hints for YAML::Node and YAML::detail::node -->\r
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">\r
+ <Type Name="YAML::Node">\r
+ <DisplayString Condition="!m_isValid">{{invalid}}</DisplayString>\r
+ <DisplayString Condition="!m_pNode">{{pNode==nullptr}}</DisplayString>\r
+ <DisplayString>{{ {*m_pNode} }}</DisplayString>\r
+ <Expand>\r
+ <Item Condition="m_pNode->m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Scalar" Name="scalar">m_pNode->m_pRef._Ptr->m_pData._Ptr->m_scalar</Item>\r
+ <Item Condition="m_pNode->m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Sequence" Name="sequence">m_pNode->m_pRef._Ptr->m_pData._Ptr->m_sequence</Item>\r
+ <Item Condition="m_pNode->m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Map" Name="map">m_pNode->m_pRef._Ptr->m_pData._Ptr->m_map</Item>\r
+ <Item Name="[details]" >m_pNode->m_pRef._Ptr->m_pData._Ptr</Item>\r
+ </Expand>\r
+ </Type>\r
+\r
+ <Type Name="YAML::detail::node">\r
+ <DisplayString Condition="!m_pRef._Ptr">{{node:pRef==nullptr}}</DisplayString>\r
+ <DisplayString Condition="!m_pRef._Ptr->m_pData._Ptr">{{node:pRef->pData==nullptr}}</DisplayString>\r
+ <DisplayString Condition="!m_pRef._Ptr->m_pData._Ptr->m_isDefined">{{undefined}}</DisplayString>\r
+ <DisplayString Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Scalar">{{{m_pRef._Ptr->m_pData._Ptr->m_scalar}}}</DisplayString>\r
+ <DisplayString Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Map">{{ Map {m_pRef._Ptr->m_pData._Ptr->m_map}}}</DisplayString>\r
+ <DisplayString Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Sequence">{{ Seq {m_pRef._Ptr->m_pData._Ptr->m_sequence}}}</DisplayString>\r
+ <DisplayString>{{{m_pRef._Ptr->m_pData._Ptr->m_type}}}</DisplayString>\r
+ <Expand>\r
+ <Item Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Scalar" Name="scalar">m_pRef._Ptr->m_pData._Ptr->m_scalar</Item>\r
+ <Item Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Sequence" Name="sequence">m_pRef._Ptr->m_pData._Ptr->m_sequence</Item>\r
+ <Item Condition="m_pRef._Ptr->m_pData._Ptr->m_type==YAML::NodeType::Map" Name="map">m_pRef._Ptr->m_pData._Ptr->m_map</Item>\r
+ <Item Name="[details]" >m_pRef._Ptr->m_pData._Ptr</Item>\r
+ </Expand>\r
+ </Type>\r
+\r
+</AutoVisualizer>\r
--- /dev/null
+# MSVC debugger visualizer for YAML::Node\r
+\r
+## How to use\r
+Add yaml-cpp.natvis to your Visual C++ project like any other source file. It will be included in the debug information, and improve debugger display on YAML::Node and contained types. \r
+\r
+## Compatibility and Troubleshooting\r
+\r
+This has been tested for MSVC 2017. It is expected to be compatible with VS 2015 and VS 2019. If you have any problems, you can open an issue here: https://github.com/peterchen-cp/yaml-cpp-natvis\r
+\r
--- /dev/null
+#include <algorithm>
+
+#include "yaml-cpp/node/convert.h"
+
+namespace {
+// we're not gonna mess with the mess that is all the isupper/etc. functions
+bool IsLower(char ch) { return 'a' <= ch && ch <= 'z'; }
+bool IsUpper(char ch) { return 'A' <= ch && ch <= 'Z'; }
+char ToLower(char ch) { return IsUpper(ch) ? ch + 'a' - 'A' : ch; }
+
+std::string tolower(const std::string& str) {
+ std::string s(str);
+ std::transform(s.begin(), s.end(), s.begin(), ToLower);
+ return s;
+}
+
+template <typename T>
+bool IsEntirely(const std::string& str, T func) {
+ return std::all_of(str.begin(), str.end(), [=](char ch) { return func(ch); });
+}
+
+// IsFlexibleCase
+// . Returns true if 'str' is:
+// . UPPERCASE
+// . lowercase
+// . Capitalized
+bool IsFlexibleCase(const std::string& str) {
+ if (str.empty())
+ return true;
+
+ if (IsEntirely(str, IsLower))
+ return true;
+
+ bool firstcaps = IsUpper(str[0]);
+ std::string rest = str.substr(1);
+ return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper));
+}
+} // namespace
+
+namespace YAML {
+bool convert<bool>::decode(const Node& node, bool& rhs) {
+ if (!node.IsScalar())
+ return false;
+
+ // we can't use iostream bool extraction operators as they don't
+ // recognize all possible values in the table below (taken from
+ // http://yaml.org/type/bool.html)
+ static const struct {
+ std::string truename, falsename;
+ } names[] = {
+ {"y", "n"},
+ {"yes", "no"},
+ {"true", "false"},
+ {"on", "off"},
+ };
+
+ if (!IsFlexibleCase(node.Scalar()))
+ return false;
+
+ for (const auto& name : names) {
+ if (name.truename == tolower(node.Scalar())) {
+ rhs = true;
+ return true;
+ }
+
+ if (name.falsename == tolower(node.Scalar())) {
+ rhs = false;
+ return true;
+ }
+ }
+
+ return false;
+}
+} // namespace YAML
--- /dev/null
+#include "yaml-cpp/depthguard.h"
+
+namespace YAML {
+
+DeepRecursion::DeepRecursion(int depth, const Mark& mark_,
+ const std::string& msg_)
+ : ParserException(mark_, msg_), m_depth(depth) {}
+
+} // namespace YAML
--- /dev/null
+#include "directives.h"
+
+namespace YAML {
+Directives::Directives() : version{true, 1, 2}, tags{} {}
+
+std::string Directives::TranslateTagHandle(
+ const std::string& handle) const {
+ auto it = tags.find(handle);
+ if (it == tags.end()) {
+ if (handle == "!!")
+ return "tag:yaml.org,2002:";
+ return handle;
+ }
+
+ return it->second;
+}
+} // namespace YAML
--- /dev/null
+#ifndef DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <map>
+
+namespace YAML {
+struct Version {
+ bool isDefault;
+ int major, minor;
+};
+
+struct Directives {
+ Directives();
+
+ std::string TranslateTagHandle(const std::string& handle) const;
+
+ Version version;
+ std::map<std::string, std::string> tags;
+};
+}
+
+#endif // DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include "yaml-cpp/node/emit.h"
+#include "nodeevents.h"
+#include "yaml-cpp/emitfromevents.h"
+#include "yaml-cpp/emitter.h"
+
+namespace YAML {
+Emitter& operator<<(Emitter& out, const Node& node) {
+ EmitFromEvents emitFromEvents(out);
+ NodeEvents events(node);
+ events.Emit(emitFromEvents);
+ return out;
+}
+
+std::ostream& operator<<(std::ostream& out, const Node& node) {
+ Emitter emitter(out);
+ emitter << node;
+ return out;
+}
+
+std::string Dump(const Node& node) {
+ Emitter emitter;
+ emitter << node;
+ return emitter.c_str();
+}
+} // namespace YAML
--- /dev/null
+#include <cassert>
+#include <sstream>
+
+#include "yaml-cpp/emitfromevents.h"
+#include "yaml-cpp/emitter.h"
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/null.h"
+
+namespace YAML {
+struct Mark;
+} // namespace YAML
+
+namespace {
+std::string ToString(YAML::anchor_t anchor) {
+ std::stringstream stream;
+ stream << anchor;
+ return stream.str();
+}
+} // namespace
+
+namespace YAML {
+EmitFromEvents::EmitFromEvents(Emitter& emitter)
+ : m_emitter(emitter), m_stateStack{} {}
+
+void EmitFromEvents::OnDocumentStart(const Mark&) {}
+
+void EmitFromEvents::OnDocumentEnd() {}
+
+void EmitFromEvents::OnNull(const Mark&, anchor_t anchor) {
+ BeginNode();
+ EmitProps("", anchor);
+ m_emitter << Null;
+}
+
+void EmitFromEvents::OnAlias(const Mark&, anchor_t anchor) {
+ BeginNode();
+ m_emitter << Alias(ToString(anchor));
+}
+
+void EmitFromEvents::OnScalar(const Mark&, const std::string& tag,
+ anchor_t anchor, const std::string& value) {
+ BeginNode();
+ EmitProps(tag, anchor);
+ m_emitter << value;
+}
+
+void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag,
+ anchor_t anchor,
+ EmitterStyle::value style) {
+ BeginNode();
+ EmitProps(tag, anchor);
+ switch (style) {
+ case EmitterStyle::Block:
+ m_emitter << Block;
+ break;
+ case EmitterStyle::Flow:
+ m_emitter << Flow;
+ break;
+ default:
+ break;
+ }
+ // Restore the global settings to eliminate the override from node style
+ m_emitter.RestoreGlobalModifiedSettings();
+ m_emitter << BeginSeq;
+ m_stateStack.push(State::WaitingForSequenceEntry);
+}
+
+void EmitFromEvents::OnSequenceEnd() {
+ m_emitter << EndSeq;
+ assert(m_stateStack.top() == State::WaitingForSequenceEntry);
+ m_stateStack.pop();
+}
+
+void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag,
+ anchor_t anchor, EmitterStyle::value style) {
+ BeginNode();
+ EmitProps(tag, anchor);
+ switch (style) {
+ case EmitterStyle::Block:
+ m_emitter << Block;
+ break;
+ case EmitterStyle::Flow:
+ m_emitter << Flow;
+ break;
+ default:
+ break;
+ }
+ // Restore the global settings to eliminate the override from node style
+ m_emitter.RestoreGlobalModifiedSettings();
+ m_emitter << BeginMap;
+ m_stateStack.push(State::WaitingForKey);
+}
+
+void EmitFromEvents::OnMapEnd() {
+ m_emitter << EndMap;
+ assert(m_stateStack.top() == State::WaitingForKey);
+ m_stateStack.pop();
+}
+
+void EmitFromEvents::BeginNode() {
+ if (m_stateStack.empty())
+ return;
+
+ switch (m_stateStack.top()) {
+ case State::WaitingForKey:
+ m_emitter << Key;
+ m_stateStack.top() = State::WaitingForValue;
+ break;
+ case State::WaitingForValue:
+ m_emitter << Value;
+ m_stateStack.top() = State::WaitingForKey;
+ break;
+ default:
+ break;
+ }
+}
+
+void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) {
+ if (!tag.empty() && tag != "?" && tag != "!")
+ m_emitter << VerbatimTag(tag);
+ if (anchor)
+ m_emitter << Anchor(ToString(anchor));
+}
+} // namespace YAML
--- /dev/null
+#include <sstream>
+
+#include "emitterutils.h"
+#include "indentation.h" // IWYU pragma: keep
+#include "yaml-cpp/emitter.h"
+#include "yaml-cpp/emitterdef.h"
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/exceptions.h" // IWYU pragma: keep
+
+namespace YAML {
+class Binary;
+struct _Null;
+
+Emitter::Emitter() : m_pState(new EmitterState), m_stream{} {}
+
+Emitter::Emitter(std::ostream& stream)
+ : m_pState(new EmitterState), m_stream(stream) {}
+
+Emitter::~Emitter() = default;
+
+const char* Emitter::c_str() const { return m_stream.str(); }
+
+std::size_t Emitter::size() const { return m_stream.pos(); }
+
+// state checking
+bool Emitter::good() const { return m_pState->good(); }
+
+const std::string Emitter::GetLastError() const {
+ return m_pState->GetLastError();
+}
+
+// global setters
+bool Emitter::SetOutputCharset(EMITTER_MANIP value) {
+ return m_pState->SetOutputCharset(value, FmtScope::Global);
+}
+
+bool Emitter::SetStringFormat(EMITTER_MANIP value) {
+ return m_pState->SetStringFormat(value, FmtScope::Global);
+}
+
+bool Emitter::SetBoolFormat(EMITTER_MANIP value) {
+ bool ok = false;
+ if (m_pState->SetBoolFormat(value, FmtScope::Global))
+ ok = true;
+ if (m_pState->SetBoolCaseFormat(value, FmtScope::Global))
+ ok = true;
+ if (m_pState->SetBoolLengthFormat(value, FmtScope::Global))
+ ok = true;
+ return ok;
+}
+
+bool Emitter::SetNullFormat(EMITTER_MANIP value) {
+ return m_pState->SetNullFormat(value, FmtScope::Global);
+}
+
+bool Emitter::SetIntBase(EMITTER_MANIP value) {
+ return m_pState->SetIntFormat(value, FmtScope::Global);
+}
+
+bool Emitter::SetSeqFormat(EMITTER_MANIP value) {
+ return m_pState->SetFlowType(GroupType::Seq, value, FmtScope::Global);
+}
+
+bool Emitter::SetMapFormat(EMITTER_MANIP value) {
+ bool ok = false;
+ if (m_pState->SetFlowType(GroupType::Map, value, FmtScope::Global))
+ ok = true;
+ if (m_pState->SetMapKeyFormat(value, FmtScope::Global))
+ ok = true;
+ return ok;
+}
+
+bool Emitter::SetIndent(std::size_t n) {
+ return m_pState->SetIndent(n, FmtScope::Global);
+}
+
+bool Emitter::SetPreCommentIndent(std::size_t n) {
+ return m_pState->SetPreCommentIndent(n, FmtScope::Global);
+}
+
+bool Emitter::SetPostCommentIndent(std::size_t n) {
+ return m_pState->SetPostCommentIndent(n, FmtScope::Global);
+}
+
+bool Emitter::SetFloatPrecision(std::size_t n) {
+ return m_pState->SetFloatPrecision(n, FmtScope::Global);
+}
+
+bool Emitter::SetDoublePrecision(std::size_t n) {
+ return m_pState->SetDoublePrecision(n, FmtScope::Global);
+}
+
+void Emitter::RestoreGlobalModifiedSettings() {
+ m_pState->RestoreGlobalModifiedSettings();
+}
+
+// SetLocalValue
+// . Either start/end a group, or set a modifier locally
+Emitter& Emitter::SetLocalValue(EMITTER_MANIP value) {
+ if (!good())
+ return *this;
+
+ switch (value) {
+ case BeginDoc:
+ EmitBeginDoc();
+ break;
+ case EndDoc:
+ EmitEndDoc();
+ break;
+ case BeginSeq:
+ EmitBeginSeq();
+ break;
+ case EndSeq:
+ EmitEndSeq();
+ break;
+ case BeginMap:
+ EmitBeginMap();
+ break;
+ case EndMap:
+ EmitEndMap();
+ break;
+ case Key:
+ case Value:
+ // deprecated (these can be deduced by the parity of nodes in a map)
+ break;
+ case TagByKind:
+ EmitKindTag();
+ break;
+ case Newline:
+ EmitNewline();
+ break;
+ default:
+ m_pState->SetLocalValue(value);
+ break;
+ }
+ return *this;
+}
+
+Emitter& Emitter::SetLocalIndent(const _Indent& indent) {
+ m_pState->SetIndent(indent.value, FmtScope::Local);
+ return *this;
+}
+
+Emitter& Emitter::SetLocalPrecision(const _Precision& precision) {
+ if (precision.floatPrecision >= 0)
+ m_pState->SetFloatPrecision(precision.floatPrecision, FmtScope::Local);
+ if (precision.doublePrecision >= 0)
+ m_pState->SetDoublePrecision(precision.doublePrecision, FmtScope::Local);
+ return *this;
+}
+
+// EmitBeginDoc
+void Emitter::EmitBeginDoc() {
+ if (!good())
+ return;
+
+ if (m_pState->CurGroupType() != GroupType::NoType) {
+ m_pState->SetError("Unexpected begin document");
+ return;
+ }
+
+ if (m_pState->HasAnchor() || m_pState->HasTag()) {
+ m_pState->SetError("Unexpected begin document");
+ return;
+ }
+
+ if (m_stream.col() > 0)
+ m_stream << "\n";
+ m_stream << "---\n";
+
+ m_pState->StartedDoc();
+}
+
+// EmitEndDoc
+void Emitter::EmitEndDoc() {
+ if (!good())
+ return;
+
+ if (m_pState->CurGroupType() != GroupType::NoType) {
+ m_pState->SetError("Unexpected begin document");
+ return;
+ }
+
+ if (m_pState->HasAnchor() || m_pState->HasTag()) {
+ m_pState->SetError("Unexpected begin document");
+ return;
+ }
+
+ if (m_stream.col() > 0)
+ m_stream << "\n";
+ m_stream << "...\n";
+}
+
+// EmitBeginSeq
+void Emitter::EmitBeginSeq() {
+ if (!good())
+ return;
+
+ PrepareNode(m_pState->NextGroupType(GroupType::Seq));
+
+ m_pState->StartedGroup(GroupType::Seq);
+}
+
+// EmitEndSeq
+void Emitter::EmitEndSeq() {
+ if (!good())
+ return;
+ FlowType::value originalType = m_pState->CurGroupFlowType();
+
+ if (m_pState->CurGroupChildCount() == 0)
+ m_pState->ForceFlow();
+
+ if (m_pState->CurGroupFlowType() == FlowType::Flow) {
+ if (m_stream.comment())
+ m_stream << "\n";
+ m_stream << IndentTo(m_pState->CurIndent());
+ if (originalType == FlowType::Block) {
+ m_stream << "[";
+ } else {
+ if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode())
+ m_stream << "[";
+ }
+ m_stream << "]";
+ }
+
+ m_pState->EndedGroup(GroupType::Seq);
+}
+
+// EmitBeginMap
+void Emitter::EmitBeginMap() {
+ if (!good())
+ return;
+
+ PrepareNode(m_pState->NextGroupType(GroupType::Map));
+
+ m_pState->StartedGroup(GroupType::Map);
+}
+
+// EmitEndMap
+void Emitter::EmitEndMap() {
+ if (!good())
+ return;
+ FlowType::value originalType = m_pState->CurGroupFlowType();
+
+ if (m_pState->CurGroupChildCount() == 0)
+ m_pState->ForceFlow();
+
+ if (m_pState->CurGroupFlowType() == FlowType::Flow) {
+ if (m_stream.comment())
+ m_stream << "\n";
+ m_stream << IndentTo(m_pState->CurIndent());
+ if (originalType == FlowType::Block) {
+ m_stream << "{";
+ } else {
+ if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode())
+ m_stream << "{";
+ }
+ m_stream << "}";
+ }
+
+ m_pState->EndedGroup(GroupType::Map);
+}
+
+// EmitNewline
+void Emitter::EmitNewline() {
+ if (!good())
+ return;
+
+ PrepareNode(EmitterNodeType::NoType);
+ m_stream << "\n";
+ m_pState->SetNonContent();
+}
+
+bool Emitter::CanEmitNewline() const { return true; }
+
+// Put the stream in a state so we can simply write the next node
+// E.g., if we're in a sequence, write the "- "
+void Emitter::PrepareNode(EmitterNodeType::value child) {
+ switch (m_pState->CurGroupNodeType()) {
+ case EmitterNodeType::NoType:
+ PrepareTopNode(child);
+ break;
+ case EmitterNodeType::FlowSeq:
+ FlowSeqPrepareNode(child);
+ break;
+ case EmitterNodeType::BlockSeq:
+ BlockSeqPrepareNode(child);
+ break;
+ case EmitterNodeType::FlowMap:
+ FlowMapPrepareNode(child);
+ break;
+ case EmitterNodeType::BlockMap:
+ BlockMapPrepareNode(child);
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ assert(false);
+ break;
+ }
+}
+
+void Emitter::PrepareTopNode(EmitterNodeType::value child) {
+ if (child == EmitterNodeType::NoType)
+ return;
+
+ if (m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0)
+ EmitBeginDoc();
+
+ switch (child) {
+ case EmitterNodeType::NoType:
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ case EmitterNodeType::FlowSeq:
+ case EmitterNodeType::FlowMap:
+ // TODO: if we were writing null, and
+ // we wanted it blank, we wouldn't want a space
+ SpaceOrIndentTo(m_pState->HasBegunContent(), 0);
+ break;
+ case EmitterNodeType::BlockSeq:
+ case EmitterNodeType::BlockMap:
+ if (m_pState->HasBegunNode())
+ m_stream << "\n";
+ break;
+ }
+}
+
+void Emitter::FlowSeqPrepareNode(EmitterNodeType::value child) {
+ const std::size_t lastIndent = m_pState->LastIndent();
+
+ if (!m_pState->HasBegunNode()) {
+ if (m_stream.comment())
+ m_stream << "\n";
+ m_stream << IndentTo(lastIndent);
+ if (m_pState->CurGroupChildCount() == 0)
+ m_stream << "[";
+ else
+ m_stream << ",";
+ }
+
+ switch (child) {
+ case EmitterNodeType::NoType:
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ case EmitterNodeType::FlowSeq:
+ case EmitterNodeType::FlowMap:
+ SpaceOrIndentTo(
+ m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+ lastIndent);
+ break;
+ case EmitterNodeType::BlockSeq:
+ case EmitterNodeType::BlockMap:
+ assert(false);
+ break;
+ }
+}
+
+void Emitter::BlockSeqPrepareNode(EmitterNodeType::value child) {
+ const std::size_t curIndent = m_pState->CurIndent();
+ const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent();
+
+ if (child == EmitterNodeType::NoType)
+ return;
+
+ if (!m_pState->HasBegunContent()) {
+ if (m_pState->CurGroupChildCount() > 0 || m_stream.comment()) {
+ m_stream << "\n";
+ }
+ m_stream << IndentTo(curIndent);
+ m_stream << "-";
+ }
+
+ switch (child) {
+ case EmitterNodeType::NoType:
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ case EmitterNodeType::FlowSeq:
+ case EmitterNodeType::FlowMap:
+ SpaceOrIndentTo(m_pState->HasBegunContent(), nextIndent);
+ break;
+ case EmitterNodeType::BlockSeq:
+ m_stream << "\n";
+ break;
+ case EmitterNodeType::BlockMap:
+ if (m_pState->HasBegunContent() || m_stream.comment())
+ m_stream << "\n";
+ break;
+ }
+}
+
+void Emitter::FlowMapPrepareNode(EmitterNodeType::value child) {
+ if (m_pState->CurGroupChildCount() % 2 == 0) {
+ if (m_pState->GetMapKeyFormat() == LongKey)
+ m_pState->SetLongKey();
+
+ if (m_pState->CurGroupLongKey())
+ FlowMapPrepareLongKey(child);
+ else
+ FlowMapPrepareSimpleKey(child);
+ } else {
+ if (m_pState->CurGroupLongKey())
+ FlowMapPrepareLongKeyValue(child);
+ else
+ FlowMapPrepareSimpleKeyValue(child);
+ }
+}
+
+void Emitter::FlowMapPrepareLongKey(EmitterNodeType::value child) {
+ const std::size_t lastIndent = m_pState->LastIndent();
+
+ if (!m_pState->HasBegunNode()) {
+ if (m_stream.comment())
+ m_stream << "\n";
+ m_stream << IndentTo(lastIndent);
+ if (m_pState->CurGroupChildCount() == 0)
+ m_stream << "{ ?";
+ else
+ m_stream << ", ?";
+ }
+
+ switch (child) {
+ case EmitterNodeType::NoType:
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ case EmitterNodeType::FlowSeq:
+ case EmitterNodeType::FlowMap:
+ SpaceOrIndentTo(
+ m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+ lastIndent);
+ break;
+ case EmitterNodeType::BlockSeq:
+ case EmitterNodeType::BlockMap:
+ assert(false);
+ break;
+ }
+}
+
+void Emitter::FlowMapPrepareLongKeyValue(EmitterNodeType::value child) {
+ const std::size_t lastIndent = m_pState->LastIndent();
+
+ if (!m_pState->HasBegunNode()) {
+ if (m_stream.comment())
+ m_stream << "\n";
+ m_stream << IndentTo(lastIndent);
+ m_stream << ":";
+ }
+
+ switch (child) {
+ case EmitterNodeType::NoType:
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ case EmitterNodeType::FlowSeq:
+ case EmitterNodeType::FlowMap:
+ SpaceOrIndentTo(
+ m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+ lastIndent);
+ break;
+ case EmitterNodeType::BlockSeq:
+ case EmitterNodeType::BlockMap:
+ assert(false);
+ break;
+ }
+}
+
+void Emitter::FlowMapPrepareSimpleKey(EmitterNodeType::value child) {
+ const std::size_t lastIndent = m_pState->LastIndent();
+
+ if (!m_pState->HasBegunNode()) {
+ if (m_stream.comment())
+ m_stream << "\n";
+ m_stream << IndentTo(lastIndent);
+ if (m_pState->CurGroupChildCount() == 0)
+ m_stream << "{";
+ else
+ m_stream << ",";
+ }
+
+ switch (child) {
+ case EmitterNodeType::NoType:
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ case EmitterNodeType::FlowSeq:
+ case EmitterNodeType::FlowMap:
+ SpaceOrIndentTo(
+ m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+ lastIndent);
+ break;
+ case EmitterNodeType::BlockSeq:
+ case EmitterNodeType::BlockMap:
+ assert(false);
+ break;
+ }
+}
+
+void Emitter::FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child) {
+ const std::size_t lastIndent = m_pState->LastIndent();
+
+ if (!m_pState->HasBegunNode()) {
+ if (m_stream.comment())
+ m_stream << "\n";
+ m_stream << IndentTo(lastIndent);
+ if (m_pState->HasAlias()) {
+ m_stream << " ";
+ }
+ m_stream << ":";
+ }
+
+ switch (child) {
+ case EmitterNodeType::NoType:
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ case EmitterNodeType::FlowSeq:
+ case EmitterNodeType::FlowMap:
+ SpaceOrIndentTo(
+ m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0,
+ lastIndent);
+ break;
+ case EmitterNodeType::BlockSeq:
+ case EmitterNodeType::BlockMap:
+ assert(false);
+ break;
+ }
+}
+
+void Emitter::BlockMapPrepareNode(EmitterNodeType::value child) {
+ if (m_pState->CurGroupChildCount() % 2 == 0) {
+ if (m_pState->GetMapKeyFormat() == LongKey)
+ m_pState->SetLongKey();
+ if (child == EmitterNodeType::BlockSeq ||
+ child == EmitterNodeType::BlockMap ||
+ child == EmitterNodeType::Property)
+ m_pState->SetLongKey();
+
+ if (m_pState->CurGroupLongKey())
+ BlockMapPrepareLongKey(child);
+ else
+ BlockMapPrepareSimpleKey(child);
+ } else {
+ if (m_pState->CurGroupLongKey())
+ BlockMapPrepareLongKeyValue(child);
+ else
+ BlockMapPrepareSimpleKeyValue(child);
+ }
+}
+
+void Emitter::BlockMapPrepareLongKey(EmitterNodeType::value child) {
+ const std::size_t curIndent = m_pState->CurIndent();
+ const std::size_t childCount = m_pState->CurGroupChildCount();
+
+ if (child == EmitterNodeType::NoType)
+ return;
+
+ if (!m_pState->HasBegunContent()) {
+ if (childCount > 0) {
+ m_stream << "\n";
+ }
+ if (m_stream.comment()) {
+ m_stream << "\n";
+ }
+ m_stream << IndentTo(curIndent);
+ m_stream << "?";
+ }
+
+ switch (child) {
+ case EmitterNodeType::NoType:
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ case EmitterNodeType::FlowSeq:
+ case EmitterNodeType::FlowMap:
+ SpaceOrIndentTo(true, curIndent + 1);
+ break;
+ case EmitterNodeType::BlockSeq:
+ case EmitterNodeType::BlockMap:
+ if (m_pState->HasBegunContent())
+ m_stream << "\n";
+ break;
+ }
+}
+
+void Emitter::BlockMapPrepareLongKeyValue(EmitterNodeType::value child) {
+ const std::size_t curIndent = m_pState->CurIndent();
+
+ if (child == EmitterNodeType::NoType)
+ return;
+
+ if (!m_pState->HasBegunContent()) {
+ m_stream << "\n";
+ m_stream << IndentTo(curIndent);
+ m_stream << ":";
+ }
+
+ switch (child) {
+ case EmitterNodeType::NoType:
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ case EmitterNodeType::FlowSeq:
+ case EmitterNodeType::FlowMap:
+ SpaceOrIndentTo(true, curIndent + 1);
+ break;
+ case EmitterNodeType::BlockSeq:
+ case EmitterNodeType::BlockMap:
+ if (m_pState->HasBegunContent())
+ m_stream << "\n";
+ SpaceOrIndentTo(true, curIndent + 1);
+ break;
+ }
+}
+
+void Emitter::BlockMapPrepareSimpleKey(EmitterNodeType::value child) {
+ const std::size_t curIndent = m_pState->CurIndent();
+ const std::size_t childCount = m_pState->CurGroupChildCount();
+
+ if (child == EmitterNodeType::NoType)
+ return;
+
+ if (!m_pState->HasBegunNode()) {
+ if (childCount > 0) {
+ m_stream << "\n";
+ }
+ }
+
+ switch (child) {
+ case EmitterNodeType::NoType:
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ case EmitterNodeType::FlowSeq:
+ case EmitterNodeType::FlowMap:
+ SpaceOrIndentTo(m_pState->HasBegunContent(), curIndent);
+ break;
+ case EmitterNodeType::BlockSeq:
+ case EmitterNodeType::BlockMap:
+ break;
+ }
+}
+
+void Emitter::BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child) {
+ const std::size_t curIndent = m_pState->CurIndent();
+ const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent();
+
+ if (!m_pState->HasBegunNode()) {
+ if (m_pState->HasAlias()) {
+ m_stream << " ";
+ }
+ m_stream << ":";
+ }
+
+ switch (child) {
+ case EmitterNodeType::NoType:
+ break;
+ case EmitterNodeType::Property:
+ case EmitterNodeType::Scalar:
+ case EmitterNodeType::FlowSeq:
+ case EmitterNodeType::FlowMap:
+ SpaceOrIndentTo(true, nextIndent);
+ break;
+ case EmitterNodeType::BlockSeq:
+ case EmitterNodeType::BlockMap:
+ m_stream << "\n";
+ break;
+ }
+}
+
+// SpaceOrIndentTo
+// . Prepares for some more content by proper spacing
+void Emitter::SpaceOrIndentTo(bool requireSpace, std::size_t indent) {
+ if (m_stream.comment())
+ m_stream << "\n";
+ if (m_stream.col() > 0 && requireSpace)
+ m_stream << " ";
+ m_stream << IndentTo(indent);
+}
+
+void Emitter::PrepareIntegralStream(std::stringstream& stream) const {
+
+ switch (m_pState->GetIntFormat()) {
+ case Dec:
+ stream << std::dec;
+ break;
+ case Hex:
+ stream << "0x";
+ stream << std::hex;
+ break;
+ case Oct:
+ stream << "0";
+ stream << std::oct;
+ break;
+ default:
+ assert(false);
+ }
+}
+
+void Emitter::StartedScalar() { m_pState->StartedScalar(); }
+
+// *******************************************************************************************
+// overloads of Write
+
+StringEscaping::value GetStringEscapingStyle(const EMITTER_MANIP emitterManip) {
+ switch (emitterManip) {
+ case EscapeNonAscii:
+ return StringEscaping::NonAscii;
+ case EscapeAsJson:
+ return StringEscaping::JSON;
+ default:
+ return StringEscaping::None;
+ break;
+ }
+}
+
+Emitter& Emitter::Write(const std::string& str) {
+ if (!good())
+ return *this;
+
+ StringEscaping::value stringEscaping = GetStringEscapingStyle(m_pState->GetOutputCharset());
+
+ const StringFormat::value strFormat =
+ Utils::ComputeStringFormat(str, m_pState->GetStringFormat(),
+ m_pState->CurGroupFlowType(), stringEscaping == StringEscaping::NonAscii);
+
+ if (strFormat == StringFormat::Literal || str.size() > 1024)
+ m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local);
+
+ PrepareNode(EmitterNodeType::Scalar);
+
+ switch (strFormat) {
+ case StringFormat::Plain:
+ m_stream << str;
+ break;
+ case StringFormat::SingleQuoted:
+ Utils::WriteSingleQuotedString(m_stream, str);
+ break;
+ case StringFormat::DoubleQuoted:
+ Utils::WriteDoubleQuotedString(m_stream, str, stringEscaping);
+ break;
+ case StringFormat::Literal:
+ Utils::WriteLiteralString(m_stream, str,
+ m_pState->CurIndent() + m_pState->GetIndent());
+ break;
+ }
+
+ StartedScalar();
+
+ return *this;
+}
+
+std::size_t Emitter::GetFloatPrecision() const {
+ return m_pState->GetFloatPrecision();
+}
+
+std::size_t Emitter::GetDoublePrecision() const {
+ return m_pState->GetDoublePrecision();
+}
+
+const char* Emitter::ComputeFullBoolName(bool b) const {
+ const EMITTER_MANIP mainFmt = (m_pState->GetBoolLengthFormat() == ShortBool
+ ? YesNoBool
+ : m_pState->GetBoolFormat());
+ const EMITTER_MANIP caseFmt = m_pState->GetBoolCaseFormat();
+ switch (mainFmt) {
+ case YesNoBool:
+ switch (caseFmt) {
+ case UpperCase:
+ return b ? "YES" : "NO";
+ case CamelCase:
+ return b ? "Yes" : "No";
+ case LowerCase:
+ return b ? "yes" : "no";
+ default:
+ break;
+ }
+ break;
+ case OnOffBool:
+ switch (caseFmt) {
+ case UpperCase:
+ return b ? "ON" : "OFF";
+ case CamelCase:
+ return b ? "On" : "Off";
+ case LowerCase:
+ return b ? "on" : "off";
+ default:
+ break;
+ }
+ break;
+ case TrueFalseBool:
+ switch (caseFmt) {
+ case UpperCase:
+ return b ? "TRUE" : "FALSE";
+ case CamelCase:
+ return b ? "True" : "False";
+ case LowerCase:
+ return b ? "true" : "false";
+ default:
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+ return b ? "y" : "n"; // should never get here, but it can't hurt to give
+ // these answers
+}
+
+const char* Emitter::ComputeNullName() const {
+ switch (m_pState->GetNullFormat()) {
+ case LowerNull:
+ return "null";
+ case UpperNull:
+ return "NULL";
+ case CamelNull:
+ return "Null";
+ case TildeNull:
+ // fallthrough
+ default:
+ return "~";
+ }
+}
+
+Emitter& Emitter::Write(bool b) {
+ if (!good())
+ return *this;
+
+ PrepareNode(EmitterNodeType::Scalar);
+
+ const char* name = ComputeFullBoolName(b);
+ if (m_pState->GetBoolLengthFormat() == ShortBool)
+ m_stream << name[0];
+ else
+ m_stream << name;
+
+ StartedScalar();
+
+ return *this;
+}
+
+Emitter& Emitter::Write(char ch) {
+ if (!good())
+ return *this;
+
+
+
+ PrepareNode(EmitterNodeType::Scalar);
+ Utils::WriteChar(m_stream, ch, GetStringEscapingStyle(m_pState->GetOutputCharset()));
+ StartedScalar();
+
+ return *this;
+}
+
+Emitter& Emitter::Write(const _Alias& alias) {
+ if (!good())
+ return *this;
+
+ if (m_pState->HasAnchor() || m_pState->HasTag()) {
+ m_pState->SetError(ErrorMsg::INVALID_ALIAS);
+ return *this;
+ }
+
+ PrepareNode(EmitterNodeType::Scalar);
+
+ if (!Utils::WriteAlias(m_stream, alias.content)) {
+ m_pState->SetError(ErrorMsg::INVALID_ALIAS);
+ return *this;
+ }
+
+ StartedScalar();
+
+ m_pState->SetAlias();
+
+ return *this;
+}
+
+Emitter& Emitter::Write(const _Anchor& anchor) {
+ if (!good())
+ return *this;
+
+ if (m_pState->HasAnchor()) {
+ m_pState->SetError(ErrorMsg::INVALID_ANCHOR);
+ return *this;
+ }
+
+ PrepareNode(EmitterNodeType::Property);
+
+ if (!Utils::WriteAnchor(m_stream, anchor.content)) {
+ m_pState->SetError(ErrorMsg::INVALID_ANCHOR);
+ return *this;
+ }
+
+ m_pState->SetAnchor();
+
+ return *this;
+}
+
+Emitter& Emitter::Write(const _Tag& tag) {
+ if (!good())
+ return *this;
+
+ if (m_pState->HasTag()) {
+ m_pState->SetError(ErrorMsg::INVALID_TAG);
+ return *this;
+ }
+
+ PrepareNode(EmitterNodeType::Property);
+
+ bool success = false;
+ if (tag.type == _Tag::Type::Verbatim)
+ success = Utils::WriteTag(m_stream, tag.content, true);
+ else if (tag.type == _Tag::Type::PrimaryHandle)
+ success = Utils::WriteTag(m_stream, tag.content, false);
+ else
+ success = Utils::WriteTagWithPrefix(m_stream, tag.prefix, tag.content);
+
+ if (!success) {
+ m_pState->SetError(ErrorMsg::INVALID_TAG);
+ return *this;
+ }
+
+ m_pState->SetTag();
+
+ return *this;
+}
+
+void Emitter::EmitKindTag() { Write(LocalTag("")); }
+
+Emitter& Emitter::Write(const _Comment& comment) {
+ if (!good())
+ return *this;
+
+ PrepareNode(EmitterNodeType::NoType);
+
+ if (m_stream.col() > 0)
+ m_stream << Indentation(m_pState->GetPreCommentIndent());
+ Utils::WriteComment(m_stream, comment.content,
+ m_pState->GetPostCommentIndent());
+
+ m_pState->SetNonContent();
+
+ return *this;
+}
+
+Emitter& Emitter::Write(const _Null& /*null*/) {
+ if (!good())
+ return *this;
+
+ PrepareNode(EmitterNodeType::Scalar);
+
+ m_stream << ComputeNullName();
+
+ StartedScalar();
+
+ return *this;
+}
+
+Emitter& Emitter::Write(const Binary& binary) {
+ Write(SecondaryTag("binary"));
+
+ if (!good())
+ return *this;
+
+ PrepareNode(EmitterNodeType::Scalar);
+ Utils::WriteBinary(m_stream, binary);
+ StartedScalar();
+
+ return *this;
+}
+} // namespace YAML
--- /dev/null
+#include <limits>
+
+#include "emitterstate.h"
+#include "yaml-cpp/exceptions.h" // IWYU pragma: keep
+
+namespace YAML {
+EmitterState::EmitterState()
+ : m_isGood(true),
+ m_lastError{},
+ // default global manipulators
+ m_charset(EmitNonAscii),
+ m_strFmt(Auto),
+ m_boolFmt(TrueFalseBool),
+ m_boolLengthFmt(LongBool),
+ m_boolCaseFmt(LowerCase),
+ m_nullFmt(TildeNull),
+ m_intFmt(Dec),
+ m_indent(2),
+ m_preCommentIndent(2),
+ m_postCommentIndent(1),
+ m_seqFmt(Block),
+ m_mapFmt(Block),
+ m_mapKeyFmt(Auto),
+ m_floatPrecision(std::numeric_limits<float>::max_digits10),
+ m_doublePrecision(std::numeric_limits<double>::max_digits10),
+ //
+ m_modifiedSettings{},
+ m_globalModifiedSettings{},
+ m_groups{},
+ m_curIndent(0),
+ m_hasAnchor(false),
+ m_hasAlias(false),
+ m_hasTag(false),
+ m_hasNonContent(false),
+ m_docCount(0) {}
+
+EmitterState::~EmitterState() = default;
+
+// SetLocalValue
+// . We blindly tries to set all possible formatters to this value
+// . Only the ones that make sense will be accepted
+void EmitterState::SetLocalValue(EMITTER_MANIP value) {
+ SetOutputCharset(value, FmtScope::Local);
+ SetStringFormat(value, FmtScope::Local);
+ SetBoolFormat(value, FmtScope::Local);
+ SetBoolCaseFormat(value, FmtScope::Local);
+ SetBoolLengthFormat(value, FmtScope::Local);
+ SetNullFormat(value, FmtScope::Local);
+ SetIntFormat(value, FmtScope::Local);
+ SetFlowType(GroupType::Seq, value, FmtScope::Local);
+ SetFlowType(GroupType::Map, value, FmtScope::Local);
+ SetMapKeyFormat(value, FmtScope::Local);
+}
+
+void EmitterState::SetAnchor() { m_hasAnchor = true; }
+
+void EmitterState::SetAlias() { m_hasAlias = true; }
+
+void EmitterState::SetTag() { m_hasTag = true; }
+
+void EmitterState::SetNonContent() { m_hasNonContent = true; }
+
+void EmitterState::SetLongKey() {
+ assert(!m_groups.empty());
+ if (m_groups.empty()) {
+ return;
+ }
+
+ assert(m_groups.back()->type == GroupType::Map);
+ m_groups.back()->longKey = true;
+}
+
+void EmitterState::ForceFlow() {
+ assert(!m_groups.empty());
+ if (m_groups.empty()) {
+ return;
+ }
+
+ m_groups.back()->flowType = FlowType::Flow;
+}
+
+void EmitterState::StartedNode() {
+ if (m_groups.empty()) {
+ m_docCount++;
+ } else {
+ m_groups.back()->childCount++;
+ if (m_groups.back()->childCount % 2 == 0) {
+ m_groups.back()->longKey = false;
+ }
+ }
+
+ m_hasAnchor = false;
+ m_hasAlias = false;
+ m_hasTag = false;
+ m_hasNonContent = false;
+}
+
+EmitterNodeType::value EmitterState::NextGroupType(
+ GroupType::value type) const {
+ if (type == GroupType::Seq) {
+ if (GetFlowType(type) == Block)
+ return EmitterNodeType::BlockSeq;
+ return EmitterNodeType::FlowSeq;
+ }
+
+ if (GetFlowType(type) == Block)
+ return EmitterNodeType::BlockMap;
+ return EmitterNodeType::FlowMap;
+
+ // can't happen
+ assert(false);
+ return EmitterNodeType::NoType;
+}
+
+void EmitterState::StartedDoc() {
+ m_hasAnchor = false;
+ m_hasTag = false;
+ m_hasNonContent = false;
+}
+
+void EmitterState::EndedDoc() {
+ m_hasAnchor = false;
+ m_hasTag = false;
+ m_hasNonContent = false;
+}
+
+void EmitterState::StartedScalar() {
+ StartedNode();
+ ClearModifiedSettings();
+}
+
+void EmitterState::StartedGroup(GroupType::value type) {
+ StartedNode();
+
+ const std::size_t lastGroupIndent =
+ (m_groups.empty() ? 0 : m_groups.back()->indent);
+ m_curIndent += lastGroupIndent;
+
+ // TODO: Create move constructors for settings types to simplify transfer
+ std::unique_ptr<Group> pGroup(new Group(type));
+
+ // transfer settings (which last until this group is done)
+ //
+ // NB: if pGroup->modifiedSettings == m_modifiedSettings,
+ // m_modifiedSettings is not changed!
+ pGroup->modifiedSettings = std::move(m_modifiedSettings);
+
+ // set up group
+ if (GetFlowType(type) == Block) {
+ pGroup->flowType = FlowType::Block;
+ } else {
+ pGroup->flowType = FlowType::Flow;
+ }
+ pGroup->indent = GetIndent();
+
+ m_groups.push_back(std::move(pGroup));
+}
+
+void EmitterState::EndedGroup(GroupType::value type) {
+ if (m_groups.empty()) {
+ if (type == GroupType::Seq) {
+ return SetError(ErrorMsg::UNEXPECTED_END_SEQ);
+ }
+ return SetError(ErrorMsg::UNEXPECTED_END_MAP);
+ }
+
+ if (m_hasTag) {
+ SetError(ErrorMsg::INVALID_TAG);
+ }
+ if (m_hasAnchor) {
+ SetError(ErrorMsg::INVALID_ANCHOR);
+ }
+
+ // get rid of the current group
+ {
+ std::unique_ptr<Group> pFinishedGroup = std::move(m_groups.back());
+ m_groups.pop_back();
+ if (pFinishedGroup->type != type) {
+ return SetError(ErrorMsg::UNMATCHED_GROUP_TAG);
+ }
+ }
+
+ // reset old settings
+ std::size_t lastIndent = (m_groups.empty() ? 0 : m_groups.back()->indent);
+ assert(m_curIndent >= lastIndent);
+ m_curIndent -= lastIndent;
+
+ // some global settings that we changed may have been overridden
+ // by a local setting we just popped, so we need to restore them
+ m_globalModifiedSettings.restore();
+
+ ClearModifiedSettings();
+ m_hasAnchor = false;
+ m_hasTag = false;
+ m_hasNonContent = false;
+}
+
+EmitterNodeType::value EmitterState::CurGroupNodeType() const {
+ if (m_groups.empty()) {
+ return EmitterNodeType::NoType;
+ }
+
+ return m_groups.back()->NodeType();
+}
+
+GroupType::value EmitterState::CurGroupType() const {
+ return m_groups.empty() ? GroupType::NoType : m_groups.back()->type;
+}
+
+FlowType::value EmitterState::CurGroupFlowType() const {
+ return m_groups.empty() ? FlowType::NoType : m_groups.back()->flowType;
+}
+
+std::size_t EmitterState::CurGroupIndent() const {
+ return m_groups.empty() ? 0 : m_groups.back()->indent;
+}
+
+std::size_t EmitterState::CurGroupChildCount() const {
+ return m_groups.empty() ? m_docCount : m_groups.back()->childCount;
+}
+
+bool EmitterState::CurGroupLongKey() const {
+ return m_groups.empty() ? false : m_groups.back()->longKey;
+}
+
+std::size_t EmitterState::LastIndent() const {
+ if (m_groups.size() <= 1) {
+ return 0;
+ }
+
+ return m_curIndent - m_groups[m_groups.size() - 2]->indent;
+}
+
+void EmitterState::ClearModifiedSettings() { m_modifiedSettings.clear(); }
+
+void EmitterState::RestoreGlobalModifiedSettings() {
+ m_globalModifiedSettings.restore();
+}
+
+bool EmitterState::SetOutputCharset(EMITTER_MANIP value,
+ FmtScope::value scope) {
+ switch (value) {
+ case EmitNonAscii:
+ case EscapeNonAscii:
+ case EscapeAsJson:
+ _Set(m_charset, value, scope);
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScope::value scope) {
+ switch (value) {
+ case Auto:
+ case SingleQuoted:
+ case DoubleQuoted:
+ case Literal:
+ _Set(m_strFmt, value, scope);
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope) {
+ switch (value) {
+ case OnOffBool:
+ case TrueFalseBool:
+ case YesNoBool:
+ _Set(m_boolFmt, value, scope);
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value,
+ FmtScope::value scope) {
+ switch (value) {
+ case LongBool:
+ case ShortBool:
+ _Set(m_boolLengthFmt, value, scope);
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value,
+ FmtScope::value scope) {
+ switch (value) {
+ case UpperCase:
+ case LowerCase:
+ case CamelCase:
+ _Set(m_boolCaseFmt, value, scope);
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool EmitterState::SetNullFormat(EMITTER_MANIP value, FmtScope::value scope) {
+ switch (value) {
+ case LowerNull:
+ case UpperNull:
+ case CamelNull:
+ case TildeNull:
+ _Set(m_nullFmt, value, scope);
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope) {
+ switch (value) {
+ case Dec:
+ case Hex:
+ case Oct:
+ _Set(m_intFmt, value, scope);
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool EmitterState::SetIndent(std::size_t value, FmtScope::value scope) {
+ if (value <= 1)
+ return false;
+
+ _Set(m_indent, value, scope);
+ return true;
+}
+
+bool EmitterState::SetPreCommentIndent(std::size_t value,
+ FmtScope::value scope) {
+ if (value == 0)
+ return false;
+
+ _Set(m_preCommentIndent, value, scope);
+ return true;
+}
+
+bool EmitterState::SetPostCommentIndent(std::size_t value,
+ FmtScope::value scope) {
+ if (value == 0)
+ return false;
+
+ _Set(m_postCommentIndent, value, scope);
+ return true;
+}
+
+bool EmitterState::SetFlowType(GroupType::value groupType, EMITTER_MANIP value,
+ FmtScope::value scope) {
+ switch (value) {
+ case Block:
+ case Flow:
+ _Set(groupType == GroupType::Seq ? m_seqFmt : m_mapFmt, value, scope);
+ return true;
+ default:
+ return false;
+ }
+}
+
+EMITTER_MANIP EmitterState::GetFlowType(GroupType::value groupType) const {
+ // force flow style if we're currently in a flow
+ if (CurGroupFlowType() == FlowType::Flow)
+ return Flow;
+
+ // otherwise, go with what's asked of us
+ return (groupType == GroupType::Seq ? m_seqFmt.get() : m_mapFmt.get());
+}
+
+bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope) {
+ switch (value) {
+ case Auto:
+ case LongKey:
+ _Set(m_mapKeyFmt, value, scope);
+ return true;
+ default:
+ return false;
+ }
+}
+
+bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope::value scope) {
+ if (value > std::numeric_limits<float>::max_digits10)
+ return false;
+ _Set(m_floatPrecision, value, scope);
+ return true;
+}
+
+bool EmitterState::SetDoublePrecision(std::size_t value,
+ FmtScope::value scope) {
+ if (value > std::numeric_limits<double>::max_digits10)
+ return false;
+ _Set(m_doublePrecision, value, scope);
+ return true;
+}
+} // namespace YAML
--- /dev/null
+#ifndef EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "setting.h"
+#include "yaml-cpp/emitterdef.h"
+#include "yaml-cpp/emittermanip.h"
+
+#include <cassert>
+#include <memory>
+#include <stack>
+#include <stdexcept>
+#include <vector>
+
+namespace YAML {
+struct FmtScope {
+ enum value { Local, Global };
+};
+struct GroupType {
+ enum value { NoType, Seq, Map };
+};
+struct FlowType {
+ enum value { NoType, Flow, Block };
+};
+
+class EmitterState {
+ public:
+ EmitterState();
+ ~EmitterState();
+
+ // basic state checking
+ bool good() const { return m_isGood; }
+ const std::string GetLastError() const { return m_lastError; }
+ void SetError(const std::string& error) {
+ m_isGood = false;
+ m_lastError = error;
+ }
+
+ // node handling
+ void SetAnchor();
+ void SetAlias();
+ void SetTag();
+ void SetNonContent();
+ void SetLongKey();
+ void ForceFlow();
+ void StartedDoc();
+ void EndedDoc();
+ void StartedScalar();
+ void StartedGroup(GroupType::value type);
+ void EndedGroup(GroupType::value type);
+
+ EmitterNodeType::value NextGroupType(GroupType::value type) const;
+ EmitterNodeType::value CurGroupNodeType() const;
+
+ GroupType::value CurGroupType() const;
+ FlowType::value CurGroupFlowType() const;
+ std::size_t CurGroupIndent() const;
+ std::size_t CurGroupChildCount() const;
+ bool CurGroupLongKey() const;
+
+ std::size_t LastIndent() const;
+ std::size_t CurIndent() const { return m_curIndent; }
+ bool HasAnchor() const { return m_hasAnchor; }
+ bool HasAlias() const { return m_hasAlias; }
+ bool HasTag() const { return m_hasTag; }
+ bool HasBegunNode() const {
+ return m_hasAnchor || m_hasTag || m_hasNonContent;
+ }
+ bool HasBegunContent() const { return m_hasAnchor || m_hasTag; }
+
+ void ClearModifiedSettings();
+ void RestoreGlobalModifiedSettings();
+
+ // formatters
+ void SetLocalValue(EMITTER_MANIP value);
+
+ bool SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope);
+ EMITTER_MANIP GetOutputCharset() const { return m_charset.get(); }
+
+ bool SetStringFormat(EMITTER_MANIP value, FmtScope::value scope);
+ EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); }
+
+ bool SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope);
+ EMITTER_MANIP GetBoolFormat() const { return m_boolFmt.get(); }
+
+ bool SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope);
+ EMITTER_MANIP GetBoolLengthFormat() const { return m_boolLengthFmt.get(); }
+
+ bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope);
+ EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); }
+
+ bool SetNullFormat(EMITTER_MANIP value, FmtScope::value scope);
+ EMITTER_MANIP GetNullFormat() const { return m_nullFmt.get(); }
+
+ bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope);
+ EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); }
+
+ bool SetIndent(std::size_t value, FmtScope::value scope);
+ std::size_t GetIndent() const { return m_indent.get(); }
+
+ bool SetPreCommentIndent(std::size_t value, FmtScope::value scope);
+ std::size_t GetPreCommentIndent() const { return m_preCommentIndent.get(); }
+ bool SetPostCommentIndent(std::size_t value, FmtScope::value scope);
+ std::size_t GetPostCommentIndent() const { return m_postCommentIndent.get(); }
+
+ bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value,
+ FmtScope::value scope);
+ EMITTER_MANIP GetFlowType(GroupType::value groupType) const;
+
+ bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope);
+ EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); }
+
+ bool SetFloatPrecision(std::size_t value, FmtScope::value scope);
+ std::size_t GetFloatPrecision() const { return m_floatPrecision.get(); }
+ bool SetDoublePrecision(std::size_t value, FmtScope::value scope);
+ std::size_t GetDoublePrecision() const { return m_doublePrecision.get(); }
+
+ private:
+ template <typename T>
+ void _Set(Setting<T>& fmt, T value, FmtScope::value scope);
+
+ void StartedNode();
+
+ private:
+ // basic state ok?
+ bool m_isGood;
+ std::string m_lastError;
+
+ // other state
+ Setting<EMITTER_MANIP> m_charset;
+ Setting<EMITTER_MANIP> m_strFmt;
+ Setting<EMITTER_MANIP> m_boolFmt;
+ Setting<EMITTER_MANIP> m_boolLengthFmt;
+ Setting<EMITTER_MANIP> m_boolCaseFmt;
+ Setting<EMITTER_MANIP> m_nullFmt;
+ Setting<EMITTER_MANIP> m_intFmt;
+ Setting<std::size_t> m_indent;
+ Setting<std::size_t> m_preCommentIndent, m_postCommentIndent;
+ Setting<EMITTER_MANIP> m_seqFmt;
+ Setting<EMITTER_MANIP> m_mapFmt;
+ Setting<EMITTER_MANIP> m_mapKeyFmt;
+ Setting<std::size_t> m_floatPrecision;
+ Setting<std::size_t> m_doublePrecision;
+
+ SettingChanges m_modifiedSettings;
+ SettingChanges m_globalModifiedSettings;
+
+ struct Group {
+ explicit Group(GroupType::value type_)
+ : type(type_),
+ flowType{},
+ indent(0),
+ childCount(0),
+ longKey(false),
+ modifiedSettings{} {}
+
+ GroupType::value type;
+ FlowType::value flowType;
+ std::size_t indent;
+ std::size_t childCount;
+ bool longKey;
+
+ SettingChanges modifiedSettings;
+
+ EmitterNodeType::value NodeType() const {
+ if (type == GroupType::Seq) {
+ if (flowType == FlowType::Flow)
+ return EmitterNodeType::FlowSeq;
+ else
+ return EmitterNodeType::BlockSeq;
+ } else {
+ if (flowType == FlowType::Flow)
+ return EmitterNodeType::FlowMap;
+ else
+ return EmitterNodeType::BlockMap;
+ }
+
+ // can't get here
+ assert(false);
+ return EmitterNodeType::NoType;
+ }
+ };
+
+ std::vector<std::unique_ptr<Group>> m_groups;
+ std::size_t m_curIndent;
+ bool m_hasAnchor;
+ bool m_hasAlias;
+ bool m_hasTag;
+ bool m_hasNonContent;
+ std::size_t m_docCount;
+};
+
+template <typename T>
+void EmitterState::_Set(Setting<T>& fmt, T value, FmtScope::value scope) {
+ switch (scope) {
+ case FmtScope::Local:
+ m_modifiedSettings.push(fmt.set(value));
+ break;
+ case FmtScope::Global:
+ fmt.set(value);
+ m_globalModifiedSettings.push(
+ fmt.set(value)); // this pushes an identity set, so when we restore,
+ // it restores to the value here, and not the previous one
+ break;
+ default:
+ assert(false);
+ }
+}
+} // namespace YAML
+
+#endif // EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include <algorithm>
+#include <iomanip>
+#include <sstream>
+
+#include "emitterutils.h"
+#include "exp.h"
+#include "indentation.h"
+#include "regex_yaml.h"
+#include "regeximpl.h"
+#include "stringsource.h"
+#include "yaml-cpp/binary.h" // IWYU pragma: keep
+#include "yaml-cpp/null.h"
+#include "yaml-cpp/ostream_wrapper.h"
+
+namespace YAML {
+namespace Utils {
+namespace {
+enum { REPLACEMENT_CHARACTER = 0xFFFD };
+
+bool IsAnchorChar(int ch) { // test for ns-anchor-char
+ switch (ch) {
+ case ',':
+ case '[':
+ case ']':
+ case '{':
+ case '}': // c-flow-indicator
+ case ' ':
+ case '\t': // s-white
+ case 0xFEFF: // c-byte-order-mark
+ case 0xA:
+ case 0xD: // b-char
+ return false;
+ case 0x85:
+ return true;
+ }
+
+ if (ch < 0x20) {
+ return false;
+ }
+
+ if (ch < 0x7E) {
+ return true;
+ }
+
+ if (ch < 0xA0) {
+ return false;
+ }
+ if (ch >= 0xD800 && ch <= 0xDFFF) {
+ return false;
+ }
+ if ((ch & 0xFFFE) == 0xFFFE) {
+ return false;
+ }
+ if ((ch >= 0xFDD0) && (ch <= 0xFDEF)) {
+ return false;
+ }
+ if (ch > 0x10FFFF) {
+ return false;
+ }
+
+ return true;
+}
+
+int Utf8BytesIndicated(char ch) {
+ int byteVal = static_cast<unsigned char>(ch);
+ switch (byteVal >> 4) {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ case 5:
+ case 6:
+ case 7:
+ return 1;
+ case 12:
+ case 13:
+ return 2;
+ case 14:
+ return 3;
+ case 15:
+ return 4;
+ default:
+ return -1;
+ }
+}
+
+bool IsTrailingByte(char ch) { return (ch & 0xC0) == 0x80; }
+
+bool GetNextCodePointAndAdvance(int& codePoint,
+ std::string::const_iterator& first,
+ std::string::const_iterator last) {
+ if (first == last)
+ return false;
+
+ int nBytes = Utf8BytesIndicated(*first);
+ if (nBytes < 1) {
+ // Bad lead byte
+ ++first;
+ codePoint = REPLACEMENT_CHARACTER;
+ return true;
+ }
+
+ if (nBytes == 1) {
+ codePoint = *first++;
+ return true;
+ }
+
+ // Gather bits from trailing bytes
+ codePoint = static_cast<unsigned char>(*first) & ~(0xFF << (7 - nBytes));
+ ++first;
+ --nBytes;
+ for (; nBytes > 0; ++first, --nBytes) {
+ if ((first == last) || !IsTrailingByte(*first)) {
+ codePoint = REPLACEMENT_CHARACTER;
+ break;
+ }
+ codePoint <<= 6;
+ codePoint |= *first & 0x3F;
+ }
+
+ // Check for illegal code points
+ if (codePoint > 0x10FFFF)
+ codePoint = REPLACEMENT_CHARACTER;
+ else if (codePoint >= 0xD800 && codePoint <= 0xDFFF)
+ codePoint = REPLACEMENT_CHARACTER;
+ else if ((codePoint & 0xFFFE) == 0xFFFE)
+ codePoint = REPLACEMENT_CHARACTER;
+ else if (codePoint >= 0xFDD0 && codePoint <= 0xFDEF)
+ codePoint = REPLACEMENT_CHARACTER;
+ return true;
+}
+
+void WriteCodePoint(ostream_wrapper& out, int codePoint) {
+ if (codePoint < 0 || codePoint > 0x10FFFF) {
+ codePoint = REPLACEMENT_CHARACTER;
+ }
+ if (codePoint <= 0x7F) {
+ out << static_cast<char>(codePoint);
+ } else if (codePoint <= 0x7FF) {
+ out << static_cast<char>(0xC0 | (codePoint >> 6))
+ << static_cast<char>(0x80 | (codePoint & 0x3F));
+ } else if (codePoint <= 0xFFFF) {
+ out << static_cast<char>(0xE0 | (codePoint >> 12))
+ << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F))
+ << static_cast<char>(0x80 | (codePoint & 0x3F));
+ } else {
+ out << static_cast<char>(0xF0 | (codePoint >> 18))
+ << static_cast<char>(0x80 | ((codePoint >> 12) & 0x3F))
+ << static_cast<char>(0x80 | ((codePoint >> 6) & 0x3F))
+ << static_cast<char>(0x80 | (codePoint & 0x3F));
+ }
+}
+
+bool IsValidPlainScalar(const std::string& str, FlowType::value flowType,
+ bool allowOnlyAscii) {
+ // check against null
+ if (IsNullString(str)) {
+ return false;
+ }
+
+ // check the start
+ const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow()
+ : Exp::PlainScalar());
+ if (!start.Matches(str)) {
+ return false;
+ }
+
+ // and check the end for plain whitespace (which can't be faithfully kept in a
+ // plain scalar)
+ if (!str.empty() && *str.rbegin() == ' ') {
+ return false;
+ }
+
+ // then check until something is disallowed
+ static const RegEx& disallowed_flow =
+ Exp::EndScalarInFlow() | (Exp::BlankOrBreak() + Exp::Comment()) |
+ Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
+ Exp::Tab() | Exp::Ampersand();
+ static const RegEx& disallowed_block =
+ Exp::EndScalar() | (Exp::BlankOrBreak() + Exp::Comment()) |
+ Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() |
+ Exp::Tab() | Exp::Ampersand();
+ const RegEx& disallowed =
+ flowType == FlowType::Flow ? disallowed_flow : disallowed_block;
+
+ StringCharSource buffer(str.c_str(), str.size());
+ while (buffer) {
+ if (disallowed.Matches(buffer)) {
+ return false;
+ }
+ if (allowOnlyAscii && (0x80 <= static_cast<unsigned char>(buffer[0]))) {
+ return false;
+ }
+ ++buffer;
+ }
+
+ return true;
+}
+
+bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) {
+ // TODO: check for non-printable characters?
+ return std::none_of(str.begin(), str.end(), [=](char ch) {
+ return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch))) ||
+ (ch == '\n');
+ });
+}
+
+bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType,
+ bool escapeNonAscii) {
+ if (flowType == FlowType::Flow) {
+ return false;
+ }
+
+ // TODO: check for non-printable characters?
+ return std::none_of(str.begin(), str.end(), [=](char ch) {
+ return (escapeNonAscii && (0x80 <= static_cast<unsigned char>(ch)));
+ });
+}
+
+std::pair<uint16_t, uint16_t> EncodeUTF16SurrogatePair(int codePoint) {
+ const uint32_t leadOffset = 0xD800 - (0x10000 >> 10);
+
+ return {
+ leadOffset | (codePoint >> 10),
+ 0xDC00 | (codePoint & 0x3FF),
+ };
+}
+
+void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint, StringEscaping::value stringEscapingStyle) {
+ static const char hexDigits[] = "0123456789abcdef";
+
+ out << "\\";
+ int digits = 8;
+ if (codePoint < 0xFF && stringEscapingStyle != StringEscaping::JSON) {
+ out << "x";
+ digits = 2;
+ } else if (codePoint < 0xFFFF) {
+ out << "u";
+ digits = 4;
+ } else if (stringEscapingStyle != StringEscaping::JSON) {
+ out << "U";
+ digits = 8;
+ } else {
+ auto surrogatePair = EncodeUTF16SurrogatePair(codePoint);
+ WriteDoubleQuoteEscapeSequence(out, surrogatePair.first, stringEscapingStyle);
+ WriteDoubleQuoteEscapeSequence(out, surrogatePair.second, stringEscapingStyle);
+ return;
+ }
+
+ // Write digits into the escape sequence
+ for (; digits > 0; --digits)
+ out << hexDigits[(codePoint >> (4 * (digits - 1))) & 0xF];
+}
+
+bool WriteAliasName(ostream_wrapper& out, const std::string& str) {
+ int codePoint;
+ for (std::string::const_iterator i = str.begin();
+ GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+ if (!IsAnchorChar(codePoint)) {
+ return false;
+ }
+
+ WriteCodePoint(out, codePoint);
+ }
+ return true;
+}
+} // namespace
+
+StringFormat::value ComputeStringFormat(const std::string& str,
+ EMITTER_MANIP strFormat,
+ FlowType::value flowType,
+ bool escapeNonAscii) {
+ switch (strFormat) {
+ case Auto:
+ if (IsValidPlainScalar(str, flowType, escapeNonAscii)) {
+ return StringFormat::Plain;
+ }
+ return StringFormat::DoubleQuoted;
+ case SingleQuoted:
+ if (IsValidSingleQuotedScalar(str, escapeNonAscii)) {
+ return StringFormat::SingleQuoted;
+ }
+ return StringFormat::DoubleQuoted;
+ case DoubleQuoted:
+ return StringFormat::DoubleQuoted;
+ case Literal:
+ if (IsValidLiteralScalar(str, flowType, escapeNonAscii)) {
+ return StringFormat::Literal;
+ }
+ return StringFormat::DoubleQuoted;
+ default:
+ break;
+ }
+
+ return StringFormat::DoubleQuoted;
+}
+
+bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str) {
+ out << "'";
+ int codePoint;
+ for (std::string::const_iterator i = str.begin();
+ GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+ if (codePoint == '\n') {
+ return false; // We can't handle a new line and the attendant indentation
+ // yet
+ }
+
+ if (codePoint == '\'') {
+ out << "''";
+ } else {
+ WriteCodePoint(out, codePoint);
+ }
+ }
+ out << "'";
+ return true;
+}
+
+bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
+ StringEscaping::value stringEscaping) {
+ out << "\"";
+ int codePoint;
+ for (std::string::const_iterator i = str.begin();
+ GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+ switch (codePoint) {
+ case '\"':
+ out << "\\\"";
+ break;
+ case '\\':
+ out << "\\\\";
+ break;
+ case '\n':
+ out << "\\n";
+ break;
+ case '\t':
+ out << "\\t";
+ break;
+ case '\r':
+ out << "\\r";
+ break;
+ case '\b':
+ out << "\\b";
+ break;
+ case '\f':
+ out << "\\f";
+ break;
+ default:
+ if (codePoint < 0x20 ||
+ (codePoint >= 0x80 &&
+ codePoint <= 0xA0)) { // Control characters and non-breaking space
+ WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
+ } else if (codePoint == 0xFEFF) { // Byte order marks (ZWNS) should be
+ // escaped (YAML 1.2, sec. 5.2)
+ WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
+ } else if (stringEscaping == StringEscaping::NonAscii && codePoint > 0x7E) {
+ WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping);
+ } else {
+ WriteCodePoint(out, codePoint);
+ }
+ }
+ }
+ out << "\"";
+ return true;
+}
+
+bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
+ std::size_t indent) {
+ out << "|\n";
+ int codePoint;
+ for (std::string::const_iterator i = str.begin();
+ GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+ if (codePoint == '\n') {
+ out << "\n";
+ } else {
+ out<< IndentTo(indent);
+ WriteCodePoint(out, codePoint);
+ }
+ }
+ return true;
+}
+
+bool WriteChar(ostream_wrapper& out, char ch, StringEscaping::value stringEscapingStyle) {
+ if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z')) {
+ out << ch;
+ } else if (ch == '\"') {
+ out << R"("\"")";
+ } else if (ch == '\t') {
+ out << R"("\t")";
+ } else if (ch == '\n') {
+ out << R"("\n")";
+ } else if (ch == '\b') {
+ out << R"("\b")";
+ } else if (ch == '\r') {
+ out << R"("\r")";
+ } else if (ch == '\f') {
+ out << R"("\f")";
+ } else if (ch == '\\') {
+ out << R"("\\")";
+ } else if (0x20 <= ch && ch <= 0x7e) {
+ out << "\"" << ch << "\"";
+ } else {
+ out << "\"";
+ WriteDoubleQuoteEscapeSequence(out, ch, stringEscapingStyle);
+ out << "\"";
+ }
+ return true;
+}
+
+bool WriteComment(ostream_wrapper& out, const std::string& str,
+ std::size_t postCommentIndent) {
+ const std::size_t curIndent = out.col();
+ out << "#" << Indentation(postCommentIndent);
+ out.set_comment();
+ int codePoint;
+ for (std::string::const_iterator i = str.begin();
+ GetNextCodePointAndAdvance(codePoint, i, str.end());) {
+ if (codePoint == '\n') {
+ out << "\n"
+ << IndentTo(curIndent) << "#" << Indentation(postCommentIndent);
+ out.set_comment();
+ } else {
+ WriteCodePoint(out, codePoint);
+ }
+ }
+ return true;
+}
+
+bool WriteAlias(ostream_wrapper& out, const std::string& str) {
+ out << "*";
+ return WriteAliasName(out, str);
+}
+
+bool WriteAnchor(ostream_wrapper& out, const std::string& str) {
+ out << "&";
+ return WriteAliasName(out, str);
+}
+
+bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim) {
+ out << (verbatim ? "!<" : "!");
+ StringCharSource buffer(str.c_str(), str.size());
+ const RegEx& reValid = verbatim ? Exp::URI() : Exp::Tag();
+ while (buffer) {
+ int n = reValid.Match(buffer);
+ if (n <= 0) {
+ return false;
+ }
+
+ while (--n >= 0) {
+ out << buffer[0];
+ ++buffer;
+ }
+ }
+ if (verbatim) {
+ out << ">";
+ }
+ return true;
+}
+
+bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix,
+ const std::string& tag) {
+ out << "!";
+ StringCharSource prefixBuffer(prefix.c_str(), prefix.size());
+ while (prefixBuffer) {
+ int n = Exp::URI().Match(prefixBuffer);
+ if (n <= 0) {
+ return false;
+ }
+
+ while (--n >= 0) {
+ out << prefixBuffer[0];
+ ++prefixBuffer;
+ }
+ }
+
+ out << "!";
+ StringCharSource tagBuffer(tag.c_str(), tag.size());
+ while (tagBuffer) {
+ int n = Exp::Tag().Match(tagBuffer);
+ if (n <= 0) {
+ return false;
+ }
+
+ while (--n >= 0) {
+ out << tagBuffer[0];
+ ++tagBuffer;
+ }
+ }
+ return true;
+}
+
+bool WriteBinary(ostream_wrapper& out, const Binary& binary) {
+ WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()),
+ StringEscaping::None);
+ return true;
+}
+} // namespace Utils
+} // namespace YAML
--- /dev/null
+#ifndef EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+#include "emitterstate.h"
+#include "yaml-cpp/emittermanip.h"
+#include "yaml-cpp/ostream_wrapper.h"
+
+namespace YAML {
+class ostream_wrapper;
+} // namespace YAML
+
+namespace YAML {
+class Binary;
+
+struct StringFormat {
+ enum value { Plain, SingleQuoted, DoubleQuoted, Literal };
+};
+
+struct StringEscaping {
+ enum value { None, NonAscii, JSON };
+};
+
+namespace Utils {
+StringFormat::value ComputeStringFormat(const std::string& str,
+ EMITTER_MANIP strFormat,
+ FlowType::value flowType,
+ bool escapeNonAscii);
+
+bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str);
+bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str,
+ StringEscaping::value stringEscaping);
+bool WriteLiteralString(ostream_wrapper& out, const std::string& str,
+ std::size_t indent);
+bool WriteChar(ostream_wrapper& out, char ch,
+ StringEscaping::value stringEscapingStyle);
+bool WriteComment(ostream_wrapper& out, const std::string& str,
+ std::size_t postCommentIndent);
+bool WriteAlias(ostream_wrapper& out, const std::string& str);
+bool WriteAnchor(ostream_wrapper& out, const std::string& str);
+bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim);
+bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix,
+ const std::string& tag);
+bool WriteBinary(ostream_wrapper& out, const Binary& binary);
+}
+}
+
+#endif // EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include "yaml-cpp/exceptions.h"
+#include "yaml-cpp/noexcept.h"
+
+namespace YAML {
+
+// These destructors are defined out-of-line so the vtable is only emitted once.
+Exception::~Exception() YAML_CPP_NOEXCEPT = default;
+ParserException::~ParserException() YAML_CPP_NOEXCEPT = default;
+RepresentationException::~RepresentationException() YAML_CPP_NOEXCEPT = default;
+InvalidScalar::~InvalidScalar() YAML_CPP_NOEXCEPT = default;
+KeyNotFound::~KeyNotFound() YAML_CPP_NOEXCEPT = default;
+InvalidNode::~InvalidNode() YAML_CPP_NOEXCEPT = default;
+BadConversion::~BadConversion() YAML_CPP_NOEXCEPT = default;
+BadDereference::~BadDereference() YAML_CPP_NOEXCEPT = default;
+BadSubscript::~BadSubscript() YAML_CPP_NOEXCEPT = default;
+BadPushback::~BadPushback() YAML_CPP_NOEXCEPT = default;
+BadInsert::~BadInsert() YAML_CPP_NOEXCEPT = default;
+EmitterException::~EmitterException() YAML_CPP_NOEXCEPT = default;
+BadFile::~BadFile() YAML_CPP_NOEXCEPT = default;
+} // namespace YAML
--- /dev/null
+#include <sstream>
+
+#include "exp.h"
+#include "stream.h"
+#include "yaml-cpp/exceptions.h" // IWYU pragma: keep
+
+namespace YAML {
+struct Mark;
+} // namespace YAML
+
+namespace YAML {
+namespace Exp {
+unsigned ParseHex(const std::string& str, const Mark& mark) {
+ unsigned value = 0;
+ for (char ch : str) {
+ int digit = 0;
+ if ('a' <= ch && ch <= 'f')
+ digit = ch - 'a' + 10;
+ else if ('A' <= ch && ch <= 'F')
+ digit = ch - 'A' + 10;
+ else if ('0' <= ch && ch <= '9')
+ digit = ch - '0';
+ else
+ throw ParserException(mark, ErrorMsg::INVALID_HEX);
+
+ value = (value << 4) + digit;
+ }
+
+ return value;
+}
+
+std::string Str(unsigned ch) { return std::string(1, static_cast<char>(ch)); }
+
+// Escape
+// . Translates the next 'codeLength' characters into a hex number and returns
+// the result.
+// . Throws if it's not actually hex.
+std::string Escape(Stream& in, int codeLength) {
+ // grab string
+ std::string str;
+ for (int i = 0; i < codeLength; i++)
+ str += in.get();
+
+ // get the value
+ unsigned value = ParseHex(str, in.mark());
+
+ // legal unicode?
+ if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) {
+ std::stringstream msg;
+ msg << ErrorMsg::INVALID_UNICODE << value;
+ throw ParserException(in.mark(), msg.str());
+ }
+
+ // now break it up into chars
+ if (value <= 0x7F)
+ return Str(value);
+
+ if (value <= 0x7FF)
+ return Str(0xC0 + (value >> 6)) + Str(0x80 + (value & 0x3F));
+
+ if (value <= 0xFFFF)
+ return Str(0xE0 + (value >> 12)) + Str(0x80 + ((value >> 6) & 0x3F)) +
+ Str(0x80 + (value & 0x3F));
+
+ return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) +
+ Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F));
+}
+
+// Escape
+// . Escapes the sequence starting 'in' (it must begin with a '\' or single
+// quote)
+// and returns the result.
+// . Throws if it's an unknown escape character.
+std::string Escape(Stream& in) {
+ // eat slash
+ char escape = in.get();
+
+ // switch on escape character
+ char ch = in.get();
+
+ // first do single quote, since it's easier
+ if (escape == '\'' && ch == '\'')
+ return "\'";
+
+ // now do the slash (we're not gonna check if it's a slash - you better pass
+ // one!)
+ switch (ch) {
+ case '0':
+ return std::string(1, '\x00');
+ case 'a':
+ return "\x07";
+ case 'b':
+ return "\x08";
+ case 't':
+ case '\t':
+ return "\x09";
+ case 'n':
+ return "\x0A";
+ case 'v':
+ return "\x0B";
+ case 'f':
+ return "\x0C";
+ case 'r':
+ return "\x0D";
+ case 'e':
+ return "\x1B";
+ case ' ':
+ return R"( )";
+ case '\"':
+ return "\"";
+ case '\'':
+ return "\'";
+ case '\\':
+ return "\\";
+ case '/':
+ return "/";
+ case 'N':
+ return "\x85";
+ case '_':
+ return "\xA0";
+ case 'L':
+ return "\xE2\x80\xA8"; // LS (#x2028)
+ case 'P':
+ return "\xE2\x80\xA9"; // PS (#x2029)
+ case 'x':
+ return Escape(in, 2);
+ case 'u':
+ return Escape(in, 4);
+ case 'U':
+ return Escape(in, 8);
+ }
+
+ std::stringstream msg;
+ throw ParserException(in.mark(), std::string(ErrorMsg::INVALID_ESCAPE) + ch);
+}
+} // namespace Exp
+} // namespace YAML
--- /dev/null
+#ifndef EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <ios>
+#include <string>
+
+#include "regex_yaml.h"
+#include "stream.h"
+
+namespace YAML {
+////////////////////////////////////////////////////////////////////////////////
+// Here we store a bunch of expressions for matching different parts of the
+// file.
+
+namespace Exp {
+// misc
+inline const RegEx& Empty() {
+ static const RegEx e;
+ return e;
+}
+inline const RegEx& Space() {
+ static const RegEx e = RegEx(' ');
+ return e;
+}
+inline const RegEx& Tab() {
+ static const RegEx e = RegEx('\t');
+ return e;
+}
+inline const RegEx& Blank() {
+ static const RegEx e = Space() | Tab();
+ return e;
+}
+inline const RegEx& Break() {
+ static const RegEx e = RegEx('\n') | RegEx("\r\n") | RegEx('\r');
+ return e;
+}
+inline const RegEx& BlankOrBreak() {
+ static const RegEx e = Blank() | Break();
+ return e;
+}
+inline const RegEx& Digit() {
+ static const RegEx e = RegEx('0', '9');
+ return e;
+}
+inline const RegEx& Alpha() {
+ static const RegEx e = RegEx('a', 'z') | RegEx('A', 'Z');
+ return e;
+}
+inline const RegEx& AlphaNumeric() {
+ static const RegEx e = Alpha() | Digit();
+ return e;
+}
+inline const RegEx& Word() {
+ static const RegEx e = AlphaNumeric() | RegEx('-');
+ return e;
+}
+inline const RegEx& Hex() {
+ static const RegEx e = Digit() | RegEx('A', 'F') | RegEx('a', 'f');
+ return e;
+}
+// Valid Unicode code points that are not part of c-printable (YAML 1.2, sec.
+// 5.1)
+inline const RegEx& NotPrintable() {
+ static const RegEx e =
+ RegEx(0) |
+ RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) |
+ RegEx(0x0E, 0x1F) |
+ (RegEx('\xC2') + (RegEx('\x80', '\x84') | RegEx('\x86', '\x9F')));
+ return e;
+}
+inline const RegEx& Utf8_ByteOrderMark() {
+ static const RegEx e = RegEx("\xEF\xBB\xBF");
+ return e;
+}
+
+// actual tags
+
+inline const RegEx& DocStart() {
+ static const RegEx e = RegEx("---") + (BlankOrBreak() | RegEx());
+ return e;
+}
+inline const RegEx& DocEnd() {
+ static const RegEx e = RegEx("...") + (BlankOrBreak() | RegEx());
+ return e;
+}
+inline const RegEx& DocIndicator() {
+ static const RegEx e = DocStart() | DocEnd();
+ return e;
+}
+inline const RegEx& BlockEntry() {
+ static const RegEx e = RegEx('-') + (BlankOrBreak() | RegEx());
+ return e;
+}
+inline const RegEx& Key() {
+ static const RegEx e = RegEx('?') + BlankOrBreak();
+ return e;
+}
+inline const RegEx& KeyInFlow() {
+ static const RegEx e = RegEx('?') + BlankOrBreak();
+ return e;
+}
+inline const RegEx& Value() {
+ static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx());
+ return e;
+}
+inline const RegEx& ValueInFlow() {
+ static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx(",]}", REGEX_OR));
+ return e;
+}
+inline const RegEx& ValueInJSONFlow() {
+ static const RegEx e = RegEx(':');
+ return e;
+}
+inline const RegEx& Ampersand() {
+ static const RegEx e = RegEx('&');
+ return e;
+}
+inline const RegEx Comment() {
+ static const RegEx e = RegEx('#');
+ return e;
+}
+inline const RegEx& Anchor() {
+ static const RegEx e = !(RegEx("[]{},", REGEX_OR) | BlankOrBreak());
+ return e;
+}
+inline const RegEx& AnchorEnd() {
+ static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) | BlankOrBreak();
+ return e;
+}
+inline const RegEx& URI() {
+ static const RegEx e = Word() | RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) |
+ (RegEx('%') + Hex() + Hex());
+ return e;
+}
+inline const RegEx& Tag() {
+ static const RegEx e = Word() | RegEx("#;/?:@&=+$_.~*'()", REGEX_OR) |
+ (RegEx('%') + Hex() + Hex());
+ return e;
+}
+
+// Plain scalar rules:
+// . Cannot start with a blank.
+// . Can never start with any of , [ ] { } # & * ! | > \' \" % @ `
+// . In the block context - ? : must be not be followed with a space.
+// . In the flow context ? is illegal and : and - must not be followed with a
+// space.
+inline const RegEx& PlainScalar() {
+ static const RegEx e =
+ !(BlankOrBreak() | RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) |
+ (RegEx("-?:", REGEX_OR) + (BlankOrBreak() | RegEx())));
+ return e;
+}
+inline const RegEx& PlainScalarInFlow() {
+ static const RegEx e =
+ !(BlankOrBreak() | RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) |
+ (RegEx("-:", REGEX_OR) + (Blank() | RegEx())));
+ return e;
+}
+inline const RegEx& EndScalar() {
+ static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx());
+ return e;
+}
+inline const RegEx& EndScalarInFlow() {
+ static const RegEx e =
+ (RegEx(':') + (BlankOrBreak() | RegEx() | RegEx(",]}", REGEX_OR))) |
+ RegEx(",?[]{}", REGEX_OR);
+ return e;
+}
+
+inline const RegEx& ScanScalarEndInFlow() {
+ static const RegEx e = (EndScalarInFlow() | (BlankOrBreak() + Comment()));
+ return e;
+}
+
+inline const RegEx& ScanScalarEnd() {
+ static const RegEx e = EndScalar() | (BlankOrBreak() + Comment());
+ return e;
+}
+inline const RegEx& EscSingleQuote() {
+ static const RegEx e = RegEx("\'\'");
+ return e;
+}
+inline const RegEx& EscBreak() {
+ static const RegEx e = RegEx('\\') + Break();
+ return e;
+}
+
+inline const RegEx& ChompIndicator() {
+ static const RegEx e = RegEx("+-", REGEX_OR);
+ return e;
+}
+inline const RegEx& Chomp() {
+ static const RegEx e = (ChompIndicator() + Digit()) |
+ (Digit() + ChompIndicator()) | ChompIndicator() |
+ Digit();
+ return e;
+}
+
+// and some functions
+std::string Escape(Stream& in);
+} // namespace Exp
+
+namespace Keys {
+const char Directive = '%';
+const char FlowSeqStart = '[';
+const char FlowSeqEnd = ']';
+const char FlowMapStart = '{';
+const char FlowMapEnd = '}';
+const char FlowEntry = ',';
+const char Alias = '*';
+const char Anchor = '&';
+const char Tag = '!';
+const char LiteralScalar = '|';
+const char FoldedScalar = '>';
+const char VerbatimTagStart = '<';
+const char VerbatimTagEnd = '>';
+} // namespace Keys
+} // namespace YAML
+
+#endif // EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <iostream>
+#include <cstddef>
+
+#include "yaml-cpp/ostream_wrapper.h"
+
+namespace YAML {
+struct Indentation {
+ Indentation(std::size_t n_) : n(n_) {}
+ std::size_t n;
+};
+
+inline ostream_wrapper& operator<<(ostream_wrapper& out,
+ const Indentation& indent) {
+ for (std::size_t i = 0; i < indent.n; i++)
+ out << ' ';
+ return out;
+}
+
+struct IndentTo {
+ IndentTo(std::size_t n_) : n(n_) {}
+ std::size_t n;
+};
+
+inline ostream_wrapper& operator<<(ostream_wrapper& out,
+ const IndentTo& indent) {
+ while (out.col() < indent.n)
+ out << ' ';
+ return out;
+}
+}
+
+#endif // INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include "yaml-cpp/node/detail/memory.h"
+#include "yaml-cpp/node/detail/node.h" // IWYU pragma: keep
+#include "yaml-cpp/node/ptr.h"
+
+namespace YAML {
+namespace detail {
+
+void memory_holder::merge(memory_holder& rhs) {
+ if (m_pMemory == rhs.m_pMemory)
+ return;
+
+ m_pMemory->merge(*rhs.m_pMemory);
+ rhs.m_pMemory = m_pMemory;
+}
+
+node& memory::create_node() {
+ shared_node pNode(new node);
+ m_nodes.insert(pNode);
+ return *pNode;
+}
+
+void memory::merge(const memory& rhs) {
+ m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end());
+}
+} // namespace detail
+} // namespace YAML
--- /dev/null
+#include "yaml-cpp/node/node.h"
+#include "nodebuilder.h"
+#include "nodeevents.h"
+
+namespace YAML {
+Node Clone(const Node& node) {
+ NodeEvents events(node);
+ NodeBuilder builder;
+ events.Emit(builder);
+ return builder.Root();
+}
+} // namespace YAML
--- /dev/null
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <sstream>
+
+#include "yaml-cpp/exceptions.h"
+#include "yaml-cpp/node/detail/memory.h"
+#include "yaml-cpp/node/detail/node.h" // IWYU pragma: keep
+#include "yaml-cpp/node/detail/node_data.h"
+#include "yaml-cpp/node/detail/node_iterator.h"
+#include "yaml-cpp/node/ptr.h"
+#include "yaml-cpp/node/type.h"
+
+namespace YAML {
+namespace detail {
+YAML_CPP_API std::atomic<size_t> node::m_amount{0};
+
+const std::string& node_data::empty_scalar() {
+ static const std::string svalue;
+ return svalue;
+}
+
+node_data::node_data()
+ : m_isDefined(false),
+ m_mark(Mark::null_mark()),
+ m_type(NodeType::Null),
+ m_tag{},
+ m_style(EmitterStyle::Default),
+ m_scalar{},
+ m_sequence{},
+ m_seqSize(0),
+ m_map{},
+ m_undefinedPairs{} {}
+
+void node_data::mark_defined() {
+ if (m_type == NodeType::Undefined)
+ m_type = NodeType::Null;
+ m_isDefined = true;
+}
+
+void node_data::set_mark(const Mark& mark) { m_mark = mark; }
+
+void node_data::set_type(NodeType::value type) {
+ if (type == NodeType::Undefined) {
+ m_type = type;
+ m_isDefined = false;
+ return;
+ }
+
+ m_isDefined = true;
+ if (type == m_type)
+ return;
+
+ m_type = type;
+
+ switch (m_type) {
+ case NodeType::Null:
+ break;
+ case NodeType::Scalar:
+ m_scalar.clear();
+ break;
+ case NodeType::Sequence:
+ reset_sequence();
+ break;
+ case NodeType::Map:
+ reset_map();
+ break;
+ case NodeType::Undefined:
+ assert(false);
+ break;
+ }
+}
+
+void node_data::set_tag(const std::string& tag) { m_tag = tag; }
+
+void node_data::set_style(EmitterStyle::value style) { m_style = style; }
+
+void node_data::set_null() {
+ m_isDefined = true;
+ m_type = NodeType::Null;
+}
+
+void node_data::set_scalar(const std::string& scalar) {
+ m_isDefined = true;
+ m_type = NodeType::Scalar;
+ m_scalar = scalar;
+}
+
+// size/iterator
+std::size_t node_data::size() const {
+ if (!m_isDefined)
+ return 0;
+
+ switch (m_type) {
+ case NodeType::Sequence:
+ compute_seq_size();
+ return m_seqSize;
+ case NodeType::Map:
+ compute_map_size();
+ return m_map.size() - m_undefinedPairs.size();
+ default:
+ return 0;
+ }
+ return 0;
+}
+
+void node_data::compute_seq_size() const {
+ while (m_seqSize < m_sequence.size() && m_sequence[m_seqSize]->is_defined())
+ m_seqSize++;
+}
+
+void node_data::compute_map_size() const {
+ auto it = m_undefinedPairs.begin();
+ while (it != m_undefinedPairs.end()) {
+ auto jt = std::next(it);
+ if (it->first->is_defined() && it->second->is_defined())
+ m_undefinedPairs.erase(it);
+ it = jt;
+ }
+}
+
+const_node_iterator node_data::begin() const {
+ if (!m_isDefined)
+ return {};
+
+ switch (m_type) {
+ case NodeType::Sequence:
+ return const_node_iterator(m_sequence.begin());
+ case NodeType::Map:
+ return const_node_iterator(m_map.begin(), m_map.end());
+ default:
+ return {};
+ }
+}
+
+node_iterator node_data::begin() {
+ if (!m_isDefined)
+ return {};
+
+ switch (m_type) {
+ case NodeType::Sequence:
+ return node_iterator(m_sequence.begin());
+ case NodeType::Map:
+ return node_iterator(m_map.begin(), m_map.end());
+ default:
+ return {};
+ }
+}
+
+const_node_iterator node_data::end() const {
+ if (!m_isDefined)
+ return {};
+
+ switch (m_type) {
+ case NodeType::Sequence:
+ return const_node_iterator(m_sequence.end());
+ case NodeType::Map:
+ return const_node_iterator(m_map.end(), m_map.end());
+ default:
+ return {};
+ }
+}
+
+node_iterator node_data::end() {
+ if (!m_isDefined)
+ return {};
+
+ switch (m_type) {
+ case NodeType::Sequence:
+ return node_iterator(m_sequence.end());
+ case NodeType::Map:
+ return node_iterator(m_map.end(), m_map.end());
+ default:
+ return {};
+ }
+}
+
+// sequence
+void node_data::push_back(node& node,
+ const shared_memory_holder& /* pMemory */) {
+ if (m_type == NodeType::Undefined || m_type == NodeType::Null) {
+ m_type = NodeType::Sequence;
+ reset_sequence();
+ }
+
+ if (m_type != NodeType::Sequence)
+ throw BadPushback();
+
+ m_sequence.push_back(&node);
+}
+
+void node_data::insert(node& key, node& value,
+ const shared_memory_holder& pMemory) {
+ switch (m_type) {
+ case NodeType::Map:
+ break;
+ case NodeType::Undefined:
+ case NodeType::Null:
+ case NodeType::Sequence:
+ convert_to_map(pMemory);
+ break;
+ case NodeType::Scalar:
+ throw BadSubscript(m_mark, key);
+ }
+
+ insert_map_pair(key, value);
+}
+
+// indexing
+node* node_data::get(node& key,
+ const shared_memory_holder& /* pMemory */) const {
+ if (m_type != NodeType::Map) {
+ return nullptr;
+ }
+
+ for (const auto& it : m_map) {
+ if (it.first->is(key))
+ return it.second;
+ }
+
+ return nullptr;
+}
+
+node& node_data::get(node& key, const shared_memory_holder& pMemory) {
+ switch (m_type) {
+ case NodeType::Map:
+ break;
+ case NodeType::Undefined:
+ case NodeType::Null:
+ case NodeType::Sequence:
+ convert_to_map(pMemory);
+ break;
+ case NodeType::Scalar:
+ throw BadSubscript(m_mark, key);
+ }
+
+ for (const auto& it : m_map) {
+ if (it.first->is(key))
+ return *it.second;
+ }
+
+ node& value = pMemory->create_node();
+ insert_map_pair(key, value);
+ return value;
+}
+
+bool node_data::remove(node& key, const shared_memory_holder& /* pMemory */) {
+ if (m_type != NodeType::Map)
+ return false;
+
+ for (auto it = m_undefinedPairs.begin(); it != m_undefinedPairs.end();) {
+ auto jt = std::next(it);
+ if (it->first->is(key))
+ m_undefinedPairs.erase(it);
+ it = jt;
+ }
+
+ auto it =
+ std::find_if(m_map.begin(), m_map.end(),
+ [&](std::pair<YAML::detail::node*, YAML::detail::node*> j) {
+ return (j.first->is(key));
+ });
+
+ if (it != m_map.end()) {
+ m_map.erase(it);
+ return true;
+ }
+
+ return false;
+}
+
+void node_data::reset_sequence() {
+ m_sequence.clear();
+ m_seqSize = 0;
+}
+
+void node_data::reset_map() {
+ m_map.clear();
+ m_undefinedPairs.clear();
+}
+
+void node_data::insert_map_pair(node& key, node& value) {
+ m_map.emplace_back(&key, &value);
+
+ if (!key.is_defined() || !value.is_defined())
+ m_undefinedPairs.emplace_back(&key, &value);
+}
+
+void node_data::convert_to_map(const shared_memory_holder& pMemory) {
+ switch (m_type) {
+ case NodeType::Undefined:
+ case NodeType::Null:
+ reset_map();
+ m_type = NodeType::Map;
+ break;
+ case NodeType::Sequence:
+ convert_sequence_to_map(pMemory);
+ break;
+ case NodeType::Map:
+ break;
+ case NodeType::Scalar:
+ assert(false);
+ break;
+ }
+}
+
+void node_data::convert_sequence_to_map(const shared_memory_holder& pMemory) {
+ assert(m_type == NodeType::Sequence);
+
+ reset_map();
+ for (std::size_t i = 0; i < m_sequence.size(); i++) {
+ std::stringstream stream;
+ stream << i;
+
+ node& key = pMemory->create_node();
+ key.set_scalar(stream.str());
+ insert_map_pair(key, *m_sequence[i]);
+ }
+
+ reset_sequence();
+ m_type = NodeType::Map;
+}
+} // namespace detail
+} // namespace YAML
--- /dev/null
+#include <cassert>
+
+#include "nodebuilder.h"
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/type.h"
+
+namespace YAML {
+struct Mark;
+
+NodeBuilder::NodeBuilder()
+ : m_pMemory(new detail::memory_holder),
+ m_pRoot(nullptr),
+ m_stack{},
+ m_anchors{},
+ m_keys{},
+ m_mapDepth(0) {
+ m_anchors.push_back(nullptr); // since the anchors start at 1
+}
+
+NodeBuilder::~NodeBuilder() = default;
+
+Node NodeBuilder::Root() {
+ if (!m_pRoot)
+ return Node();
+
+ return Node(*m_pRoot, m_pMemory);
+}
+
+void NodeBuilder::OnDocumentStart(const Mark&) {}
+
+void NodeBuilder::OnDocumentEnd() {}
+
+void NodeBuilder::OnNull(const Mark& mark, anchor_t anchor) {
+ detail::node& node = Push(mark, anchor);
+ node.set_null();
+ Pop();
+}
+
+void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor) {
+ detail::node& node = *m_anchors[anchor];
+ Push(node);
+ Pop();
+}
+
+void NodeBuilder::OnScalar(const Mark& mark, const std::string& tag,
+ anchor_t anchor, const std::string& value) {
+ detail::node& node = Push(mark, anchor);
+ node.set_scalar(value);
+ node.set_tag(tag);
+ Pop();
+}
+
+void NodeBuilder::OnSequenceStart(const Mark& mark, const std::string& tag,
+ anchor_t anchor, EmitterStyle::value style) {
+ detail::node& node = Push(mark, anchor);
+ node.set_tag(tag);
+ node.set_type(NodeType::Sequence);
+ node.set_style(style);
+}
+
+void NodeBuilder::OnSequenceEnd() { Pop(); }
+
+void NodeBuilder::OnMapStart(const Mark& mark, const std::string& tag,
+ anchor_t anchor, EmitterStyle::value style) {
+ detail::node& node = Push(mark, anchor);
+ node.set_type(NodeType::Map);
+ node.set_tag(tag);
+ node.set_style(style);
+ m_mapDepth++;
+}
+
+void NodeBuilder::OnMapEnd() {
+ assert(m_mapDepth > 0);
+ m_mapDepth--;
+ Pop();
+}
+
+detail::node& NodeBuilder::Push(const Mark& mark, anchor_t anchor) {
+ detail::node& node = m_pMemory->create_node();
+ node.set_mark(mark);
+ RegisterAnchor(anchor, node);
+ Push(node);
+ return node;
+}
+
+void NodeBuilder::Push(detail::node& node) {
+ const bool needsKey =
+ (!m_stack.empty() && m_stack.back()->type() == NodeType::Map &&
+ m_keys.size() < m_mapDepth);
+
+ m_stack.push_back(&node);
+ if (needsKey)
+ m_keys.emplace_back(&node, false);
+}
+
+void NodeBuilder::Pop() {
+ assert(!m_stack.empty());
+ if (m_stack.size() == 1) {
+ m_pRoot = m_stack[0];
+ m_stack.pop_back();
+ return;
+ }
+
+ detail::node& node = *m_stack.back();
+ m_stack.pop_back();
+
+ detail::node& collection = *m_stack.back();
+
+ if (collection.type() == NodeType::Sequence) {
+ collection.push_back(node, m_pMemory);
+ } else if (collection.type() == NodeType::Map) {
+ assert(!m_keys.empty());
+ PushedKey& key = m_keys.back();
+ if (key.second) {
+ collection.insert(*key.first, node, m_pMemory);
+ m_keys.pop_back();
+ } else {
+ key.second = true;
+ }
+ } else {
+ assert(false);
+ m_stack.clear();
+ }
+}
+
+void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) {
+ if (anchor) {
+ assert(anchor == m_anchors.size());
+ m_anchors.push_back(&node);
+ }
+}
+} // namespace YAML
--- /dev/null
+#ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <vector>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/node/ptr.h"
+
+namespace YAML {
+namespace detail {
+class node;
+} // namespace detail
+struct Mark;
+} // namespace YAML
+
+namespace YAML {
+class Node;
+
+class NodeBuilder : public EventHandler {
+ public:
+ NodeBuilder();
+ NodeBuilder(const NodeBuilder&) = delete;
+ NodeBuilder(NodeBuilder&&) = delete;
+ NodeBuilder& operator=(const NodeBuilder&) = delete;
+ NodeBuilder& operator=(NodeBuilder&&) = delete;
+ ~NodeBuilder() override;
+
+ Node Root();
+
+ void OnDocumentStart(const Mark& mark) override;
+ void OnDocumentEnd() override;
+
+ void OnNull(const Mark& mark, anchor_t anchor) override;
+ void OnAlias(const Mark& mark, anchor_t anchor) override;
+ void OnScalar(const Mark& mark, const std::string& tag,
+ anchor_t anchor, const std::string& value) override;
+
+ void OnSequenceStart(const Mark& mark, const std::string& tag,
+ anchor_t anchor, EmitterStyle::value style) override;
+ void OnSequenceEnd() override;
+
+ void OnMapStart(const Mark& mark, const std::string& tag,
+ anchor_t anchor, EmitterStyle::value style) override;
+ void OnMapEnd() override;
+
+ private:
+ detail::node& Push(const Mark& mark, anchor_t anchor);
+ void Push(detail::node& node);
+ void Pop();
+ void RegisterAnchor(anchor_t anchor, detail::node& node);
+
+ private:
+ detail::shared_memory_holder m_pMemory;
+ detail::node* m_pRoot;
+
+ using Nodes = std::vector<detail::node *>;
+ Nodes m_stack;
+ Nodes m_anchors;
+
+ using PushedKey = std::pair<detail::node*, bool>;
+ std::vector<PushedKey> m_keys;
+ std::size_t m_mapDepth;
+};
+} // namespace YAML
+
+#endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include "nodeevents.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/node/detail/node.h"
+#include "yaml-cpp/node/detail/node_iterator.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/node/type.h"
+
+namespace YAML {
+void NodeEvents::AliasManager::RegisterReference(const detail::node& node) {
+ m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor()));
+}
+
+anchor_t NodeEvents::AliasManager::LookupAnchor(
+ const detail::node& node) const {
+ auto it = m_anchorByIdentity.find(node.ref());
+ if (it == m_anchorByIdentity.end())
+ return 0;
+ return it->second;
+}
+
+NodeEvents::NodeEvents(const Node& node)
+ : m_pMemory(node.m_pMemory), m_root(node.m_pNode), m_refCount{} {
+ if (m_root)
+ Setup(*m_root);
+}
+
+void NodeEvents::Setup(const detail::node& node) {
+ int& refCount = m_refCount[node.ref()];
+ refCount++;
+ if (refCount > 1)
+ return;
+
+ if (node.type() == NodeType::Sequence) {
+ for (auto element : node)
+ Setup(*element);
+ } else if (node.type() == NodeType::Map) {
+ for (auto element : node) {
+ Setup(*element.first);
+ Setup(*element.second);
+ }
+ }
+}
+
+void NodeEvents::Emit(EventHandler& handler) {
+ AliasManager am;
+
+ handler.OnDocumentStart(Mark());
+ if (m_root)
+ Emit(*m_root, handler, am);
+ handler.OnDocumentEnd();
+}
+
+void NodeEvents::Emit(const detail::node& node, EventHandler& handler,
+ AliasManager& am) const {
+ anchor_t anchor = NullAnchor;
+ if (IsAliased(node)) {
+ anchor = am.LookupAnchor(node);
+ if (anchor) {
+ handler.OnAlias(Mark(), anchor);
+ return;
+ }
+
+ am.RegisterReference(node);
+ anchor = am.LookupAnchor(node);
+ }
+
+ switch (node.type()) {
+ case NodeType::Undefined:
+ break;
+ case NodeType::Null:
+ handler.OnNull(Mark(), anchor);
+ break;
+ case NodeType::Scalar:
+ handler.OnScalar(Mark(), node.tag(), anchor, node.scalar());
+ break;
+ case NodeType::Sequence:
+ handler.OnSequenceStart(Mark(), node.tag(), anchor, node.style());
+ for (auto element : node)
+ Emit(*element, handler, am);
+ handler.OnSequenceEnd();
+ break;
+ case NodeType::Map:
+ handler.OnMapStart(Mark(), node.tag(), anchor, node.style());
+ for (auto element : node) {
+ Emit(*element.first, handler, am);
+ Emit(*element.second, handler, am);
+ }
+ handler.OnMapEnd();
+ break;
+ }
+}
+
+bool NodeEvents::IsAliased(const detail::node& node) const {
+ auto it = m_refCount.find(node.ref());
+ return it != m_refCount.end() && it->second > 1;
+}
+} // namespace YAML
--- /dev/null
+#ifndef NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <map>
+#include <vector>
+
+#include "yaml-cpp/anchor.h"
+#include "yaml-cpp/node/ptr.h"
+
+namespace YAML {
+namespace detail {
+class node;
+} // namespace detail
+} // namespace YAML
+
+namespace YAML {
+class EventHandler;
+class Node;
+
+class NodeEvents {
+ public:
+ explicit NodeEvents(const Node& node);
+ NodeEvents(const NodeEvents&) = delete;
+ NodeEvents(NodeEvents&&) = delete;
+ NodeEvents& operator=(const NodeEvents&) = delete;
+ NodeEvents& operator=(NodeEvents&&) = delete;
+
+ void Emit(EventHandler& handler);
+
+ private:
+ class AliasManager {
+ public:
+ AliasManager() : m_anchorByIdentity{}, m_curAnchor(0) {}
+
+ void RegisterReference(const detail::node& node);
+ anchor_t LookupAnchor(const detail::node& node) const;
+
+ private:
+ anchor_t _CreateNewAnchor() { return ++m_curAnchor; }
+
+ private:
+ using AnchorByIdentity = std::map<const detail::node_ref*, anchor_t>;
+ AnchorByIdentity m_anchorByIdentity;
+
+ anchor_t m_curAnchor;
+ };
+
+ void Setup(const detail::node& node);
+ void Emit(const detail::node& node, EventHandler& handler,
+ AliasManager& am) const;
+ bool IsAliased(const detail::node& node) const;
+
+ private:
+ detail::shared_memory_holder m_pMemory;
+ detail::node* m_root;
+
+ using RefCount = std::map<const detail::node_ref*, int>;
+ RefCount m_refCount;
+};
+} // namespace YAML
+
+#endif // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include "yaml-cpp/null.h"
+
+namespace YAML {
+_Null Null;
+
+bool IsNullString(const std::string& str) {
+ return str.empty() || str == "~" || str == "null" || str == "Null" ||
+ str == "NULL";
+}
+} // namespace YAML
--- /dev/null
+#include "yaml-cpp/ostream_wrapper.h"
+
+#include <algorithm>
+#include <cstring>
+#include <iostream>
+
+namespace YAML {
+ostream_wrapper::ostream_wrapper()
+ : m_buffer(1, '\0'),
+ m_pStream(nullptr),
+ m_pos(0),
+ m_row(0),
+ m_col(0),
+ m_comment(false) {}
+
+ostream_wrapper::ostream_wrapper(std::ostream& stream)
+ : m_buffer{},
+ m_pStream(&stream),
+ m_pos(0),
+ m_row(0),
+ m_col(0),
+ m_comment(false) {}
+
+ostream_wrapper::~ostream_wrapper() = default;
+
+void ostream_wrapper::write(const std::string& str) {
+ if (m_pStream) {
+ m_pStream->write(str.c_str(), str.size());
+ } else {
+ m_buffer.resize(std::max(m_buffer.size(), m_pos + str.size() + 1));
+ std::copy(str.begin(), str.end(), m_buffer.begin() + m_pos);
+ }
+
+ for (char ch : str) {
+ update_pos(ch);
+ }
+}
+
+void ostream_wrapper::write(const char* str, std::size_t size) {
+ if (m_pStream) {
+ m_pStream->write(str, size);
+ } else {
+ m_buffer.resize(std::max(m_buffer.size(), m_pos + size + 1));
+ std::copy(str, str + size, m_buffer.begin() + m_pos);
+ }
+
+ for (std::size_t i = 0; i < size; i++) {
+ update_pos(str[i]);
+ }
+}
+
+void ostream_wrapper::update_pos(char ch) {
+ m_pos++;
+ m_col++;
+
+ if (ch == '\n') {
+ m_row++;
+ m_col = 0;
+ m_comment = false;
+ }
+}
+} // namespace YAML
--- /dev/null
+#include "yaml-cpp/node/parse.h"
+
+#include <fstream>
+#include <sstream>
+
+#include "nodebuilder.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/parser.h"
+
+namespace YAML {
+Node Load(const std::string& input) {
+ std::stringstream stream(input);
+ return Load(stream);
+}
+
+Node Load(const char* input) {
+ std::stringstream stream(input);
+ return Load(stream);
+}
+
+Node Load(std::istream& input) {
+ Parser parser(input);
+ NodeBuilder builder;
+ if (!parser.HandleNextDocument(builder)) {
+ return Node();
+ }
+
+ return builder.Root();
+}
+
+Node LoadFile(const std::string& filename) {
+ std::ifstream fin(filename);
+ if (!fin) {
+ throw BadFile(filename);
+ }
+ return Load(fin);
+}
+
+std::vector<Node> LoadAll(const std::string& input) {
+ std::stringstream stream(input);
+ return LoadAll(stream);
+}
+
+std::vector<Node> LoadAll(const char* input) {
+ std::stringstream stream(input);
+ return LoadAll(stream);
+}
+
+std::vector<Node> LoadAll(std::istream& input) {
+ std::vector<Node> docs;
+
+ Parser parser(input);
+ while (true) {
+ NodeBuilder builder;
+ if (!parser.HandleNextDocument(builder)) {
+ break;
+ }
+ docs.push_back(builder.Root());
+ }
+
+ return docs;
+}
+
+std::vector<Node> LoadAllFromFile(const std::string& filename) {
+ std::ifstream fin(filename);
+ if (!fin) {
+ throw BadFile(filename);
+ }
+ return LoadAll(fin);
+}
+} // namespace YAML
--- /dev/null
+#include <cstdio>
+#include <sstream>
+
+#include "directives.h" // IWYU pragma: keep
+#include "scanner.h" // IWYU pragma: keep
+#include "singledocparser.h"
+#include "token.h"
+#include "yaml-cpp/exceptions.h" // IWYU pragma: keep
+#include "yaml-cpp/parser.h"
+
+namespace YAML {
+class EventHandler;
+
+Parser::Parser() : m_pScanner{}, m_pDirectives{} {}
+
+Parser::Parser(std::istream& in) : Parser() { Load(in); }
+
+Parser::~Parser() = default;
+
+Parser::operator bool() const { return m_pScanner && !m_pScanner->empty(); }
+
+void Parser::Load(std::istream& in) {
+ m_pScanner.reset(new Scanner(in));
+ m_pDirectives.reset(new Directives);
+}
+
+bool Parser::HandleNextDocument(EventHandler& eventHandler) {
+ if (!m_pScanner)
+ return false;
+
+ ParseDirectives();
+ if (m_pScanner->empty()) {
+ return false;
+ }
+
+ SingleDocParser sdp(*m_pScanner, *m_pDirectives);
+ sdp.HandleDocument(eventHandler);
+ return true;
+}
+
+void Parser::ParseDirectives() {
+ bool readDirective = false;
+
+ while (!m_pScanner->empty()) {
+ Token& token = m_pScanner->peek();
+ if (token.type != Token::DIRECTIVE) {
+ break;
+ }
+
+ // we keep the directives from the last document if none are specified;
+ // but if any directives are specific, then we reset them
+ if (!readDirective) {
+ m_pDirectives.reset(new Directives);
+ }
+
+ readDirective = true;
+ HandleDirective(token);
+ m_pScanner->pop();
+ }
+}
+
+void Parser::HandleDirective(const Token& token) {
+ if (token.value == "YAML") {
+ HandleYamlDirective(token);
+ } else if (token.value == "TAG") {
+ HandleTagDirective(token);
+ }
+}
+
+void Parser::HandleYamlDirective(const Token& token) {
+ if (token.params.size() != 1) {
+ throw ParserException(token.mark, ErrorMsg::YAML_DIRECTIVE_ARGS);
+ }
+
+ if (!m_pDirectives->version.isDefault) {
+ throw ParserException(token.mark, ErrorMsg::REPEATED_YAML_DIRECTIVE);
+ }
+
+ std::stringstream str(token.params[0]);
+ str >> m_pDirectives->version.major;
+ str.get();
+ str >> m_pDirectives->version.minor;
+ if (!str || str.peek() != EOF) {
+ throw ParserException(
+ token.mark, std::string(ErrorMsg::YAML_VERSION) + token.params[0]);
+ }
+
+ if (m_pDirectives->version.major > 1) {
+ throw ParserException(token.mark, ErrorMsg::YAML_MAJOR_VERSION);
+ }
+
+ m_pDirectives->version.isDefault = false;
+ // TODO: warning on major == 1, minor > 2?
+}
+
+void Parser::HandleTagDirective(const Token& token) {
+ if (token.params.size() != 2)
+ throw ParserException(token.mark, ErrorMsg::TAG_DIRECTIVE_ARGS);
+
+ const std::string& handle = token.params[0];
+ const std::string& prefix = token.params[1];
+ if (m_pDirectives->tags.find(handle) != m_pDirectives->tags.end()) {
+ throw ParserException(token.mark, ErrorMsg::REPEATED_TAG_DIRECTIVE);
+ }
+
+ m_pDirectives->tags[handle] = prefix;
+}
+
+void Parser::PrintTokens(std::ostream& out) {
+ if (!m_pScanner) {
+ return;
+ }
+
+ while (!m_pScanner->empty()) {
+ out << m_pScanner->peek() << "\n";
+ m_pScanner->pop();
+ }
+}
+} // namespace YAML
--- /dev/null
+#ifndef PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstddef>
+#include <cstdlib>
+#include <memory>
+#include <vector>
+
+namespace YAML {
+
+// TODO: This class is no longer needed
+template <typename T>
+class ptr_vector {
+ public:
+ ptr_vector() : m_data{} {}
+ ptr_vector(const ptr_vector&) = delete;
+ ptr_vector(ptr_vector&&) = default;
+ ptr_vector& operator=(const ptr_vector&) = delete;
+ ptr_vector& operator=(ptr_vector&&) = default;
+
+ void clear() { m_data.clear(); }
+
+ std::size_t size() const { return m_data.size(); }
+ bool empty() const { return m_data.empty(); }
+
+ void push_back(std::unique_ptr<T>&& t) { m_data.push_back(std::move(t)); }
+ T& operator[](std::size_t i) { return *m_data[i]; }
+ const T& operator[](std::size_t i) const { return *m_data[i]; }
+
+ T& back() { return *(m_data.back().get()); }
+
+ const T& back() const { return *(m_data.back().get()); }
+
+ private:
+ std::vector<std::unique_ptr<T>> m_data;
+};
+} // namespace YAML
+
+#endif // PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include "regex_yaml.h"
+
+namespace YAML {
+// constructors
+
+RegEx::RegEx(REGEX_OP op) : m_op(op), m_a(0), m_z(0), m_params{} {}
+RegEx::RegEx() : RegEx(REGEX_EMPTY) {}
+
+RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch), m_z(0), m_params{} {}
+
+RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z), m_params{} {}
+
+RegEx::RegEx(const std::string& str, REGEX_OP op)
+ : m_op(op), m_a(0), m_z(0), m_params(str.begin(), str.end()) {}
+
+// combination constructors
+RegEx operator!(const RegEx& ex) {
+ RegEx ret(REGEX_NOT);
+ ret.m_params.push_back(ex);
+ return ret;
+}
+
+RegEx operator|(const RegEx& ex1, const RegEx& ex2) {
+ RegEx ret(REGEX_OR);
+ ret.m_params.push_back(ex1);
+ ret.m_params.push_back(ex2);
+ return ret;
+}
+
+RegEx operator&(const RegEx& ex1, const RegEx& ex2) {
+ RegEx ret(REGEX_AND);
+ ret.m_params.push_back(ex1);
+ ret.m_params.push_back(ex2);
+ return ret;
+}
+
+RegEx operator+(const RegEx& ex1, const RegEx& ex2) {
+ RegEx ret(REGEX_SEQ);
+ ret.m_params.push_back(ex1);
+ ret.m_params.push_back(ex2);
+ return ret;
+}
+} // namespace YAML
--- /dev/null
+#ifndef REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include <vector>
+
+#include "yaml-cpp/dll.h"
+
+namespace YAML {
+class Stream;
+
+enum REGEX_OP {
+ REGEX_EMPTY,
+ REGEX_MATCH,
+ REGEX_RANGE,
+ REGEX_OR,
+ REGEX_AND,
+ REGEX_NOT,
+ REGEX_SEQ
+};
+
+// simplified regular expressions
+// . Only straightforward matches (no repeated characters)
+// . Only matches from start of string
+class YAML_CPP_API RegEx {
+ public:
+ RegEx();
+ explicit RegEx(char ch);
+ RegEx(char a, char z);
+ RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
+ ~RegEx() = default;
+
+ friend YAML_CPP_API RegEx operator!(const RegEx& ex);
+ friend YAML_CPP_API RegEx operator|(const RegEx& ex1, const RegEx& ex2);
+ friend YAML_CPP_API RegEx operator&(const RegEx& ex1, const RegEx& ex2);
+ friend YAML_CPP_API RegEx operator+(const RegEx& ex1, const RegEx& ex2);
+
+ bool Matches(char ch) const;
+ bool Matches(const std::string& str) const;
+ bool Matches(const Stream& in) const;
+ template <typename Source>
+ bool Matches(const Source& source) const;
+
+ int Match(const std::string& str) const;
+ int Match(const Stream& in) const;
+ template <typename Source>
+ int Match(const Source& source) const;
+
+ private:
+ explicit RegEx(REGEX_OP op);
+
+ template <typename Source>
+ bool IsValidSource(const Source& source) const;
+ template <typename Source>
+ int MatchUnchecked(const Source& source) const;
+
+ template <typename Source>
+ int MatchOpEmpty(const Source& source) const;
+ template <typename Source>
+ int MatchOpMatch(const Source& source) const;
+ template <typename Source>
+ int MatchOpRange(const Source& source) const;
+ template <typename Source>
+ int MatchOpOr(const Source& source) const;
+ template <typename Source>
+ int MatchOpAnd(const Source& source) const;
+ template <typename Source>
+ int MatchOpNot(const Source& source) const;
+ template <typename Source>
+ int MatchOpSeq(const Source& source) const;
+
+ private:
+ REGEX_OP m_op;
+ char m_a{};
+ char m_z{};
+ std::vector<RegEx> m_params;
+};
+} // namespace YAML
+
+#include "regeximpl.h"
+
+#endif // REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "stream.h"
+#include "streamcharsource.h"
+#include "stringsource.h"
+
+namespace YAML {
+// query matches
+inline bool RegEx::Matches(char ch) const {
+ std::string str;
+ str += ch;
+ return Matches(str);
+}
+
+inline bool RegEx::Matches(const std::string& str) const {
+ return Match(str) >= 0;
+}
+
+inline bool RegEx::Matches(const Stream& in) const { return Match(in) >= 0; }
+
+template <typename Source>
+inline bool RegEx::Matches(const Source& source) const {
+ return Match(source) >= 0;
+}
+
+// Match
+// . Matches the given string against this regular expression.
+// . Returns the number of characters matched.
+// . Returns -1 if no characters were matched (the reason for
+// not returning zero is that we may have an empty regex
+// which is ALWAYS successful at matching zero characters).
+// . REMEMBER that we only match from the start of the buffer!
+inline int RegEx::Match(const std::string& str) const {
+ StringCharSource source(str.c_str(), str.size());
+ return Match(source);
+}
+
+inline int RegEx::Match(const Stream& in) const {
+ StreamCharSource source(in);
+ return Match(source);
+}
+
+template <typename Source>
+inline bool RegEx::IsValidSource(const Source& source) const {
+ return source;
+}
+
+template <>
+inline bool RegEx::IsValidSource<StringCharSource>(
+ const StringCharSource& source) const {
+ switch (m_op) {
+ case REGEX_MATCH:
+ case REGEX_RANGE:
+ return source;
+ default:
+ return true;
+ }
+}
+
+template <typename Source>
+inline int RegEx::Match(const Source& source) const {
+ return IsValidSource(source) ? MatchUnchecked(source) : -1;
+}
+
+template <typename Source>
+inline int RegEx::MatchUnchecked(const Source& source) const {
+ switch (m_op) {
+ case REGEX_EMPTY:
+ return MatchOpEmpty(source);
+ case REGEX_MATCH:
+ return MatchOpMatch(source);
+ case REGEX_RANGE:
+ return MatchOpRange(source);
+ case REGEX_OR:
+ return MatchOpOr(source);
+ case REGEX_AND:
+ return MatchOpAnd(source);
+ case REGEX_NOT:
+ return MatchOpNot(source);
+ case REGEX_SEQ:
+ return MatchOpSeq(source);
+ }
+
+ return -1;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Operators
+// Note: the convention MatchOp*<Source> is that we can assume
+// IsSourceValid(source).
+// So we do all our checks *before* we call these functions
+
+// EmptyOperator
+template <typename Source>
+inline int RegEx::MatchOpEmpty(const Source& source) const {
+ return source[0] == Stream::eof() ? 0 : -1;
+}
+
+template <>
+inline int RegEx::MatchOpEmpty<StringCharSource>(
+ const StringCharSource& source) const {
+ return !source ? 0 : -1; // the empty regex only is successful on the empty
+ // string
+}
+
+// MatchOperator
+template <typename Source>
+inline int RegEx::MatchOpMatch(const Source& source) const {
+ if (source[0] != m_a)
+ return -1;
+ return 1;
+}
+
+// RangeOperator
+template <typename Source>
+inline int RegEx::MatchOpRange(const Source& source) const {
+ if (m_a > source[0] || m_z < source[0])
+ return -1;
+ return 1;
+}
+
+// OrOperator
+template <typename Source>
+inline int RegEx::MatchOpOr(const Source& source) const {
+ for (const RegEx& param : m_params) {
+ int n = param.MatchUnchecked(source);
+ if (n >= 0)
+ return n;
+ }
+ return -1;
+}
+
+// AndOperator
+// Note: 'AND' is a little funny, since we may be required to match things
+// of different lengths. If we find a match, we return the length of
+// the FIRST entry on the list.
+template <typename Source>
+inline int RegEx::MatchOpAnd(const Source& source) const {
+ int first = -1;
+ for (std::size_t i = 0; i < m_params.size(); i++) {
+ int n = m_params[i].MatchUnchecked(source);
+ if (n == -1)
+ return -1;
+ if (i == 0)
+ first = n;
+ }
+ return first;
+}
+
+// NotOperator
+template <typename Source>
+inline int RegEx::MatchOpNot(const Source& source) const {
+ if (m_params.empty())
+ return -1;
+ if (m_params[0].MatchUnchecked(source) >= 0)
+ return -1;
+ return 1;
+}
+
+// SeqOperator
+template <typename Source>
+inline int RegEx::MatchOpSeq(const Source& source) const {
+ int offset = 0;
+ for (const RegEx& param : m_params) {
+ int n = param.Match(source + offset); // note Match, not
+ // MatchUnchecked because we
+ // need to check validity after
+ // the offset
+ if (n == -1)
+ return -1;
+ offset += n;
+ }
+
+ return offset;
+}
+} // namespace YAML
+
+#endif // REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include <cassert>
+#include <memory>
+
+#include "exp.h"
+#include "scanner.h"
+#include "token.h"
+#include "yaml-cpp/exceptions.h" // IWYU pragma: keep
+
+namespace YAML {
+Scanner::Scanner(std::istream& in)
+ : INPUT(in),
+ m_tokens{},
+ m_startedStream(false),
+ m_endedStream(false),
+ m_simpleKeyAllowed(false),
+ m_canBeJSONFlow(false),
+ m_simpleKeys{},
+ m_indents{},
+ m_indentRefs{},
+ m_flows{} {}
+
+Scanner::~Scanner() = default;
+
+bool Scanner::empty() {
+ EnsureTokensInQueue();
+ return m_tokens.empty();
+}
+
+void Scanner::pop() {
+ EnsureTokensInQueue();
+ if (!m_tokens.empty())
+ m_tokens.pop();
+}
+
+Token& Scanner::peek() {
+ EnsureTokensInQueue();
+ assert(!m_tokens.empty()); // should we be asserting here? I mean, we really
+ // just be checking
+ // if it's empty before peeking.
+
+#if 0
+ static Token *pLast = 0;
+ if(pLast != &m_tokens.front())
+ std::cerr << "peek: " << m_tokens.front() << "\n";
+ pLast = &m_tokens.front();
+#endif
+
+ return m_tokens.front();
+}
+
+Mark Scanner::mark() const { return INPUT.mark(); }
+
+void Scanner::EnsureTokensInQueue() {
+ while (true) {
+ if (!m_tokens.empty()) {
+ Token& token = m_tokens.front();
+
+ // if this guy's valid, then we're done
+ if (token.status == Token::VALID) {
+ return;
+ }
+
+ // here's where we clean up the impossible tokens
+ if (token.status == Token::INVALID) {
+ m_tokens.pop();
+ continue;
+ }
+
+ // note: what's left are the unverified tokens
+ }
+
+ // no token? maybe we've actually finished
+ if (m_endedStream) {
+ return;
+ }
+
+ // no? then scan...
+ ScanNextToken();
+ }
+}
+
+void Scanner::ScanNextToken() {
+ if (m_endedStream) {
+ return;
+ }
+
+ if (!m_startedStream) {
+ return StartStream();
+ }
+
+ // get rid of whitespace, etc. (in between tokens it should be irrelevant)
+ ScanToNextToken();
+
+ // maybe need to end some blocks
+ PopIndentToHere();
+
+ // *****
+ // And now branch based on the next few characters!
+ // *****
+
+ // end of stream
+ if (!INPUT) {
+ return EndStream();
+ }
+
+ if (INPUT.column() == 0 && INPUT.peek() == Keys::Directive) {
+ return ScanDirective();
+ }
+
+ // document token
+ if (INPUT.column() == 0 && Exp::DocStart().Matches(INPUT)) {
+ return ScanDocStart();
+ }
+
+ if (INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT)) {
+ return ScanDocEnd();
+ }
+
+ // flow start/end/entry
+ if (INPUT.peek() == Keys::FlowSeqStart ||
+ INPUT.peek() == Keys::FlowMapStart) {
+ return ScanFlowStart();
+ }
+
+ if (INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd) {
+ return ScanFlowEnd();
+ }
+
+ if (INPUT.peek() == Keys::FlowEntry) {
+ return ScanFlowEntry();
+ }
+
+ // block/map stuff
+ if (Exp::BlockEntry().Matches(INPUT)) {
+ return ScanBlockEntry();
+ }
+
+ if ((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT)) {
+ return ScanKey();
+ }
+
+ if (GetValueRegex().Matches(INPUT)) {
+ return ScanValue();
+ }
+
+ // alias/anchor
+ if (INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor) {
+ return ScanAnchorOrAlias();
+ }
+
+ // tag
+ if (INPUT.peek() == Keys::Tag) {
+ return ScanTag();
+ }
+
+ // special scalars
+ if (InBlockContext() && (INPUT.peek() == Keys::LiteralScalar ||
+ INPUT.peek() == Keys::FoldedScalar)) {
+ return ScanBlockScalar();
+ }
+
+ if (INPUT.peek() == '\'' || INPUT.peek() == '\"') {
+ return ScanQuotedScalar();
+ }
+
+ // plain scalars
+ if ((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow())
+ .Matches(INPUT)) {
+ return ScanPlainScalar();
+ }
+
+ // don't know what it is!
+ throw ParserException(INPUT.mark(), ErrorMsg::UNKNOWN_TOKEN);
+}
+
+void Scanner::ScanToNextToken() {
+ while (true) {
+ // first eat whitespace
+ while (INPUT && IsWhitespaceToBeEaten(INPUT.peek())) {
+ if (InBlockContext() && Exp::Tab().Matches(INPUT)) {
+ m_simpleKeyAllowed = false;
+ }
+ INPUT.eat(1);
+ }
+
+ // then eat a comment
+ if (Exp::Comment().Matches(INPUT)) {
+ // eat until line break
+ while (INPUT && !Exp::Break().Matches(INPUT)) {
+ INPUT.eat(1);
+ }
+ }
+
+ // if it's NOT a line break, then we're done!
+ if (!Exp::Break().Matches(INPUT)) {
+ break;
+ }
+
+ // otherwise, let's eat the line break and keep going
+ int n = Exp::Break().Match(INPUT);
+ INPUT.eat(n);
+
+ // oh yeah, and let's get rid of that simple key
+ InvalidateSimpleKey();
+
+ // new line - we may be able to accept a simple key now
+ if (InBlockContext()) {
+ m_simpleKeyAllowed = true;
+ }
+ }
+}
+
+///////////////////////////////////////////////////////////////////////
+// Misc. helpers
+
+// IsWhitespaceToBeEaten
+// . We can eat whitespace if it's a space or tab
+// . Note: originally tabs in block context couldn't be eaten
+// "where a simple key could be allowed
+// (i.e., not at the beginning of a line, or following '-', '?', or
+// ':')"
+// I think this is wrong, since tabs can be non-content whitespace; it's just
+// that they can't contribute to indentation, so once you've seen a tab in a
+// line, you can't start a simple key
+bool Scanner::IsWhitespaceToBeEaten(char ch) {
+ if (ch == ' ') {
+ return true;
+ }
+
+ if (ch == '\t') {
+ return true;
+ }
+
+ return false;
+}
+
+const RegEx& Scanner::GetValueRegex() const {
+ if (InBlockContext()) {
+ return Exp::Value();
+ }
+
+ return m_canBeJSONFlow ? Exp::ValueInJSONFlow() : Exp::ValueInFlow();
+}
+
+void Scanner::StartStream() {
+ m_startedStream = true;
+ m_simpleKeyAllowed = true;
+ std::unique_ptr<IndentMarker> pIndent(
+ new IndentMarker(-1, IndentMarker::NONE));
+ m_indentRefs.push_back(std::move(pIndent));
+ m_indents.push(&m_indentRefs.back());
+}
+
+void Scanner::EndStream() {
+ // force newline
+ if (INPUT.column() > 0) {
+ INPUT.ResetColumn();
+ }
+
+ PopAllIndents();
+ PopAllSimpleKeys();
+
+ m_simpleKeyAllowed = false;
+ m_endedStream = true;
+}
+
+Token* Scanner::PushToken(Token::TYPE type) {
+ m_tokens.push(Token(type, INPUT.mark()));
+ return &m_tokens.back();
+}
+
+Token::TYPE Scanner::GetStartTokenFor(IndentMarker::INDENT_TYPE type) const {
+ switch (type) {
+ case IndentMarker::SEQ:
+ return Token::BLOCK_SEQ_START;
+ case IndentMarker::MAP:
+ return Token::BLOCK_MAP_START;
+ case IndentMarker::NONE:
+ assert(false);
+ break;
+ }
+ assert(false);
+ throw std::runtime_error("yaml-cpp: internal error, invalid indent type");
+}
+
+Scanner::IndentMarker* Scanner::PushIndentTo(int column,
+ IndentMarker::INDENT_TYPE type) {
+ // are we in flow?
+ if (InFlowContext()) {
+ return nullptr;
+ }
+
+ std::unique_ptr<IndentMarker> pIndent(new IndentMarker(column, type));
+ IndentMarker& indent = *pIndent;
+ const IndentMarker& lastIndent = *m_indents.top();
+
+ // is this actually an indentation?
+ if (indent.column < lastIndent.column) {
+ return nullptr;
+ }
+ if (indent.column == lastIndent.column &&
+ !(indent.type == IndentMarker::SEQ &&
+ lastIndent.type == IndentMarker::MAP)) {
+ return nullptr;
+ }
+
+ // push a start token
+ indent.pStartToken = PushToken(GetStartTokenFor(type));
+
+ // and then the indent
+ m_indents.push(&indent);
+ m_indentRefs.push_back(std::move(pIndent));
+ return &m_indentRefs.back();
+}
+
+void Scanner::PopIndentToHere() {
+ // are we in flow?
+ if (InFlowContext()) {
+ return;
+ }
+
+ // now pop away
+ while (!m_indents.empty()) {
+ const IndentMarker& indent = *m_indents.top();
+ if (indent.column < INPUT.column()) {
+ break;
+ }
+ if (indent.column == INPUT.column() &&
+ !(indent.type == IndentMarker::SEQ &&
+ !Exp::BlockEntry().Matches(INPUT))) {
+ break;
+ }
+
+ PopIndent();
+ }
+
+ while (!m_indents.empty() &&
+ m_indents.top()->status == IndentMarker::INVALID) {
+ PopIndent();
+ }
+}
+
+void Scanner::PopAllIndents() {
+ // are we in flow?
+ if (InFlowContext()) {
+ return;
+ }
+
+ // now pop away
+ while (!m_indents.empty()) {
+ const IndentMarker& indent = *m_indents.top();
+ if (indent.type == IndentMarker::NONE) {
+ break;
+ }
+
+ PopIndent();
+ }
+}
+
+void Scanner::PopIndent() {
+ const IndentMarker& indent = *m_indents.top();
+ m_indents.pop();
+
+ if (indent.status != IndentMarker::VALID) {
+ InvalidateSimpleKey();
+ return;
+ }
+
+ if (indent.type == IndentMarker::SEQ) {
+ m_tokens.push(Token(Token::BLOCK_SEQ_END, INPUT.mark()));
+ } else if (indent.type == IndentMarker::MAP) {
+ m_tokens.push(Token(Token::BLOCK_MAP_END, INPUT.mark()));
+ }
+}
+
+int Scanner::GetTopIndent() const {
+ if (m_indents.empty()) {
+ return 0;
+ }
+ return m_indents.top()->column;
+}
+
+void Scanner::ThrowParserException(const std::string& msg) const {
+ Mark mark = Mark::null_mark();
+ if (!m_tokens.empty()) {
+ const Token& token = m_tokens.front();
+ mark = token.mark;
+ }
+ throw ParserException(mark, msg);
+}
+} // namespace YAML
--- /dev/null
+#ifndef SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstddef>
+#include <ios>
+#include <queue>
+#include <stack>
+#include <string>
+
+#include "ptr_vector.h"
+#include "stream.h"
+#include "token.h"
+#include "yaml-cpp/mark.h"
+
+namespace YAML {
+class Node;
+class RegEx;
+
+/**
+ * A scanner transforms a stream of characters into a stream of tokens.
+ */
+class Scanner {
+ public:
+ explicit Scanner(std::istream &in);
+ ~Scanner();
+
+ /** Returns true if there are no more tokens to be read. */
+ bool empty();
+
+ /** Removes the next token in the queue. */
+ void pop();
+
+ /** Returns, but does not remove, the next token in the queue. */
+ Token &peek();
+
+ /** Returns the current mark in the input stream. */
+ Mark mark() const;
+
+ private:
+ struct IndentMarker {
+ enum INDENT_TYPE { MAP, SEQ, NONE };
+ enum STATUS { VALID, INVALID, UNKNOWN };
+ IndentMarker(int column_, INDENT_TYPE type_)
+ : column(column_), type(type_), status(VALID), pStartToken(nullptr) {}
+
+ int column;
+ INDENT_TYPE type;
+ STATUS status;
+ Token *pStartToken;
+ };
+
+ enum FLOW_MARKER { FLOW_MAP, FLOW_SEQ };
+
+ private:
+ // scanning
+
+ /**
+ * Scans until there's a valid token at the front of the queue, or the queue
+ * is empty. The state can be checked by {@link #empty}, and the next token
+ * retrieved by {@link #peek}.
+ */
+ void EnsureTokensInQueue();
+
+ /**
+ * The main scanning function; this method branches out to scan whatever the
+ * next token should be.
+ */
+ void ScanNextToken();
+
+ /** Eats the input stream until it reaches the next token-like thing. */
+ void ScanToNextToken();
+
+ /** Sets the initial conditions for starting a stream. */
+ void StartStream();
+
+ /** Closes out the stream, finish up, etc. */
+ void EndStream();
+
+ Token *PushToken(Token::TYPE type);
+
+ bool InFlowContext() const { return !m_flows.empty(); }
+ bool InBlockContext() const { return m_flows.empty(); }
+ std::size_t GetFlowLevel() const { return m_flows.size(); }
+
+ Token::TYPE GetStartTokenFor(IndentMarker::INDENT_TYPE type) const;
+
+ /**
+ * Pushes an indentation onto the stack, and enqueues the proper token
+ * (sequence start or mapping start).
+ *
+ * @return the indent marker it generates (if any).
+ */
+ IndentMarker *PushIndentTo(int column, IndentMarker::INDENT_TYPE type);
+
+ /**
+ * Pops indentations off the stack until it reaches the current indentation
+ * level, and enqueues the proper token each time. Then pops all invalid
+ * indentations off.
+ */
+ void PopIndentToHere();
+
+ /**
+ * Pops all indentations (except for the base empty one) off the stack, and
+ * enqueues the proper token each time.
+ */
+ void PopAllIndents();
+
+ /** Pops a single indent, pushing the proper token. */
+ void PopIndent();
+ int GetTopIndent() const;
+
+ // checking input
+ bool CanInsertPotentialSimpleKey() const;
+ bool ExistsActiveSimpleKey() const;
+ void InsertPotentialSimpleKey();
+ void InvalidateSimpleKey();
+ bool VerifySimpleKey();
+ void PopAllSimpleKeys();
+
+ /**
+ * Throws a ParserException with the current token location (if available),
+ * and does not parse any more tokens.
+ */
+ void ThrowParserException(const std::string &msg) const;
+
+ bool IsWhitespaceToBeEaten(char ch);
+
+ /**
+ * Returns the appropriate regex to check if the next token is a value token.
+ */
+ const RegEx &GetValueRegex() const;
+
+ struct SimpleKey {
+ SimpleKey(const Mark &mark_, std::size_t flowLevel_);
+
+ void Validate();
+ void Invalidate();
+
+ Mark mark;
+ std::size_t flowLevel;
+ IndentMarker *pIndent;
+ Token *pMapStart, *pKey;
+ };
+
+ // and the tokens
+ void ScanDirective();
+ void ScanDocStart();
+ void ScanDocEnd();
+ void ScanBlockSeqStart();
+ void ScanBlockMapSTart();
+ void ScanBlockEnd();
+ void ScanBlockEntry();
+ void ScanFlowStart();
+ void ScanFlowEnd();
+ void ScanFlowEntry();
+ void ScanKey();
+ void ScanValue();
+ void ScanAnchorOrAlias();
+ void ScanTag();
+ void ScanPlainScalar();
+ void ScanQuotedScalar();
+ void ScanBlockScalar();
+
+ private:
+ // the stream
+ Stream INPUT;
+
+ // the output (tokens)
+ std::queue<Token> m_tokens;
+
+ // state info
+ bool m_startedStream, m_endedStream;
+ bool m_simpleKeyAllowed;
+ bool m_canBeJSONFlow;
+ std::stack<SimpleKey> m_simpleKeys;
+ std::stack<IndentMarker *> m_indents;
+ ptr_vector<IndentMarker> m_indentRefs; // for "garbage collection"
+ std::stack<FLOW_MARKER> m_flows;
+};
+}
+
+#endif // SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include "scanscalar.h"
+
+#include <algorithm>
+
+#include "exp.h"
+#include "regeximpl.h"
+#include "stream.h"
+#include "yaml-cpp/exceptions.h" // IWYU pragma: keep
+
+namespace YAML {
+// ScanScalar
+// . This is where the scalar magic happens.
+//
+// . We do the scanning in three phases:
+// 1. Scan until newline
+// 2. Eat newline
+// 3. Scan leading blanks.
+//
+// . Depending on the parameters given, we store or stop
+// and different places in the above flow.
+std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) {
+ bool foundNonEmptyLine = false;
+ bool pastOpeningBreak = (params.fold == FOLD_FLOW);
+ bool emptyLine = false, moreIndented = false;
+ int foldedNewlineCount = 0;
+ bool foldedNewlineStartedMoreIndented = false;
+ std::size_t lastEscapedChar = std::string::npos;
+ std::string scalar;
+ params.leadingSpaces = false;
+
+ if (!params.end) {
+ params.end = &Exp::Empty();
+ }
+
+ while (INPUT) {
+ // ********************************
+ // Phase #1: scan until line ending
+
+ std::size_t lastNonWhitespaceChar = scalar.size();
+ bool escapedNewline = false;
+ while (!params.end->Matches(INPUT) && !Exp::Break().Matches(INPUT)) {
+ if (!INPUT) {
+ break;
+ }
+
+ // document indicator?
+ if (INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT)) {
+ if (params.onDocIndicator == BREAK) {
+ break;
+ }
+ if (params.onDocIndicator == THROW) {
+ throw ParserException(INPUT.mark(), ErrorMsg::DOC_IN_SCALAR);
+ }
+ }
+
+ foundNonEmptyLine = true;
+ pastOpeningBreak = true;
+
+ // escaped newline? (only if we're escaping on slash)
+ if (params.escape == '\\' && Exp::EscBreak().Matches(INPUT)) {
+ // eat escape character and get out (but preserve trailing whitespace!)
+ INPUT.get();
+ lastNonWhitespaceChar = scalar.size();
+ lastEscapedChar = scalar.size();
+ escapedNewline = true;
+ break;
+ }
+
+ // escape this?
+ if (INPUT.peek() == params.escape) {
+ scalar += Exp::Escape(INPUT);
+ lastNonWhitespaceChar = scalar.size();
+ lastEscapedChar = scalar.size();
+ continue;
+ }
+
+ // otherwise, just add the damn character
+ char ch = INPUT.get();
+ scalar += ch;
+ if (ch != ' ' && ch != '\t') {
+ lastNonWhitespaceChar = scalar.size();
+ }
+ }
+
+ // eof? if we're looking to eat something, then we throw
+ if (!INPUT) {
+ if (params.eatEnd) {
+ throw ParserException(INPUT.mark(), ErrorMsg::EOF_IN_SCALAR);
+ }
+ break;
+ }
+
+ // doc indicator?
+ if (params.onDocIndicator == BREAK && INPUT.column() == 0 &&
+ Exp::DocIndicator().Matches(INPUT)) {
+ break;
+ }
+
+ // are we done via character match?
+ int n = params.end->Match(INPUT);
+ if (n >= 0) {
+ if (params.eatEnd) {
+ INPUT.eat(n);
+ }
+ break;
+ }
+
+ // do we remove trailing whitespace?
+ if (params.fold == FOLD_FLOW)
+ scalar.erase(lastNonWhitespaceChar);
+
+ // ********************************
+ // Phase #2: eat line ending
+ n = Exp::Break().Match(INPUT);
+ INPUT.eat(n);
+
+ // ********************************
+ // Phase #3: scan initial spaces
+
+ // first the required indentation
+ while (INPUT.peek() == ' ' &&
+ (INPUT.column() < params.indent ||
+ (params.detectIndent && !foundNonEmptyLine)) &&
+ !params.end->Matches(INPUT)) {
+ INPUT.eat(1);
+ }
+
+ // update indent if we're auto-detecting
+ if (params.detectIndent && !foundNonEmptyLine) {
+ params.indent = std::max(params.indent, INPUT.column());
+ }
+
+ // and then the rest of the whitespace
+ while (Exp::Blank().Matches(INPUT)) {
+ // we check for tabs that masquerade as indentation
+ if (INPUT.peek() == '\t' && INPUT.column() < params.indent &&
+ params.onTabInIndentation == THROW) {
+ throw ParserException(INPUT.mark(), ErrorMsg::TAB_IN_INDENTATION);
+ }
+
+ if (!params.eatLeadingWhitespace) {
+ break;
+ }
+
+ if (params.end->Matches(INPUT)) {
+ break;
+ }
+
+ INPUT.eat(1);
+ }
+
+ // was this an empty line?
+ bool nextEmptyLine = Exp::Break().Matches(INPUT);
+ bool nextMoreIndented = Exp::Blank().Matches(INPUT);
+ if (params.fold == FOLD_BLOCK && foldedNewlineCount == 0 && nextEmptyLine)
+ foldedNewlineStartedMoreIndented = moreIndented;
+
+ // for block scalars, we always start with a newline, so we should ignore it
+ // (not fold or keep)
+ if (pastOpeningBreak) {
+ switch (params.fold) {
+ case DONT_FOLD:
+ scalar += "\n";
+ break;
+ case FOLD_BLOCK:
+ if (!emptyLine && !nextEmptyLine && !moreIndented &&
+ !nextMoreIndented && INPUT.column() >= params.indent) {
+ scalar += " ";
+ } else if (nextEmptyLine) {
+ foldedNewlineCount++;
+ } else {
+ scalar += "\n";
+ }
+
+ if (!nextEmptyLine && foldedNewlineCount > 0) {
+ scalar += std::string(foldedNewlineCount - 1, '\n');
+ if (foldedNewlineStartedMoreIndented ||
+ nextMoreIndented | !foundNonEmptyLine) {
+ scalar += "\n";
+ }
+ foldedNewlineCount = 0;
+ }
+ break;
+ case FOLD_FLOW:
+ if (nextEmptyLine) {
+ scalar += "\n";
+ } else if (!emptyLine && !escapedNewline) {
+ scalar += " ";
+ }
+ break;
+ }
+ }
+
+ emptyLine = nextEmptyLine;
+ moreIndented = nextMoreIndented;
+ pastOpeningBreak = true;
+
+ // are we done via indentation?
+ if (!emptyLine && INPUT.column() < params.indent) {
+ params.leadingSpaces = true;
+ break;
+ }
+ }
+
+ // post-processing
+ if (params.trimTrailingSpaces) {
+ std::size_t pos = scalar.find_last_not_of(" \t");
+ if (lastEscapedChar != std::string::npos) {
+ if (pos < lastEscapedChar || pos == std::string::npos) {
+ pos = lastEscapedChar;
+ }
+ }
+ if (pos < scalar.size()) {
+ scalar.erase(pos + 1);
+ }
+ }
+
+ switch (params.chomp) {
+ case CLIP: {
+ std::size_t pos = scalar.find_last_not_of('\n');
+ if (lastEscapedChar != std::string::npos) {
+ if (pos < lastEscapedChar || pos == std::string::npos) {
+ pos = lastEscapedChar;
+ }
+ }
+ if (pos == std::string::npos) {
+ scalar.erase();
+ } else if (pos + 1 < scalar.size()) {
+ scalar.erase(pos + 2);
+ }
+ } break;
+ case STRIP: {
+ std::size_t pos = scalar.find_last_not_of('\n');
+ if (lastEscapedChar != std::string::npos) {
+ if (pos < lastEscapedChar || pos == std::string::npos) {
+ pos = lastEscapedChar;
+ }
+ }
+ if (pos == std::string::npos) {
+ scalar.erase();
+ } else if (pos < scalar.size()) {
+ scalar.erase(pos + 1);
+ }
+ } break;
+ default:
+ break;
+ }
+
+ return scalar;
+}
+} // namespace YAML
--- /dev/null
+#ifndef SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+#include "regex_yaml.h"
+#include "stream.h"
+
+namespace YAML {
+enum CHOMP { STRIP = -1, CLIP, KEEP };
+enum ACTION { NONE, BREAK, THROW };
+enum FOLD { DONT_FOLD, FOLD_BLOCK, FOLD_FLOW };
+
+struct ScanScalarParams {
+ ScanScalarParams()
+ : end(nullptr),
+ eatEnd(false),
+ indent(0),
+ detectIndent(false),
+ eatLeadingWhitespace(0),
+ escape(0),
+ fold(DONT_FOLD),
+ trimTrailingSpaces(0),
+ chomp(CLIP),
+ onDocIndicator(NONE),
+ onTabInIndentation(NONE),
+ leadingSpaces(false) {}
+
+ // input:
+ const RegEx* end; // what condition ends this scalar?
+ // unowned.
+ bool eatEnd; // should we eat that condition when we see it?
+ int indent; // what level of indentation should be eaten and ignored?
+ bool detectIndent; // should we try to autodetect the indent?
+ bool eatLeadingWhitespace; // should we continue eating this delicious
+ // indentation after 'indent' spaces?
+ char escape; // what character do we escape on (i.e., slash or single quote)
+ // (0 for none)
+ FOLD fold; // how do we fold line ends?
+ bool trimTrailingSpaces; // do we remove all trailing spaces (at the very
+ // end)
+ CHOMP chomp; // do we strip, clip, or keep trailing newlines (at the very
+ // end)
+ // Note: strip means kill all, clip means keep at most one, keep means keep
+ // all
+ ACTION onDocIndicator; // what do we do if we see a document indicator?
+ ACTION onTabInIndentation; // what do we do if we see a tab where we should
+ // be seeing indentation spaces
+
+ // output:
+ bool leadingSpaces;
+};
+
+std::string ScanScalar(Stream& INPUT, ScanScalarParams& params);
+}
+
+#endif // SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include "exp.h"
+#include "regex_yaml.h"
+#include "regeximpl.h"
+#include "stream.h"
+#include "yaml-cpp/exceptions.h" // IWYU pragma: keep
+#include "yaml-cpp/mark.h"
+
+namespace YAML {
+const std::string ScanVerbatimTag(Stream& INPUT) {
+ std::string tag;
+
+ // eat the start character
+ INPUT.get();
+
+ while (INPUT) {
+ if (INPUT.peek() == Keys::VerbatimTagEnd) {
+ // eat the end character
+ INPUT.get();
+ return tag;
+ }
+
+ int n = Exp::URI().Match(INPUT);
+ if (n <= 0)
+ break;
+
+ tag += INPUT.get(n);
+ }
+
+ throw ParserException(INPUT.mark(), ErrorMsg::END_OF_VERBATIM_TAG);
+}
+
+const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle) {
+ std::string tag;
+ canBeHandle = true;
+ Mark firstNonWordChar;
+
+ while (INPUT) {
+ if (INPUT.peek() == Keys::Tag) {
+ if (!canBeHandle)
+ throw ParserException(firstNonWordChar, ErrorMsg::CHAR_IN_TAG_HANDLE);
+ break;
+ }
+
+ int n = 0;
+ if (canBeHandle) {
+ n = Exp::Word().Match(INPUT);
+ if (n <= 0) {
+ canBeHandle = false;
+ firstNonWordChar = INPUT.mark();
+ }
+ }
+
+ if (!canBeHandle)
+ n = Exp::Tag().Match(INPUT);
+
+ if (n <= 0)
+ break;
+
+ tag += INPUT.get(n);
+ }
+
+ return tag;
+}
+
+const std::string ScanTagSuffix(Stream& INPUT) {
+ std::string tag;
+
+ while (INPUT) {
+ int n = Exp::Tag().Match(INPUT);
+ if (n <= 0)
+ break;
+
+ tag += INPUT.get(n);
+ }
+
+ if (tag.empty())
+ throw ParserException(INPUT.mark(), ErrorMsg::TAG_WITH_NO_SUFFIX);
+
+ return tag;
+}
+} // namespace YAML
--- /dev/null
+#ifndef SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+#include "stream.h"
+
+namespace YAML {
+const std::string ScanVerbatimTag(Stream& INPUT);
+const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle);
+const std::string ScanTagSuffix(Stream& INPUT);
+}
+
+#endif // SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include <sstream>
+
+#include "exp.h"
+#include "regex_yaml.h"
+#include "regeximpl.h"
+#include "scanner.h"
+#include "scanscalar.h"
+#include "scantag.h" // IWYU pragma: keep
+#include "tag.h" // IWYU pragma: keep
+#include "token.h"
+#include "yaml-cpp/exceptions.h" // IWYU pragma: keep
+#include "yaml-cpp/mark.h"
+
+namespace YAML {
+///////////////////////////////////////////////////////////////////////
+// Specialization for scanning specific tokens
+
+// Directive
+// . Note: no semantic checking is done here (that's for the parser to do)
+void Scanner::ScanDirective() {
+ std::string name;
+ std::vector<std::string> params;
+
+ // pop indents and simple keys
+ PopAllIndents();
+ PopAllSimpleKeys();
+
+ m_simpleKeyAllowed = false;
+ m_canBeJSONFlow = false;
+
+ // store pos and eat indicator
+ Token token(Token::DIRECTIVE, INPUT.mark());
+ INPUT.eat(1);
+
+ // read name
+ while (INPUT && !Exp::BlankOrBreak().Matches(INPUT))
+ token.value += INPUT.get();
+
+ // read parameters
+ while (true) {
+ // first get rid of whitespace
+ while (Exp::Blank().Matches(INPUT))
+ INPUT.eat(1);
+
+ // break on newline or comment
+ if (!INPUT || Exp::Break().Matches(INPUT) || Exp::Comment().Matches(INPUT))
+ break;
+
+ // now read parameter
+ std::string param;
+ while (INPUT && !Exp::BlankOrBreak().Matches(INPUT))
+ param += INPUT.get();
+
+ token.params.push_back(param);
+ }
+
+ m_tokens.push(token);
+}
+
+// DocStart
+void Scanner::ScanDocStart() {
+ PopAllIndents();
+ PopAllSimpleKeys();
+ m_simpleKeyAllowed = false;
+ m_canBeJSONFlow = false;
+
+ // eat
+ Mark mark = INPUT.mark();
+ INPUT.eat(3);
+ m_tokens.push(Token(Token::DOC_START, mark));
+}
+
+// DocEnd
+void Scanner::ScanDocEnd() {
+ PopAllIndents();
+ PopAllSimpleKeys();
+ m_simpleKeyAllowed = false;
+ m_canBeJSONFlow = false;
+
+ // eat
+ Mark mark = INPUT.mark();
+ INPUT.eat(3);
+ m_tokens.push(Token(Token::DOC_END, mark));
+}
+
+// FlowStart
+void Scanner::ScanFlowStart() {
+ // flows can be simple keys
+ InsertPotentialSimpleKey();
+ m_simpleKeyAllowed = true;
+ m_canBeJSONFlow = false;
+
+ // eat
+ Mark mark = INPUT.mark();
+ char ch = INPUT.get();
+ FLOW_MARKER flowType = (ch == Keys::FlowSeqStart ? FLOW_SEQ : FLOW_MAP);
+ m_flows.push(flowType);
+ Token::TYPE type =
+ (flowType == FLOW_SEQ ? Token::FLOW_SEQ_START : Token::FLOW_MAP_START);
+ m_tokens.push(Token(type, mark));
+}
+
+// FlowEnd
+void Scanner::ScanFlowEnd() {
+ if (InBlockContext())
+ throw ParserException(INPUT.mark(), ErrorMsg::FLOW_END);
+
+ // we might have a solo entry in the flow context
+ if (InFlowContext()) {
+ if (m_flows.top() == FLOW_MAP && VerifySimpleKey())
+ m_tokens.push(Token(Token::VALUE, INPUT.mark()));
+ else if (m_flows.top() == FLOW_SEQ)
+ InvalidateSimpleKey();
+ }
+
+ m_simpleKeyAllowed = false;
+ m_canBeJSONFlow = true;
+
+ // eat
+ Mark mark = INPUT.mark();
+ char ch = INPUT.get();
+
+ // check that it matches the start
+ FLOW_MARKER flowType = (ch == Keys::FlowSeqEnd ? FLOW_SEQ : FLOW_MAP);
+ if (m_flows.top() != flowType)
+ throw ParserException(mark, ErrorMsg::FLOW_END);
+ m_flows.pop();
+
+ Token::TYPE type = (flowType ? Token::FLOW_SEQ_END : Token::FLOW_MAP_END);
+ m_tokens.push(Token(type, mark));
+}
+
+// FlowEntry
+void Scanner::ScanFlowEntry() {
+ // we might have a solo entry in the flow context
+ if (InFlowContext()) {
+ if (m_flows.top() == FLOW_MAP && VerifySimpleKey())
+ m_tokens.push(Token(Token::VALUE, INPUT.mark()));
+ else if (m_flows.top() == FLOW_SEQ)
+ InvalidateSimpleKey();
+ }
+
+ m_simpleKeyAllowed = true;
+ m_canBeJSONFlow = false;
+
+ // eat
+ Mark mark = INPUT.mark();
+ INPUT.eat(1);
+ m_tokens.push(Token(Token::FLOW_ENTRY, mark));
+}
+
+// BlockEntry
+void Scanner::ScanBlockEntry() {
+ // we better be in the block context!
+ if (InFlowContext())
+ throw ParserException(INPUT.mark(), ErrorMsg::BLOCK_ENTRY);
+
+ // can we put it here?
+ if (!m_simpleKeyAllowed)
+ throw ParserException(INPUT.mark(), ErrorMsg::BLOCK_ENTRY);
+
+ PushIndentTo(INPUT.column(), IndentMarker::SEQ);
+ m_simpleKeyAllowed = true;
+ m_canBeJSONFlow = false;
+
+ // eat
+ Mark mark = INPUT.mark();
+ INPUT.eat(1);
+ m_tokens.push(Token(Token::BLOCK_ENTRY, mark));
+}
+
+// Key
+void Scanner::ScanKey() {
+ // handle keys differently in the block context (and manage indents)
+ if (InBlockContext()) {
+ if (!m_simpleKeyAllowed)
+ throw ParserException(INPUT.mark(), ErrorMsg::MAP_KEY);
+
+ PushIndentTo(INPUT.column(), IndentMarker::MAP);
+ }
+
+ // can only put a simple key here if we're in block context
+ m_simpleKeyAllowed = InBlockContext();
+
+ // eat
+ Mark mark = INPUT.mark();
+ INPUT.eat(1);
+ m_tokens.push(Token(Token::KEY, mark));
+}
+
+// Value
+void Scanner::ScanValue() {
+ // and check that simple key
+ bool isSimpleKey = VerifySimpleKey();
+ m_canBeJSONFlow = false;
+
+ if (isSimpleKey) {
+ // can't follow a simple key with another simple key (dunno why, though - it
+ // seems fine)
+ m_simpleKeyAllowed = false;
+ } else {
+ // handle values differently in the block context (and manage indents)
+ if (InBlockContext()) {
+ if (!m_simpleKeyAllowed)
+ throw ParserException(INPUT.mark(), ErrorMsg::MAP_VALUE);
+
+ PushIndentTo(INPUT.column(), IndentMarker::MAP);
+ }
+
+ // can only put a simple key here if we're in block context
+ m_simpleKeyAllowed = InBlockContext();
+ }
+
+ // eat
+ Mark mark = INPUT.mark();
+ INPUT.eat(1);
+ m_tokens.push(Token(Token::VALUE, mark));
+}
+
+// AnchorOrAlias
+void Scanner::ScanAnchorOrAlias() {
+ bool alias;
+ std::string name;
+
+ // insert a potential simple key
+ InsertPotentialSimpleKey();
+ m_simpleKeyAllowed = false;
+ m_canBeJSONFlow = false;
+
+ // eat the indicator
+ Mark mark = INPUT.mark();
+ char indicator = INPUT.get();
+ alias = (indicator == Keys::Alias);
+
+ // now eat the content
+ while (INPUT && Exp::Anchor().Matches(INPUT))
+ name += INPUT.get();
+
+ // we need to have read SOMETHING!
+ if (name.empty())
+ throw ParserException(INPUT.mark(), alias ? ErrorMsg::ALIAS_NOT_FOUND
+ : ErrorMsg::ANCHOR_NOT_FOUND);
+
+ // and needs to end correctly
+ if (INPUT && !Exp::AnchorEnd().Matches(INPUT))
+ throw ParserException(INPUT.mark(), alias ? ErrorMsg::CHAR_IN_ALIAS
+ : ErrorMsg::CHAR_IN_ANCHOR);
+
+ // and we're done
+ Token token(alias ? Token::ALIAS : Token::ANCHOR, mark);
+ token.value = name;
+ m_tokens.push(token);
+}
+
+// Tag
+void Scanner::ScanTag() {
+ // insert a potential simple key
+ InsertPotentialSimpleKey();
+ m_simpleKeyAllowed = false;
+ m_canBeJSONFlow = false;
+
+ Token token(Token::TAG, INPUT.mark());
+
+ // eat the indicator
+ INPUT.get();
+
+ if (INPUT && INPUT.peek() == Keys::VerbatimTagStart) {
+ std::string tag = ScanVerbatimTag(INPUT);
+
+ token.value = tag;
+ token.data = Tag::VERBATIM;
+ } else {
+ bool canBeHandle;
+ token.value = ScanTagHandle(INPUT, canBeHandle);
+ if (!canBeHandle && token.value.empty())
+ token.data = Tag::NON_SPECIFIC;
+ else if (token.value.empty())
+ token.data = Tag::SECONDARY_HANDLE;
+ else
+ token.data = Tag::PRIMARY_HANDLE;
+
+ // is there a suffix?
+ if (canBeHandle && INPUT.peek() == Keys::Tag) {
+ // eat the indicator
+ INPUT.get();
+ token.params.push_back(ScanTagSuffix(INPUT));
+ token.data = Tag::NAMED_HANDLE;
+ }
+ }
+
+ m_tokens.push(token);
+}
+
+// PlainScalar
+void Scanner::ScanPlainScalar() {
+ std::string scalar;
+
+ // set up the scanning parameters
+ ScanScalarParams params;
+ params.end =
+ (InFlowContext() ? &Exp::ScanScalarEndInFlow() : &Exp::ScanScalarEnd());
+ params.eatEnd = false;
+ params.indent = (InFlowContext() ? 0 : GetTopIndent() + 1);
+ params.fold = FOLD_FLOW;
+ params.eatLeadingWhitespace = true;
+ params.trimTrailingSpaces = true;
+ params.chomp = STRIP;
+ params.onDocIndicator = BREAK;
+ params.onTabInIndentation = THROW;
+
+ // insert a potential simple key
+ InsertPotentialSimpleKey();
+
+ Mark mark = INPUT.mark();
+ scalar = ScanScalar(INPUT, params);
+
+ // can have a simple key only if we ended the scalar by starting a new line
+ m_simpleKeyAllowed = params.leadingSpaces;
+ m_canBeJSONFlow = false;
+
+ // finally, check and see if we ended on an illegal character
+ // if(Exp::IllegalCharInScalar.Matches(INPUT))
+ // throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_SCALAR);
+
+ Token token(Token::PLAIN_SCALAR, mark);
+ token.value = scalar;
+ m_tokens.push(token);
+}
+
+// QuotedScalar
+void Scanner::ScanQuotedScalar() {
+ std::string scalar;
+
+ // peek at single or double quote (don't eat because we need to preserve (for
+ // the time being) the input position)
+ char quote = INPUT.peek();
+ bool single = (quote == '\'');
+
+ // setup the scanning parameters
+ ScanScalarParams params;
+ RegEx end = (single ? RegEx(quote) & !Exp::EscSingleQuote() : RegEx(quote));
+ params.end = &end;
+ params.eatEnd = true;
+ params.escape = (single ? '\'' : '\\');
+ params.indent = 0;
+ params.fold = FOLD_FLOW;
+ params.eatLeadingWhitespace = true;
+ params.trimTrailingSpaces = false;
+ params.chomp = CLIP;
+ params.onDocIndicator = THROW;
+
+ // insert a potential simple key
+ InsertPotentialSimpleKey();
+
+ Mark mark = INPUT.mark();
+
+ // now eat that opening quote
+ INPUT.get();
+
+ // and scan
+ scalar = ScanScalar(INPUT, params);
+ m_simpleKeyAllowed = false;
+ m_canBeJSONFlow = true;
+
+ Token token(Token::NON_PLAIN_SCALAR, mark);
+ token.value = scalar;
+ m_tokens.push(token);
+}
+
+// BlockScalarToken
+// . These need a little extra processing beforehand.
+// . We need to scan the line where the indicator is (this doesn't count as part
+// of the scalar),
+// and then we need to figure out what level of indentation we'll be using.
+void Scanner::ScanBlockScalar() {
+ std::string scalar;
+
+ ScanScalarParams params;
+ params.indent = 1;
+ params.detectIndent = true;
+
+ // eat block indicator ('|' or '>')
+ Mark mark = INPUT.mark();
+ char indicator = INPUT.get();
+ params.fold = (indicator == Keys::FoldedScalar ? FOLD_BLOCK : DONT_FOLD);
+
+ // eat chomping/indentation indicators
+ params.chomp = CLIP;
+ int n = Exp::Chomp().Match(INPUT);
+ for (int i = 0; i < n; i++) {
+ char ch = INPUT.get();
+ if (ch == '+')
+ params.chomp = KEEP;
+ else if (ch == '-')
+ params.chomp = STRIP;
+ else if (Exp::Digit().Matches(ch)) {
+ if (ch == '0')
+ throw ParserException(INPUT.mark(), ErrorMsg::ZERO_INDENT_IN_BLOCK);
+
+ params.indent = ch - '0';
+ params.detectIndent = false;
+ }
+ }
+
+ // now eat whitespace
+ while (Exp::Blank().Matches(INPUT))
+ INPUT.eat(1);
+
+ // and comments to the end of the line
+ if (Exp::Comment().Matches(INPUT))
+ while (INPUT && !Exp::Break().Matches(INPUT))
+ INPUT.eat(1);
+
+ // if it's not a line break, then we ran into a bad character inline
+ if (INPUT && !Exp::Break().Matches(INPUT))
+ throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_BLOCK);
+
+ // set the initial indentation
+ if (GetTopIndent() >= 0)
+ params.indent += GetTopIndent();
+
+ params.eatLeadingWhitespace = false;
+ params.trimTrailingSpaces = false;
+ params.onTabInIndentation = THROW;
+
+ scalar = ScanScalar(INPUT, params);
+
+ // simple keys always ok after block scalars (since we're gonna start a new
+ // line anyways)
+ m_simpleKeyAllowed = true;
+ m_canBeJSONFlow = false;
+
+ Token token(Token::NON_PLAIN_SCALAR, mark);
+ token.value = scalar;
+ m_tokens.push(token);
+}
+} // namespace YAML
--- /dev/null
+#ifndef SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/noexcept.h"
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace YAML {
+
+class SettingChangeBase {
+ public:
+ virtual ~SettingChangeBase() = default;
+ virtual void pop() = 0;
+};
+
+template <typename T>
+class Setting {
+ public:
+ Setting() : m_value() {}
+ Setting(const T& value) : m_value() { set(value); }
+
+ const T get() const { return m_value; }
+ std::unique_ptr<SettingChangeBase> set(const T& value);
+ void restore(const Setting<T>& oldSetting) { m_value = oldSetting.get(); }
+
+ private:
+ T m_value;
+};
+
+template <typename T>
+class SettingChange : public SettingChangeBase {
+ public:
+ SettingChange(Setting<T>* pSetting)
+ : m_pCurSetting(pSetting),
+ m_oldSetting(*pSetting) // copy old setting to save its state
+ {}
+ SettingChange(const SettingChange&) = delete;
+ SettingChange(SettingChange&&) = delete;
+ SettingChange& operator=(const SettingChange&) = delete;
+ SettingChange& operator=(SettingChange&&) = delete;
+
+ void pop() override { m_pCurSetting->restore(m_oldSetting); }
+
+ private:
+ Setting<T>* m_pCurSetting;
+ Setting<T> m_oldSetting;
+};
+
+template <typename T>
+inline std::unique_ptr<SettingChangeBase> Setting<T>::set(const T& value) {
+ std::unique_ptr<SettingChangeBase> pChange(new SettingChange<T>(this));
+ m_value = value;
+ return pChange;
+}
+
+class SettingChanges {
+ public:
+ SettingChanges() : m_settingChanges{} {}
+ SettingChanges(const SettingChanges&) = delete;
+ SettingChanges(SettingChanges&&) YAML_CPP_NOEXCEPT = default;
+ SettingChanges& operator=(const SettingChanges&) = delete;
+ SettingChanges& operator=(SettingChanges&& rhs) YAML_CPP_NOEXCEPT {
+ if (this == &rhs)
+ return *this;
+
+ clear();
+ std::swap(m_settingChanges, rhs.m_settingChanges);
+
+ return *this;
+ }
+ ~SettingChanges() { clear(); }
+
+ void clear() YAML_CPP_NOEXCEPT {
+ restore();
+ m_settingChanges.clear();
+ }
+
+ void restore() YAML_CPP_NOEXCEPT {
+ for (const auto& setting : m_settingChanges)
+ setting->pop();
+ }
+
+ void push(std::unique_ptr<SettingChangeBase> pSettingChange) {
+ m_settingChanges.push_back(std::move(pSettingChange));
+ }
+
+ private:
+ using setting_changes = std::vector<std::unique_ptr<SettingChangeBase>>;
+ setting_changes m_settingChanges;
+};
+} // namespace YAML
+
+#endif // SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include "scanner.h"
+#include "token.h"
+
+namespace YAML {
+struct Mark;
+
+Scanner::SimpleKey::SimpleKey(const Mark& mark_, std::size_t flowLevel_)
+ : mark(mark_),
+ flowLevel(flowLevel_),
+ pIndent(nullptr),
+ pMapStart(nullptr),
+ pKey(nullptr) {}
+
+void Scanner::SimpleKey::Validate() {
+ // Note: pIndent will *not* be garbage here;
+ // we "garbage collect" them so we can
+ // always refer to them
+ if (pIndent)
+ pIndent->status = IndentMarker::VALID;
+ if (pMapStart)
+ pMapStart->status = Token::VALID;
+ if (pKey)
+ pKey->status = Token::VALID;
+}
+
+void Scanner::SimpleKey::Invalidate() {
+ if (pIndent)
+ pIndent->status = IndentMarker::INVALID;
+ if (pMapStart)
+ pMapStart->status = Token::INVALID;
+ if (pKey)
+ pKey->status = Token::INVALID;
+}
+
+// CanInsertPotentialSimpleKey
+bool Scanner::CanInsertPotentialSimpleKey() const {
+ if (!m_simpleKeyAllowed)
+ return false;
+
+ return !ExistsActiveSimpleKey();
+}
+
+// ExistsActiveSimpleKey
+// . Returns true if there's a potential simple key at our flow level
+// (there's allowed at most one per flow level, i.e., at the start of the flow
+// start token)
+bool Scanner::ExistsActiveSimpleKey() const {
+ if (m_simpleKeys.empty())
+ return false;
+
+ const SimpleKey& key = m_simpleKeys.top();
+ return key.flowLevel == GetFlowLevel();
+}
+
+// InsertPotentialSimpleKey
+// . If we can, add a potential simple key to the queue,
+// and save it on a stack.
+void Scanner::InsertPotentialSimpleKey() {
+ if (!CanInsertPotentialSimpleKey())
+ return;
+
+ SimpleKey key(INPUT.mark(), GetFlowLevel());
+
+ // first add a map start, if necessary
+ if (InBlockContext()) {
+ key.pIndent = PushIndentTo(INPUT.column(), IndentMarker::MAP);
+ if (key.pIndent) {
+ key.pIndent->status = IndentMarker::UNKNOWN;
+ key.pMapStart = key.pIndent->pStartToken;
+ key.pMapStart->status = Token::UNVERIFIED;
+ }
+ }
+
+ // then add the (now unverified) key
+ m_tokens.push(Token(Token::KEY, INPUT.mark()));
+ key.pKey = &m_tokens.back();
+ key.pKey->status = Token::UNVERIFIED;
+
+ m_simpleKeys.push(key);
+}
+
+// InvalidateSimpleKey
+// . Automatically invalidate the simple key in our flow level
+void Scanner::InvalidateSimpleKey() {
+ if (m_simpleKeys.empty())
+ return;
+
+ // grab top key
+ SimpleKey& key = m_simpleKeys.top();
+ if (key.flowLevel != GetFlowLevel())
+ return;
+
+ key.Invalidate();
+ m_simpleKeys.pop();
+}
+
+// VerifySimpleKey
+// . Determines whether the latest simple key to be added is valid,
+// and if so, makes it valid.
+bool Scanner::VerifySimpleKey() {
+ if (m_simpleKeys.empty())
+ return false;
+
+ // grab top key
+ SimpleKey key = m_simpleKeys.top();
+
+ // only validate if we're in the correct flow level
+ if (key.flowLevel != GetFlowLevel())
+ return false;
+
+ m_simpleKeys.pop();
+
+ bool isValid = true;
+
+ // needs to be less than 1024 characters and inline
+ if (INPUT.line() != key.mark.line || INPUT.pos() - key.mark.pos > 1024)
+ isValid = false;
+
+ // invalidate key
+ if (isValid)
+ key.Validate();
+ else
+ key.Invalidate();
+
+ return isValid;
+}
+
+void Scanner::PopAllSimpleKeys() {
+ while (!m_simpleKeys.empty())
+ m_simpleKeys.pop();
+}
+} // namespace YAML
--- /dev/null
+#include <algorithm>
+#include <cstdio>
+#include <sstream>
+
+#include "collectionstack.h" // IWYU pragma: keep
+#include "scanner.h"
+#include "singledocparser.h"
+#include "tag.h"
+#include "token.h"
+#include "yaml-cpp/depthguard.h"
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/exceptions.h" // IWYU pragma: keep
+#include "yaml-cpp/mark.h"
+#include "yaml-cpp/null.h"
+
+namespace YAML {
+SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives)
+ : m_scanner(scanner),
+ m_directives(directives),
+ m_pCollectionStack(new CollectionStack),
+ m_anchors{},
+ m_curAnchor(0) {}
+
+SingleDocParser::~SingleDocParser() = default;
+
+// HandleDocument
+// . Handles the next document
+// . Throws a ParserException on error.
+void SingleDocParser::HandleDocument(EventHandler& eventHandler) {
+ assert(!m_scanner.empty()); // guaranteed that there are tokens
+ assert(!m_curAnchor);
+
+ eventHandler.OnDocumentStart(m_scanner.peek().mark);
+
+ // eat doc start
+ if (m_scanner.peek().type == Token::DOC_START)
+ m_scanner.pop();
+
+ // recurse!
+ HandleNode(eventHandler);
+
+ eventHandler.OnDocumentEnd();
+
+ // and finally eat any doc ends we see
+ while (!m_scanner.empty() && m_scanner.peek().type == Token::DOC_END)
+ m_scanner.pop();
+}
+
+void SingleDocParser::HandleNode(EventHandler& eventHandler) {
+ DepthGuard<500> depthguard(depth, m_scanner.mark(), ErrorMsg::BAD_FILE);
+
+ // an empty node *is* a possibility
+ if (m_scanner.empty()) {
+ eventHandler.OnNull(m_scanner.mark(), NullAnchor);
+ return;
+ }
+
+ // save location
+ Mark mark = m_scanner.peek().mark;
+
+ // special case: a value node by itself must be a map, with no header
+ if (m_scanner.peek().type == Token::VALUE) {
+ eventHandler.OnMapStart(mark, "?", NullAnchor, EmitterStyle::Default);
+ HandleMap(eventHandler);
+ eventHandler.OnMapEnd();
+ return;
+ }
+
+ // special case: an alias node
+ if (m_scanner.peek().type == Token::ALIAS) {
+ eventHandler.OnAlias(mark, LookupAnchor(mark, m_scanner.peek().value));
+ m_scanner.pop();
+ return;
+ }
+
+ std::string tag;
+ std::string anchor_name;
+ anchor_t anchor;
+ ParseProperties(tag, anchor, anchor_name);
+
+ if (!anchor_name.empty())
+ eventHandler.OnAnchor(mark, anchor_name);
+
+ // after parsing properties, an empty node is again a possibility
+ if (m_scanner.empty()) {
+ eventHandler.OnNull(mark, anchor);
+ return;
+ }
+
+ const Token& token = m_scanner.peek();
+
+ // add non-specific tags
+ if (tag.empty())
+ tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?");
+
+ if (token.type == Token::PLAIN_SCALAR
+ && tag.compare("?") == 0 && IsNullString(token.value)) {
+ eventHandler.OnNull(mark, anchor);
+ m_scanner.pop();
+ return;
+ }
+
+ // now split based on what kind of node we should be
+ switch (token.type) {
+ case Token::PLAIN_SCALAR:
+ case Token::NON_PLAIN_SCALAR:
+ eventHandler.OnScalar(mark, tag, anchor, token.value);
+ m_scanner.pop();
+ return;
+ case Token::FLOW_SEQ_START:
+ eventHandler.OnSequenceStart(mark, tag, anchor, EmitterStyle::Flow);
+ HandleSequence(eventHandler);
+ eventHandler.OnSequenceEnd();
+ return;
+ case Token::BLOCK_SEQ_START:
+ eventHandler.OnSequenceStart(mark, tag, anchor, EmitterStyle::Block);
+ HandleSequence(eventHandler);
+ eventHandler.OnSequenceEnd();
+ return;
+ case Token::FLOW_MAP_START:
+ eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Flow);
+ HandleMap(eventHandler);
+ eventHandler.OnMapEnd();
+ return;
+ case Token::BLOCK_MAP_START:
+ eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Block);
+ HandleMap(eventHandler);
+ eventHandler.OnMapEnd();
+ return;
+ case Token::KEY:
+ // compact maps can only go in a flow sequence
+ if (m_pCollectionStack->GetCurCollectionType() ==
+ CollectionType::FlowSeq) {
+ eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Flow);
+ HandleMap(eventHandler);
+ eventHandler.OnMapEnd();
+ return;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (tag == "?")
+ eventHandler.OnNull(mark, anchor);
+ else
+ eventHandler.OnScalar(mark, tag, anchor, "");
+}
+
+void SingleDocParser::HandleSequence(EventHandler& eventHandler) {
+ // split based on start token
+ switch (m_scanner.peek().type) {
+ case Token::BLOCK_SEQ_START:
+ HandleBlockSequence(eventHandler);
+ break;
+ case Token::FLOW_SEQ_START:
+ HandleFlowSequence(eventHandler);
+ break;
+ default:
+ break;
+ }
+}
+
+void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) {
+ // eat start token
+ m_scanner.pop();
+ m_pCollectionStack->PushCollectionType(CollectionType::BlockSeq);
+
+ while (true) {
+ if (m_scanner.empty())
+ throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ);
+
+ Token token = m_scanner.peek();
+ if (token.type != Token::BLOCK_ENTRY && token.type != Token::BLOCK_SEQ_END)
+ throw ParserException(token.mark, ErrorMsg::END_OF_SEQ);
+
+ m_scanner.pop();
+ if (token.type == Token::BLOCK_SEQ_END)
+ break;
+
+ // check for null
+ if (!m_scanner.empty()) {
+ const Token& nextToken = m_scanner.peek();
+ if (nextToken.type == Token::BLOCK_ENTRY ||
+ nextToken.type == Token::BLOCK_SEQ_END) {
+ eventHandler.OnNull(nextToken.mark, NullAnchor);
+ continue;
+ }
+ }
+
+ HandleNode(eventHandler);
+ }
+
+ m_pCollectionStack->PopCollectionType(CollectionType::BlockSeq);
+}
+
+void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler) {
+ // eat start token
+ m_scanner.pop();
+ m_pCollectionStack->PushCollectionType(CollectionType::FlowSeq);
+
+ while (true) {
+ if (m_scanner.empty())
+ throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW);
+
+ // first check for end
+ if (m_scanner.peek().type == Token::FLOW_SEQ_END) {
+ m_scanner.pop();
+ break;
+ }
+
+ // then read the node
+ HandleNode(eventHandler);
+
+ if (m_scanner.empty())
+ throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW);
+
+ // now eat the separator (or could be a sequence end, which we ignore - but
+ // if it's neither, then it's a bad node)
+ Token& token = m_scanner.peek();
+ if (token.type == Token::FLOW_ENTRY)
+ m_scanner.pop();
+ else if (token.type != Token::FLOW_SEQ_END)
+ throw ParserException(token.mark, ErrorMsg::END_OF_SEQ_FLOW);
+ }
+
+ m_pCollectionStack->PopCollectionType(CollectionType::FlowSeq);
+}
+
+void SingleDocParser::HandleMap(EventHandler& eventHandler) {
+ // split based on start token
+ switch (m_scanner.peek().type) {
+ case Token::BLOCK_MAP_START:
+ HandleBlockMap(eventHandler);
+ break;
+ case Token::FLOW_MAP_START:
+ HandleFlowMap(eventHandler);
+ break;
+ case Token::KEY:
+ HandleCompactMap(eventHandler);
+ break;
+ case Token::VALUE:
+ HandleCompactMapWithNoKey(eventHandler);
+ break;
+ default:
+ break;
+ }
+}
+
+void SingleDocParser::HandleBlockMap(EventHandler& eventHandler) {
+ // eat start token
+ m_scanner.pop();
+ m_pCollectionStack->PushCollectionType(CollectionType::BlockMap);
+
+ while (true) {
+ if (m_scanner.empty())
+ throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP);
+
+ Token token = m_scanner.peek();
+ if (token.type != Token::KEY && token.type != Token::VALUE &&
+ token.type != Token::BLOCK_MAP_END)
+ throw ParserException(token.mark, ErrorMsg::END_OF_MAP);
+
+ if (token.type == Token::BLOCK_MAP_END) {
+ m_scanner.pop();
+ break;
+ }
+
+ // grab key (if non-null)
+ if (token.type == Token::KEY) {
+ m_scanner.pop();
+ HandleNode(eventHandler);
+ } else {
+ eventHandler.OnNull(token.mark, NullAnchor);
+ }
+
+ // now grab value (optional)
+ if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
+ m_scanner.pop();
+ HandleNode(eventHandler);
+ } else {
+ eventHandler.OnNull(token.mark, NullAnchor);
+ }
+ }
+
+ m_pCollectionStack->PopCollectionType(CollectionType::BlockMap);
+}
+
+void SingleDocParser::HandleFlowMap(EventHandler& eventHandler) {
+ // eat start token
+ m_scanner.pop();
+ m_pCollectionStack->PushCollectionType(CollectionType::FlowMap);
+
+ while (true) {
+ if (m_scanner.empty())
+ throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW);
+
+ Token& token = m_scanner.peek();
+ const Mark mark = token.mark;
+ // first check for end
+ if (token.type == Token::FLOW_MAP_END) {
+ m_scanner.pop();
+ break;
+ }
+
+ // grab key (if non-null)
+ if (token.type == Token::KEY) {
+ m_scanner.pop();
+ HandleNode(eventHandler);
+ } else {
+ eventHandler.OnNull(mark, NullAnchor);
+ }
+
+ // now grab value (optional)
+ if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
+ m_scanner.pop();
+ HandleNode(eventHandler);
+ } else {
+ eventHandler.OnNull(mark, NullAnchor);
+ }
+
+ if (m_scanner.empty())
+ throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW);
+
+ // now eat the separator (or could be a map end, which we ignore - but if
+ // it's neither, then it's a bad node)
+ Token& nextToken = m_scanner.peek();
+ if (nextToken.type == Token::FLOW_ENTRY)
+ m_scanner.pop();
+ else if (nextToken.type != Token::FLOW_MAP_END)
+ throw ParserException(nextToken.mark, ErrorMsg::END_OF_MAP_FLOW);
+ }
+
+ m_pCollectionStack->PopCollectionType(CollectionType::FlowMap);
+}
+
+// . Single "key: value" pair in a flow sequence
+void SingleDocParser::HandleCompactMap(EventHandler& eventHandler) {
+ m_pCollectionStack->PushCollectionType(CollectionType::CompactMap);
+
+ // grab key
+ Mark mark = m_scanner.peek().mark;
+ m_scanner.pop();
+ HandleNode(eventHandler);
+
+ // now grab value (optional)
+ if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) {
+ m_scanner.pop();
+ HandleNode(eventHandler);
+ } else {
+ eventHandler.OnNull(mark, NullAnchor);
+ }
+
+ m_pCollectionStack->PopCollectionType(CollectionType::CompactMap);
+}
+
+// . Single ": value" pair in a flow sequence
+void SingleDocParser::HandleCompactMapWithNoKey(EventHandler& eventHandler) {
+ m_pCollectionStack->PushCollectionType(CollectionType::CompactMap);
+
+ // null key
+ eventHandler.OnNull(m_scanner.peek().mark, NullAnchor);
+
+ // grab value
+ m_scanner.pop();
+ HandleNode(eventHandler);
+
+ m_pCollectionStack->PopCollectionType(CollectionType::CompactMap);
+}
+
+// ParseProperties
+// . Grabs any tag or anchor tokens and deals with them.
+void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor,
+ std::string& anchor_name) {
+ tag.clear();
+ anchor_name.clear();
+ anchor = NullAnchor;
+
+ while (true) {
+ if (m_scanner.empty())
+ return;
+
+ switch (m_scanner.peek().type) {
+ case Token::TAG:
+ ParseTag(tag);
+ break;
+ case Token::ANCHOR:
+ ParseAnchor(anchor, anchor_name);
+ break;
+ default:
+ return;
+ }
+ }
+}
+
+void SingleDocParser::ParseTag(std::string& tag) {
+ Token& token = m_scanner.peek();
+ if (!tag.empty())
+ throw ParserException(token.mark, ErrorMsg::MULTIPLE_TAGS);
+
+ Tag tagInfo(token);
+ tag = tagInfo.Translate(m_directives);
+ m_scanner.pop();
+}
+
+void SingleDocParser::ParseAnchor(anchor_t& anchor, std::string& anchor_name) {
+ Token& token = m_scanner.peek();
+ if (anchor)
+ throw ParserException(token.mark, ErrorMsg::MULTIPLE_ANCHORS);
+
+ anchor_name = token.value;
+ anchor = RegisterAnchor(token.value);
+ m_scanner.pop();
+}
+
+anchor_t SingleDocParser::RegisterAnchor(const std::string& name) {
+ if (name.empty())
+ return NullAnchor;
+
+ return m_anchors[name] = ++m_curAnchor;
+}
+
+anchor_t SingleDocParser::LookupAnchor(const Mark& mark,
+ const std::string& name) const {
+ auto it = m_anchors.find(name);
+ if (it == m_anchors.end()) {
+ std::stringstream ss;
+ ss << ErrorMsg::UNKNOWN_ANCHOR << name;
+ throw ParserException(mark, ss.str());
+ }
+
+ return it->second;
+}
+} // namespace YAML
--- /dev/null
+#ifndef SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <map>
+#include <memory>
+#include <string>
+
+#include "yaml-cpp/anchor.h"
+
+namespace YAML {
+class CollectionStack;
+template <int> class DepthGuard; // depthguard.h
+class EventHandler;
+class Node;
+class Scanner;
+struct Directives;
+struct Mark;
+struct Token;
+
+class SingleDocParser {
+ public:
+ SingleDocParser(Scanner& scanner, const Directives& directives);
+ SingleDocParser(const SingleDocParser&) = delete;
+ SingleDocParser(SingleDocParser&&) = delete;
+ SingleDocParser& operator=(const SingleDocParser&) = delete;
+ SingleDocParser& operator=(SingleDocParser&&) = delete;
+ ~SingleDocParser();
+
+ void HandleDocument(EventHandler& eventHandler);
+
+ private:
+ void HandleNode(EventHandler& eventHandler);
+
+ void HandleSequence(EventHandler& eventHandler);
+ void HandleBlockSequence(EventHandler& eventHandler);
+ void HandleFlowSequence(EventHandler& eventHandler);
+
+ void HandleMap(EventHandler& eventHandler);
+ void HandleBlockMap(EventHandler& eventHandler);
+ void HandleFlowMap(EventHandler& eventHandler);
+ void HandleCompactMap(EventHandler& eventHandler);
+ void HandleCompactMapWithNoKey(EventHandler& eventHandler);
+
+ void ParseProperties(std::string& tag, anchor_t& anchor,
+ std::string& anchor_name);
+ void ParseTag(std::string& tag);
+ void ParseAnchor(anchor_t& anchor, std::string& anchor_name);
+
+ anchor_t RegisterAnchor(const std::string& name);
+ anchor_t LookupAnchor(const Mark& mark, const std::string& name) const;
+
+ private:
+ int depth = 0;
+ Scanner& m_scanner;
+ const Directives& m_directives;
+ std::unique_ptr<CollectionStack> m_pCollectionStack;
+
+ using Anchors = std::map<std::string, anchor_t>;
+ Anchors m_anchors;
+
+ anchor_t m_curAnchor;
+};
+} // namespace YAML
+
+#endif // SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include <iostream>
+
+#include "stream.h"
+
+#ifndef YAML_PREFETCH_SIZE
+#define YAML_PREFETCH_SIZE 2048
+#endif
+
+#define S_ARRAY_SIZE(A) (sizeof(A) / sizeof(*(A)))
+#define S_ARRAY_END(A) ((A) + S_ARRAY_SIZE(A))
+
+#define CP_REPLACEMENT_CHARACTER (0xFFFD)
+
+namespace YAML {
+enum UtfIntroState {
+ uis_start,
+ uis_utfbe_b1,
+ uis_utf32be_b2,
+ uis_utf32be_bom3,
+ uis_utf32be,
+ uis_utf16be,
+ uis_utf16be_bom1,
+ uis_utfle_bom1,
+ uis_utf16le_bom2,
+ uis_utf32le_bom3,
+ uis_utf16le,
+ uis_utf32le,
+ uis_utf8_imp,
+ uis_utf16le_imp,
+ uis_utf32le_imp3,
+ uis_utf8_bom1,
+ uis_utf8_bom2,
+ uis_utf8,
+ uis_error
+};
+
+enum UtfIntroCharType {
+ uict00,
+ uictBB,
+ uictBF,
+ uictEF,
+ uictFE,
+ uictFF,
+ uictAscii,
+ uictOther,
+ uictMax
+};
+
+static bool s_introFinalState[] = {
+ false, // uis_start
+ false, // uis_utfbe_b1
+ false, // uis_utf32be_b2
+ false, // uis_utf32be_bom3
+ true, // uis_utf32be
+ true, // uis_utf16be
+ false, // uis_utf16be_bom1
+ false, // uis_utfle_bom1
+ false, // uis_utf16le_bom2
+ false, // uis_utf32le_bom3
+ true, // uis_utf16le
+ true, // uis_utf32le
+ false, // uis_utf8_imp
+ false, // uis_utf16le_imp
+ false, // uis_utf32le_imp3
+ false, // uis_utf8_bom1
+ false, // uis_utf8_bom2
+ true, // uis_utf8
+ true, // uis_error
+};
+
+static UtfIntroState s_introTransitions[][uictMax] = {
+ // uict00, uictBB, uictBF, uictEF,
+ // uictFE, uictFF, uictAscii, uictOther
+ {uis_utfbe_b1, uis_utf8, uis_utf8, uis_utf8_bom1, uis_utf16be_bom1,
+ uis_utfle_bom1, uis_utf8_imp, uis_utf8},
+ {uis_utf32be_b2, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8,
+ uis_utf16be, uis_utf8},
+ {uis_utf32be, uis_utf8, uis_utf8, uis_utf8, uis_utf32be_bom3, uis_utf8,
+ uis_utf8, uis_utf8},
+ {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf32be, uis_utf8,
+ uis_utf8},
+ {uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be,
+ uis_utf32be, uis_utf32be, uis_utf32be},
+ {uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be,
+ uis_utf16be, uis_utf16be, uis_utf16be},
+ {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf16be, uis_utf8,
+ uis_utf8},
+ {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf16le_bom2, uis_utf8,
+ uis_utf8, uis_utf8},
+ {uis_utf32le_bom3, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le,
+ uis_utf16le, uis_utf16le, uis_utf16le},
+ {uis_utf32le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le,
+ uis_utf16le, uis_utf16le, uis_utf16le},
+ {uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le,
+ uis_utf16le, uis_utf16le, uis_utf16le},
+ {uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le,
+ uis_utf32le, uis_utf32le, uis_utf32le},
+ {uis_utf16le_imp, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8,
+ uis_utf8, uis_utf8},
+ {uis_utf32le_imp3, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le,
+ uis_utf16le, uis_utf16le, uis_utf16le},
+ {uis_utf32le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le,
+ uis_utf16le, uis_utf16le, uis_utf16le},
+ {uis_utf8, uis_utf8_bom2, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8,
+ uis_utf8},
+ {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8,
+ uis_utf8},
+ {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8,
+ uis_utf8},
+};
+
+static char s_introUngetCount[][uictMax] = {
+ // uict00, uictBB, uictBF, uictEF, uictFE, uictFF, uictAscii, uictOther
+ {0, 1, 1, 0, 0, 0, 0, 1}, {0, 2, 2, 2, 2, 2, 2, 2},
+ {3, 3, 3, 3, 0, 3, 3, 3}, {4, 4, 4, 4, 4, 0, 4, 4},
+ {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 1},
+ {2, 2, 2, 2, 2, 0, 2, 2}, {2, 2, 2, 2, 0, 2, 2, 2},
+ {0, 1, 1, 1, 1, 1, 1, 1}, {0, 2, 2, 2, 2, 2, 2, 2},
+ {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 1},
+ {0, 2, 2, 2, 2, 2, 2, 2}, {0, 3, 3, 3, 3, 3, 3, 3},
+ {4, 4, 4, 4, 4, 4, 4, 4}, {2, 0, 2, 2, 2, 2, 2, 2},
+ {3, 3, 0, 3, 3, 3, 3, 3}, {1, 1, 1, 1, 1, 1, 1, 1},
+};
+
+inline UtfIntroCharType IntroCharTypeOf(std::istream::int_type ch) {
+ if (std::istream::traits_type::eof() == ch) {
+ return uictOther;
+ }
+
+ switch (ch) {
+ case 0:
+ return uict00;
+ case 0xBB:
+ return uictBB;
+ case 0xBF:
+ return uictBF;
+ case 0xEF:
+ return uictEF;
+ case 0xFE:
+ return uictFE;
+ case 0xFF:
+ return uictFF;
+ }
+
+ if ((ch > 0) && (ch < 0xFF)) {
+ return uictAscii;
+ }
+
+ return uictOther;
+}
+
+inline char Utf8Adjust(unsigned long ch, unsigned char lead_bits,
+ unsigned char rshift) {
+ const unsigned char header =
+ static_cast<unsigned char>(((1 << lead_bits) - 1) << (8 - lead_bits));
+ const unsigned char mask = (0xFF >> (lead_bits + 1));
+ return static_cast<char>(
+ static_cast<unsigned char>(header | ((ch >> rshift) & mask)));
+}
+
+inline void QueueUnicodeCodepoint(std::deque<char>& q, unsigned long ch) {
+ // We are not allowed to queue the Stream::eof() codepoint, so
+ // replace it with CP_REPLACEMENT_CHARACTER
+ if (static_cast<unsigned long>(Stream::eof()) == ch) {
+ ch = CP_REPLACEMENT_CHARACTER;
+ }
+
+ if (ch < 0x80) {
+ q.push_back(Utf8Adjust(ch, 0, 0));
+ } else if (ch < 0x800) {
+ q.push_back(Utf8Adjust(ch, 2, 6));
+ q.push_back(Utf8Adjust(ch, 1, 0));
+ } else if (ch < 0x10000) {
+ q.push_back(Utf8Adjust(ch, 3, 12));
+ q.push_back(Utf8Adjust(ch, 1, 6));
+ q.push_back(Utf8Adjust(ch, 1, 0));
+ } else {
+ q.push_back(Utf8Adjust(ch, 4, 18));
+ q.push_back(Utf8Adjust(ch, 1, 12));
+ q.push_back(Utf8Adjust(ch, 1, 6));
+ q.push_back(Utf8Adjust(ch, 1, 0));
+ }
+}
+
+Stream::Stream(std::istream& input)
+ : m_input(input),
+ m_mark{},
+ m_charSet{},
+ m_readahead{},
+ m_pPrefetched(new unsigned char[YAML_PREFETCH_SIZE]),
+ m_nPrefetchedAvailable(0),
+ m_nPrefetchedUsed(0) {
+ using char_traits = std::istream::traits_type;
+
+ if (!input)
+ return;
+
+ // Determine (or guess) the character-set by reading the BOM, if any. See
+ // the YAML specification for the determination algorithm.
+ char_traits::int_type intro[4]{};
+ int nIntroUsed = 0;
+ UtfIntroState state = uis_start;
+ for (; !s_introFinalState[state];) {
+ std::istream::int_type ch = input.get();
+ intro[nIntroUsed++] = ch;
+ UtfIntroCharType charType = IntroCharTypeOf(ch);
+ UtfIntroState newState = s_introTransitions[state][charType];
+ int nUngets = s_introUngetCount[state][charType];
+ if (nUngets > 0) {
+ input.clear();
+ for (; nUngets > 0; --nUngets) {
+ if (char_traits::eof() != intro[--nIntroUsed])
+ input.putback(char_traits::to_char_type(intro[nIntroUsed]));
+ }
+ }
+ state = newState;
+ }
+
+ switch (state) {
+ case uis_utf8:
+ m_charSet = utf8;
+ break;
+ case uis_utf16le:
+ m_charSet = utf16le;
+ break;
+ case uis_utf16be:
+ m_charSet = utf16be;
+ break;
+ case uis_utf32le:
+ m_charSet = utf32le;
+ break;
+ case uis_utf32be:
+ m_charSet = utf32be;
+ break;
+ default:
+ m_charSet = utf8;
+ break;
+ }
+
+ ReadAheadTo(0);
+}
+
+Stream::~Stream() { delete[] m_pPrefetched; }
+
+char Stream::peek() const {
+ if (m_readahead.empty()) {
+ return Stream::eof();
+ }
+
+ return m_readahead[0];
+}
+
+Stream::operator bool() const {
+ return m_input.good() ||
+ (!m_readahead.empty() && m_readahead[0] != Stream::eof());
+}
+
+// get
+// . Extracts a character from the stream and updates our position
+char Stream::get() {
+ char ch = peek();
+ AdvanceCurrent();
+ m_mark.column++;
+
+ if (ch == '\n') {
+ m_mark.column = 0;
+ m_mark.line++;
+ }
+
+ return ch;
+}
+
+// get
+// . Extracts 'n' characters from the stream and updates our position
+std::string Stream::get(int n) {
+ std::string ret;
+ if (n > 0) {
+ ret.reserve(static_cast<std::string::size_type>(n));
+ for (int i = 0; i < n; i++)
+ ret += get();
+ }
+ return ret;
+}
+
+// eat
+// . Eats 'n' characters and updates our position.
+void Stream::eat(int n) {
+ for (int i = 0; i < n; i++)
+ get();
+}
+
+void Stream::AdvanceCurrent() {
+ if (!m_readahead.empty()) {
+ m_readahead.pop_front();
+ m_mark.pos++;
+ }
+
+ ReadAheadTo(0);
+}
+
+bool Stream::_ReadAheadTo(size_t i) const {
+ while (m_input.good() && (m_readahead.size() <= i)) {
+ switch (m_charSet) {
+ case utf8:
+ StreamInUtf8();
+ break;
+ case utf16le:
+ StreamInUtf16();
+ break;
+ case utf16be:
+ StreamInUtf16();
+ break;
+ case utf32le:
+ StreamInUtf32();
+ break;
+ case utf32be:
+ StreamInUtf32();
+ break;
+ }
+ }
+
+ // signal end of stream
+ if (!m_input.good())
+ m_readahead.push_back(Stream::eof());
+
+ return m_readahead.size() > i;
+}
+
+void Stream::StreamInUtf8() const {
+ unsigned char b = GetNextByte();
+ if (m_input.good()) {
+ m_readahead.push_back(static_cast<char>(b));
+ }
+}
+
+void Stream::StreamInUtf16() const {
+ unsigned long ch = 0;
+ unsigned char bytes[2];
+ int nBigEnd = (m_charSet == utf16be) ? 0 : 1;
+
+ bytes[0] = GetNextByte();
+ bytes[1] = GetNextByte();
+ if (!m_input.good()) {
+ return;
+ }
+ ch = (static_cast<unsigned long>(bytes[nBigEnd]) << 8) |
+ static_cast<unsigned long>(bytes[1 ^ nBigEnd]);
+
+ if (ch >= 0xDC00 && ch < 0xE000) {
+ // Trailing (low) surrogate...ugh, wrong order
+ QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER);
+ return;
+ }
+
+ if (ch >= 0xD800 && ch < 0xDC00) {
+ // ch is a leading (high) surrogate
+
+ // Four byte UTF-8 code point
+
+ // Read the trailing (low) surrogate
+ for (;;) {
+ bytes[0] = GetNextByte();
+ bytes[1] = GetNextByte();
+ if (!m_input.good()) {
+ QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER);
+ return;
+ }
+ unsigned long chLow = (static_cast<unsigned long>(bytes[nBigEnd]) << 8) |
+ static_cast<unsigned long>(bytes[1 ^ nBigEnd]);
+ if (chLow < 0xDC00 || chLow >= 0xE000) {
+ // Trouble...not a low surrogate. Dump a REPLACEMENT CHARACTER into the
+ // stream.
+ QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER);
+
+ // Deal with the next UTF-16 unit
+ if (chLow < 0xD800 || chLow >= 0xE000) {
+ // Easiest case: queue the codepoint and return
+ QueueUnicodeCodepoint(m_readahead, ch);
+ return;
+ }
+ // Start the loop over with the new high surrogate
+ ch = chLow;
+ continue;
+ }
+
+ // Select the payload bits from the high surrogate
+ ch &= 0x3FF;
+ ch <<= 10;
+
+ // Include bits from low surrogate
+ ch |= (chLow & 0x3FF);
+
+ // Add the surrogacy offset
+ ch += 0x10000;
+ break;
+ }
+ }
+
+ QueueUnicodeCodepoint(m_readahead, ch);
+}
+
+inline char* ReadBuffer(unsigned char* pBuffer) {
+ return reinterpret_cast<char*>(pBuffer);
+}
+
+unsigned char Stream::GetNextByte() const {
+ if (m_nPrefetchedUsed >= m_nPrefetchedAvailable) {
+ std::streambuf* pBuf = m_input.rdbuf();
+ m_nPrefetchedAvailable = static_cast<std::size_t>(
+ pBuf->sgetn(ReadBuffer(m_pPrefetched), YAML_PREFETCH_SIZE));
+ m_nPrefetchedUsed = 0;
+ if (!m_nPrefetchedAvailable) {
+ m_input.setstate(std::ios_base::eofbit);
+ }
+
+ if (0 == m_nPrefetchedAvailable) {
+ return 0;
+ }
+ }
+
+ return m_pPrefetched[m_nPrefetchedUsed++];
+}
+
+void Stream::StreamInUtf32() const {
+ static int indexes[2][4] = {{3, 2, 1, 0}, {0, 1, 2, 3}};
+
+ unsigned long ch = 0;
+ unsigned char bytes[4];
+ int* pIndexes = (m_charSet == utf32be) ? indexes[1] : indexes[0];
+
+ bytes[0] = GetNextByte();
+ bytes[1] = GetNextByte();
+ bytes[2] = GetNextByte();
+ bytes[3] = GetNextByte();
+ if (!m_input.good()) {
+ return;
+ }
+
+ for (int i = 0; i < 4; ++i) {
+ ch <<= 8;
+ ch |= bytes[pIndexes[i]];
+ }
+
+ QueueUnicodeCodepoint(m_readahead, ch);
+}
+} // namespace YAML
--- /dev/null
+#ifndef STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/mark.h"
+#include <cstddef>
+#include <deque>
+#include <ios>
+#include <iostream>
+#include <set>
+#include <string>
+
+namespace YAML {
+
+class StreamCharSource;
+
+class Stream {
+ public:
+ friend class StreamCharSource;
+
+ Stream(std::istream& input);
+ Stream(const Stream&) = delete;
+ Stream(Stream&&) = delete;
+ Stream& operator=(const Stream&) = delete;
+ Stream& operator=(Stream&&) = delete;
+ ~Stream();
+
+ operator bool() const;
+ bool operator!() const { return !static_cast<bool>(*this); }
+
+ char peek() const;
+ char get();
+ std::string get(int n);
+ void eat(int n = 1);
+
+ static char eof() { return 0x04; }
+
+ const Mark mark() const { return m_mark; }
+ int pos() const { return m_mark.pos; }
+ int line() const { return m_mark.line; }
+ int column() const { return m_mark.column; }
+ void ResetColumn() { m_mark.column = 0; }
+
+ private:
+ enum CharacterSet { utf8, utf16le, utf16be, utf32le, utf32be };
+
+ std::istream& m_input;
+ Mark m_mark;
+
+ CharacterSet m_charSet;
+ mutable std::deque<char> m_readahead;
+ unsigned char* const m_pPrefetched;
+ mutable size_t m_nPrefetchedAvailable;
+ mutable size_t m_nPrefetchedUsed;
+
+ void AdvanceCurrent();
+ char CharAt(size_t i) const;
+ bool ReadAheadTo(size_t i) const;
+ bool _ReadAheadTo(size_t i) const;
+ void StreamInUtf8() const;
+ void StreamInUtf16() const;
+ void StreamInUtf32() const;
+ unsigned char GetNextByte() const;
+};
+
+// CharAt
+// . Unchecked access
+inline char Stream::CharAt(size_t i) const { return m_readahead[i]; }
+
+inline bool Stream::ReadAheadTo(size_t i) const {
+ if (m_readahead.size() > i)
+ return true;
+ return _ReadAheadTo(i);
+}
+} // namespace YAML
+
+#endif // STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/noexcept.h"
+#include "stream.h"
+#include <cstddef>
+
+namespace YAML {
+
+class StreamCharSource {
+ public:
+ StreamCharSource(const Stream& stream) : m_offset(0), m_stream(stream) {}
+ StreamCharSource(const StreamCharSource& source) = default;
+ StreamCharSource(StreamCharSource&&) YAML_CPP_NOEXCEPT = default;
+ StreamCharSource& operator=(const StreamCharSource&) = delete;
+ StreamCharSource& operator=(StreamCharSource&&) = delete;
+ ~StreamCharSource() = default;
+
+ operator bool() const;
+ char operator[](std::size_t i) const { return m_stream.CharAt(m_offset + i); }
+ bool operator!() const { return !static_cast<bool>(*this); }
+
+ const StreamCharSource operator+(int i) const;
+
+ private:
+ std::size_t m_offset;
+ const Stream& m_stream;
+};
+
+inline StreamCharSource::operator bool() const {
+ return m_stream.ReadAheadTo(m_offset);
+}
+
+inline const StreamCharSource StreamCharSource::operator+(int i) const {
+ StreamCharSource source(*this);
+ if (static_cast<int>(source.m_offset) + i >= 0)
+ source.m_offset += static_cast<std::size_t>(i);
+ else
+ source.m_offset = 0;
+ return source;
+}
+} // namespace YAML
+
+#endif // STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <cstddef>
+
+namespace YAML {
+class StringCharSource {
+ public:
+ StringCharSource(const char* str, std::size_t size)
+ : m_str(str), m_size(size), m_offset(0) {}
+
+ operator bool() const { return m_offset < m_size; }
+ char operator[](std::size_t i) const { return m_str[m_offset + i]; }
+ bool operator!() const { return !static_cast<bool>(*this); }
+
+ const StringCharSource operator+(int i) const {
+ StringCharSource source(*this);
+ if (static_cast<int>(source.m_offset) + i >= 0)
+ source.m_offset += i;
+ else
+ source.m_offset = 0;
+ return source;
+ }
+
+ StringCharSource& operator++() {
+ ++m_offset;
+ return *this;
+ }
+
+ StringCharSource& operator+=(std::size_t offset) {
+ m_offset += offset;
+ return *this;
+ }
+
+ private:
+ const char* m_str;
+ std::size_t m_size;
+ std::size_t m_offset;
+};
+}
+
+#endif // STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#include <cassert>
+#include <stdexcept>
+
+#include "directives.h" // IWYU pragma: keep
+#include "tag.h"
+#include "token.h"
+
+namespace YAML {
+Tag::Tag(const Token& token)
+ : type(static_cast<TYPE>(token.data)), handle{}, value{} {
+ switch (type) {
+ case VERBATIM:
+ value = token.value;
+ break;
+ case PRIMARY_HANDLE:
+ value = token.value;
+ break;
+ case SECONDARY_HANDLE:
+ value = token.value;
+ break;
+ case NAMED_HANDLE:
+ handle = token.value;
+ value = token.params[0];
+ break;
+ case NON_SPECIFIC:
+ break;
+ default:
+ assert(false);
+ }
+}
+
+std::string Tag::Translate(const Directives& directives) {
+ switch (type) {
+ case VERBATIM:
+ return value;
+ case PRIMARY_HANDLE:
+ return directives.TranslateTagHandle("!") + value;
+ case SECONDARY_HANDLE:
+ return directives.TranslateTagHandle("!!") + value;
+ case NAMED_HANDLE:
+ return directives.TranslateTagHandle("!" + handle + "!") + value;
+ case NON_SPECIFIC:
+ // TODO:
+ return "!";
+ default:
+ assert(false);
+ }
+ throw std::runtime_error("yaml-cpp: internal error, bad tag type");
+}
+} // namespace YAML
--- /dev/null
+#ifndef TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include <string>
+
+namespace YAML {
+struct Directives;
+struct Token;
+
+struct Tag {
+ enum TYPE {
+ VERBATIM,
+ PRIMARY_HANDLE,
+ SECONDARY_HANDLE,
+ NAMED_HANDLE,
+ NON_SPECIFIC
+ };
+
+ Tag(const Token& token);
+ std::string Translate(const Directives& directives);
+
+ TYPE type;
+ std::string handle, value;
+};
+}
+
+#endif // TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+#ifndef TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+#define TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66
+
+#if defined(_MSC_VER) || \
+ (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \
+ (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
+#pragma once
+#endif
+
+#include "yaml-cpp/mark.h"
+#include <iostream>
+#include <string>
+#include <vector>
+
+namespace YAML {
+const std::string TokenNames[] = {
+ "DIRECTIVE", "DOC_START", "DOC_END", "BLOCK_SEQ_START",
+ "BLOCK_MAP_START", "BLOCK_SEQ_END", "BLOCK_MAP_END", "BLOCK_ENTRY",
+ "FLOW_SEQ_START", "FLOW_MAP_START", "FLOW_SEQ_END", "FLOW_MAP_END",
+ "FLOW_MAP_COMPACT", "FLOW_ENTRY", "KEY", "VALUE",
+ "ANCHOR", "ALIAS", "TAG", "SCALAR"};
+
+struct Token {
+ // enums
+ enum STATUS { VALID, INVALID, UNVERIFIED };
+ enum TYPE {
+ DIRECTIVE,
+ DOC_START,
+ DOC_END,
+ BLOCK_SEQ_START,
+ BLOCK_MAP_START,
+ BLOCK_SEQ_END,
+ BLOCK_MAP_END,
+ BLOCK_ENTRY,
+ FLOW_SEQ_START,
+ FLOW_MAP_START,
+ FLOW_SEQ_END,
+ FLOW_MAP_END,
+ FLOW_MAP_COMPACT,
+ FLOW_ENTRY,
+ KEY,
+ VALUE,
+ ANCHOR,
+ ALIAS,
+ TAG,
+ PLAIN_SCALAR,
+ NON_PLAIN_SCALAR
+ };
+
+ // data
+ Token(TYPE type_, const Mark& mark_)
+ : status(VALID), type(type_), mark(mark_), value{}, params{}, data(0) {}
+
+ friend std::ostream& operator<<(std::ostream& out, const Token& token) {
+ out << TokenNames[token.type] << std::string(": ") << token.value;
+ for (const std::string& param : token.params)
+ out << std::string(" ") << param;
+ return out;
+ }
+
+ STATUS status;
+ TYPE type;
+ Mark mark;
+ std::string value;
+ std::vector<std::string> params;
+ int data;
+};
+} // namespace YAML
+
+#endif // TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66
--- /dev/null
+cc_test(
+ name = "test",
+ srcs = glob([
+ "*.cpp",
+ "*.h",
+ "integrations/*.cpp",
+ "node/*.cpp",
+ ]),
+ deps = [
+ "//:yaml-cpp",
+ "//:yaml-cpp_internal",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
--- /dev/null
+find_package(Threads REQUIRED)
+
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+set(BUILD_MOCK ON CACHE BOOL "" FORCE)
+set(CMAKE_POLICY_DEFAULT_CMP0048 NEW)
+
+add_subdirectory(
+ "${CMAKE_CURRENT_SOURCE_DIR}/gtest-1.11.0"
+ "${CMAKE_CURRENT_BINARY_DIR}/prefix")
+
+include_directories(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/gtest-1.11.0/googletest/include")
+
+set(test-new-api-pattern "new-api/*.cpp")
+set(test-source-pattern "*.cpp" "integration/*.cpp" "node/*.cpp")
+if (CMAKE_VERSION VERSION_GREATER 3.11)
+ list(INSERT test-new-api-pattern 0 CONFIGURE_DEPENDS)
+ list(INSERT test-source-pattern 0 CONFIGURE_DEPENDS)
+endif()
+
+file(GLOB test-new-api-sources ${test-new-api-pattern})
+file(GLOB test-sources ${test-source-pattern})
+
+add_executable(yaml-cpp-tests "")
+target_sources(yaml-cpp-tests
+ PRIVATE
+ ${test-new-api-sources}
+ ${test-sources})
+target_include_directories(yaml-cpp-tests
+ PRIVATE
+ ${CMAKE_CURRENT_SOURCE_DIR}/integration
+ ${CMAKE_CURRENT_SOURCE_DIR}
+ ${PROJECT_SOURCE_DIR}/src)
+target_compile_options(yaml-cpp-tests
+ PRIVATE
+ $<$<CXX_COMPILER_ID:Clang>:-Wno-c99-extensions -Wno-variadic-macros -Wno-sign-compare>
+ $<$<CXX_COMPILER_ID:GNU>:-Wno-variadic-macros -Wno-sign-compare>)
+target_link_libraries(yaml-cpp-tests
+ PRIVATE
+ Threads::Threads
+ yaml-cpp
+ gmock)
+
+set_property(TARGET yaml-cpp-tests PROPERTY CXX_STANDARD_REQUIRED ON)
+if (NOT DEFINED CMAKE_CXX_STANDARD)
+ set_target_properties(yaml-cpp-tests PROPERTIES CXX_STANDARD 11)
+endif()
+
+
+add_test(NAME yaml-cpp::test COMMAND yaml-cpp-tests)
+
+if (build-windows-dll)
+ add_custom_command(
+ TARGET yaml-cpp-tests
+ POST_BUILD COMMAND ${CMAKE_COMMAND} -E
+ copy_if_different "$<TARGET_FILE:yaml-cpp>" "$<TARGET_FILE_DIR:yaml-cpp-tests>")
+endif()
--- /dev/null
+#include "gtest/gtest.h"
+#include <yaml-cpp/binary.h>
+
+TEST(BinaryTest, DecodingSimple) {
+ std::string input{90, 71, 86, 104, 90, 71, 74, 108, 90, 87, 89, 61};
+ const std::vector<unsigned char> &result = YAML::DecodeBase64(input);
+ EXPECT_EQ(std::string(result.begin(), result.end()), "deadbeef");
+}
+
+TEST(BinaryTest, DecodingNoCrashOnNegative) {
+ std::string input{-58, -1, -99, 109};
+ const std::vector<unsigned char> &result = YAML::DecodeBase64(input);
+ EXPECT_TRUE(result.empty());
+}
--- /dev/null
+import sys
+import yaml
+import hashlib
+
+DEFINE = 'YAML_GEN_TESTS'
+EVENT_COUNT = 5
+
+def encode_stream(line):
+ for c in line:
+ if c == '\n':
+ yield '\\n'
+ elif c == '"':
+ yield '\\"'
+ elif c == '\t':
+ yield '\\t'
+ elif ord(c) < 0x20:
+ yield '\\x' + hex(ord(c))
+ else:
+ yield c
+
+def encode(line):
+ return ''.join(encode_stream(line))
+
+def doc_start(implicit=False):
+ if implicit:
+ return {'emit': '', 'handle': 'OnDocumentStart(_)'}
+ else:
+ return {'emit': 'BeginDoc', 'handle': 'OnDocumentStart(_)'}
+
+def doc_end(implicit=False):
+ if implicit:
+ return {'emit': '', 'handle': 'OnDocumentEnd()'}
+ else:
+ return {'emit': 'EndDoc', 'handle': 'OnDocumentEnd()'}
+
+def scalar(value, tag='', anchor='', anchor_id=0):
+ emit = []
+ handle = []
+ if tag:
+ emit += ['VerbatimTag("%s")' % encode(tag)]
+ if anchor:
+ emit += ['Anchor("%s")' % encode(anchor)]
+ handle += ['OnAnchor(_, "%s")' % encode(anchor)]
+ if tag:
+ out_tag = encode(tag)
+ else:
+ if value == encode(value):
+ out_tag = '?'
+ else:
+ out_tag = '!'
+ emit += ['"%s"' % encode(value)]
+ handle += ['OnScalar(_, "%s", %s, "%s")' % (out_tag, anchor_id, encode(value))]
+ return {'emit': emit, 'handle': handle}
+
+def comment(value):
+ return {'emit': 'Comment("%s")' % value, 'handle': ''}
+
+def seq_start(tag='', anchor='', anchor_id=0, style='_'):
+ emit = []
+ handle = []
+ if tag:
+ emit += ['VerbatimTag("%s")' % encode(tag)]
+ if anchor:
+ emit += ['Anchor("%s")' % encode(anchor)]
+ handle += ['OnAnchor(_, "%s")' % encode(anchor)]
+ if tag:
+ out_tag = encode(tag)
+ else:
+ out_tag = '?'
+ emit += ['BeginSeq']
+ handle += ['OnSequenceStart(_, "%s", %s, %s)' % (out_tag, anchor_id, style)]
+ return {'emit': emit, 'handle': handle}
+
+def seq_end():
+ return {'emit': 'EndSeq', 'handle': 'OnSequenceEnd()'}
+
+def map_start(tag='', anchor='', anchor_id=0, style='_'):
+ emit = []
+ handle = []
+ if tag:
+ emit += ['VerbatimTag("%s")' % encode(tag)]
+ if anchor:
+ emit += ['Anchor("%s")' % encode(anchor)]
+ handle += ['OnAnchor(_, "%s")' % encode(anchor)]
+ if tag:
+ out_tag = encode(tag)
+ else:
+ out_tag = '?'
+ emit += ['BeginMap']
+ handle += ['OnMapStart(_, "%s", %s, %s)' % (out_tag, anchor_id, style)]
+ return {'emit': emit, 'handle': handle}
+
+def map_end():
+ return {'emit': 'EndMap', 'handle': 'OnMapEnd()'}
+
+def gen_templates():
+ yield [[doc_start(), doc_start(True)],
+ [scalar('foo'), scalar('foo\n'), scalar('foo', 'tag'), scalar('foo', '', 'anchor', 1)],
+ [doc_end(), doc_end(True)]]
+ yield [[doc_start(), doc_start(True)],
+ [seq_start()],
+ [[], [scalar('foo')], [scalar('foo', 'tag')], [scalar('foo', '', 'anchor', 1)], [scalar('foo', 'tag', 'anchor', 1)], [scalar('foo'), scalar('bar')], [scalar('foo', 'tag', 'anchor', 1), scalar('bar', 'tag', 'other', 2)]],
+ [seq_end()],
+ [doc_end(), doc_end(True)]]
+ yield [[doc_start(), doc_start(True)],
+ [map_start()],
+ [[], [scalar('foo'), scalar('bar')], [scalar('foo', 'tag', 'anchor', 1), scalar('bar', 'tag', 'other', 2)]],
+ [map_end()],
+ [doc_end(), doc_end(True)]]
+ yield [[doc_start(True)],
+ [map_start()],
+ [[scalar('foo')], [seq_start(), scalar('foo'), seq_end()], [map_start(), scalar('foo'), scalar('bar'), map_end()]],
+ [[scalar('foo')], [seq_start(), scalar('foo'), seq_end()], [map_start(), scalar('foo'), scalar('bar'), map_end()]],
+ [map_end()],
+ [doc_end(True)]]
+ yield [[doc_start(True)],
+ [seq_start()],
+ [[scalar('foo')], [seq_start(), scalar('foo'), seq_end()], [map_start(), scalar('foo'), scalar('bar'), map_end()]],
+ [[scalar('foo')], [seq_start(), scalar('foo'), seq_end()], [map_start(), scalar('foo'), scalar('bar'), map_end()]],
+ [seq_end()],
+ [doc_end(True)]]
+
+def expand(template):
+ if len(template) == 0:
+ pass
+ elif len(template) == 1:
+ for item in template[0]:
+ if isinstance(item, list):
+ yield item
+ else:
+ yield [item]
+ else:
+ for car in expand(template[:1]):
+ for cdr in expand(template[1:]):
+ yield car + cdr
+
+
+def gen_events():
+ for template in gen_templates():
+ for events in expand(template):
+ base = list(events)
+ for i in range(0, len(base)+1):
+ cpy = list(base)
+ cpy.insert(i, comment('comment'))
+ yield cpy
+
+def gen_tests():
+ for events in gen_events():
+ name = 'test' + hashlib.sha1(''.join(yaml.dump(event) for event in events)).hexdigest()[:20]
+ yield {'name': name, 'events': events}
+
+class Writer(object):
+ def __init__(self, out):
+ self.out = out
+ self.indent = 0
+
+ def writeln(self, s):
+ self.out.write('%s%s\n' % (' ' * self.indent, s))
+
+class Scope(object):
+ def __init__(self, writer, name, indent):
+ self.writer = writer
+ self.name = name
+ self.indent = indent
+
+ def __enter__(self):
+ self.writer.writeln('%s {' % self.name)
+ self.writer.indent += self.indent
+
+ def __exit__(self, type, value, traceback):
+ self.writer.indent -= self.indent
+ self.writer.writeln('}')
+
+def create_emitter_tests(out):
+ out = Writer(out)
+
+ includes = [
+ 'handler_test.h',
+ 'yaml-cpp/yaml.h',
+ 'gmock/gmock.h',
+ 'gtest/gtest.h',
+ ]
+ for include in includes:
+ out.writeln('#include "%s"' % include)
+ out.writeln('')
+
+ usings = [
+ '::testing::_',
+ ]
+ for using in usings:
+ out.writeln('using %s;' % using)
+ out.writeln('')
+
+ with Scope(out, 'namespace YAML', 0) as _:
+ with Scope(out, 'namespace', 0) as _:
+ out.writeln('')
+ out.writeln('typedef HandlerTest GenEmitterTest;')
+ out.writeln('')
+ tests = list(gen_tests())
+
+ for test in tests:
+ with Scope(out, 'TEST_F(%s, %s)' % ('GenEmitterTest', test['name']), 2) as _:
+ out.writeln('Emitter out;')
+ for event in test['events']:
+ emit = event['emit']
+ if isinstance(emit, list):
+ for e in emit:
+ out.writeln('out << %s;' % e)
+ elif emit:
+ out.writeln('out << %s;' % emit)
+ out.writeln('')
+ for event in test['events']:
+ handle = event['handle']
+ if isinstance(handle, list):
+ for e in handle:
+ out.writeln('EXPECT_CALL(handler, %s);' % e)
+ elif handle:
+ out.writeln('EXPECT_CALL(handler, %s);' % handle)
+ out.writeln('Parse(out.c_str());')
+ out.writeln('')
+
+if __name__ == '__main__':
+ create_emitter_tests(sys.stdout)
--- /dev/null
+#include "mock_event_handler.h"
+#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using ::testing::InSequence;
+using ::testing::NiceMock;
+using ::testing::StrictMock;
+
+namespace YAML {
+class HandlerTest : public ::testing::Test {
+ protected:
+ void Parse(const std::string& example) {
+ std::stringstream stream(example);
+ Parser parser(stream);
+ while (parser.HandleNextDocument(handler)) {
+ }
+ }
+
+ void IgnoreParse(const std::string& example) {
+ std::stringstream stream(example);
+ Parser parser(stream);
+ while (parser.HandleNextDocument(nice_handler)) {
+ }
+ }
+
+ InSequence sequence;
+ StrictMock<MockEventHandler> handler;
+ NiceMock<MockEventHandler> nice_handler;
+};
+}
--- /dev/null
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+#include "gtest/gtest.h"
+
+namespace YAML {
+namespace {
+
+class NullEventHandler : public EventHandler {
+ virtual void OnDocumentStart(const Mark&) {}
+ virtual void OnDocumentEnd() {}
+
+ virtual void OnNull(const Mark&, anchor_t) {}
+ virtual void OnAlias(const Mark&, anchor_t) {}
+ virtual void OnScalar(const Mark&, const std::string&, anchor_t,
+ const std::string&) {}
+
+ virtual void OnSequenceStart(const Mark&, const std::string&, anchor_t,
+ EmitterStyle::value /* style */) {}
+ virtual void OnSequenceEnd() {}
+
+ virtual void OnMapStart(const Mark&, const std::string&, anchor_t,
+ EmitterStyle::value /* style */) {}
+ virtual void OnMapEnd() {}
+};
+
+class EmitterTest : public ::testing::Test {
+ protected:
+ void ExpectEmit(const std::string& expected) {
+ EXPECT_EQ(expected, out.c_str());
+ EXPECT_TRUE(out.good()) << "Emitter raised: " << out.GetLastError();
+ if (expected == out.c_str()) {
+ std::stringstream stream(expected);
+ Parser parser;
+ NullEventHandler handler;
+ parser.HandleNextDocument(handler);
+ }
+ }
+
+ Emitter out;
+};
+
+TEST_F(EmitterTest, SimpleScalar) {
+ out << "Hello, World!";
+
+ ExpectEmit("Hello, World!");
+}
+
+TEST_F(EmitterTest, SimpleQuotedScalar) {
+ Node n(Load("\"test\""));
+ out << n;
+ ExpectEmit("test");
+}
+
+TEST_F(EmitterTest, DumpAndSize) {
+ Node n(Load("test"));
+ EXPECT_EQ("test", Dump(n));
+ out << n;
+ EXPECT_EQ(4, out.size());
+}
+
+TEST_F(EmitterTest, NullScalar) {
+ Node n(Load("null"));
+ out << n;
+ ExpectEmit("~");
+}
+
+TEST_F(EmitterTest, AliasScalar) {
+ Node n(Load("[&a str, *a]"));
+ out << n;
+ ExpectEmit("[&1 str, *1]");
+}
+
+TEST_F(EmitterTest, StringFormat) {
+ out << BeginSeq;
+ out.SetStringFormat(SingleQuoted);
+ out << "string";
+ out.SetStringFormat(DoubleQuoted);
+ out << "string";
+ out.SetStringFormat(Literal);
+ out << "string";
+ out << EndSeq;
+
+ ExpectEmit("- 'string'\n- \"string\"\n- |\n string");
+}
+
+TEST_F(EmitterTest, IntBase) {
+ out << BeginSeq;
+ out.SetIntBase(Dec);
+ out << 1024;
+ out.SetIntBase(Hex);
+ out << 1024;
+ out.SetIntBase(Oct);
+ out << 1024;
+ out << EndSeq;
+
+ ExpectEmit("- 1024\n- 0x400\n- 02000");
+}
+
+TEST_F(EmitterTest, NumberPrecision) {
+ out.SetFloatPrecision(3);
+ out.SetDoublePrecision(2);
+ out << BeginSeq;
+ out << 3.1425926f;
+ out << 53.5893;
+ out << 2384626.4338;
+ out << EndSeq;
+
+ ExpectEmit("- 3.14\n- 54\n- 2.4e+06");
+}
+
+TEST_F(EmitterTest, SimpleSeq) {
+ out << BeginSeq;
+ out << "eggs";
+ out << "bread";
+ out << "milk";
+ out << EndSeq;
+
+ ExpectEmit("- eggs\n- bread\n- milk");
+}
+
+TEST_F(EmitterTest, SimpleFlowSeq) {
+ out << Flow;
+ out << BeginSeq;
+ out << "Larry";
+ out << "Curly";
+ out << "Moe";
+ out << EndSeq;
+
+ ExpectEmit("[Larry, Curly, Moe]");
+}
+
+TEST_F(EmitterTest, EmptyFlowSeq) {
+ out << Flow;
+ out << BeginSeq;
+ out << EndSeq;
+
+ ExpectEmit("[]");
+}
+
+TEST_F(EmitterTest, EmptyBlockSeqWithBegunContent) {
+ out << BeginSeq;
+ out << BeginSeq << Comment("comment") << EndSeq;
+ out << BeginSeq << Newline << EndSeq;
+ out << EndSeq;
+
+ ExpectEmit(R"(-
+# comment
+ []
+-
+
+ [])");
+}
+
+TEST_F(EmitterTest, EmptyBlockMapWithBegunContent) {
+ out << BeginSeq;
+ out << BeginMap << Comment("comment") << EndMap;
+ out << BeginMap << Newline << EndMap;
+ out << EndSeq;
+
+ ExpectEmit(R"(- # comment
+ {}
+-
+ {})");
+}
+
+TEST_F(EmitterTest, EmptyFlowSeqWithBegunContent) {
+ out << Flow;
+ out << BeginSeq;
+ out << BeginSeq << Comment("comment") << EndSeq;
+ out << BeginSeq << Newline << EndSeq;
+ out << EndSeq;
+
+ ExpectEmit(R"([[ # comment
+ ], [
+ ]])");
+}
+
+TEST_F(EmitterTest, EmptyFlowMapWithBegunContent) {
+ out << Flow;
+ out << BeginSeq;
+ out << BeginMap << Comment("comment") << EndMap;
+ out << BeginMap << Newline << EndMap;
+ out << EndSeq;
+
+ ExpectEmit(R"([{ # comment
+ }, {
+ }])");
+}
+
+TEST_F(EmitterTest, NestedBlockSeq) {
+ out << BeginSeq;
+ out << "item 1";
+ out << BeginSeq << "subitem 1"
+ << "subitem 2" << EndSeq;
+ out << EndSeq;
+
+ ExpectEmit("- item 1\n-\n - subitem 1\n - subitem 2");
+}
+
+TEST_F(EmitterTest, NestedFlowSeq) {
+ out << BeginSeq;
+ out << "one";
+ out << Flow << BeginSeq << "two"
+ << "three" << EndSeq;
+ out << EndSeq;
+
+ ExpectEmit("- one\n- [two, three]");
+}
+
+TEST_F(EmitterTest, SimpleMap) {
+ out << BeginMap;
+ out << Key << "name";
+ out << Value << "Ryan Braun";
+ out << Key << "position";
+ out << Value << "3B";
+ out << EndMap;
+
+ ExpectEmit("name: Ryan Braun\nposition: 3B");
+}
+
+TEST_F(EmitterTest, SimpleFlowMap) {
+ out << Flow;
+ out << BeginMap;
+ out << Key << "shape";
+ out << Value << "square";
+ out << Key << "color";
+ out << Value << "blue";
+ out << EndMap;
+
+ ExpectEmit("{shape: square, color: blue}");
+}
+
+TEST_F(EmitterTest, MapAndList) {
+ out << BeginMap;
+ out << Key << "name";
+ out << Value << "Barack Obama";
+ out << Key << "children";
+ out << Value << BeginSeq << "Sasha"
+ << "Malia" << EndSeq;
+ out << EndMap;
+
+ ExpectEmit("name: Barack Obama\nchildren:\n - Sasha\n - Malia");
+}
+
+TEST_F(EmitterTest, ListAndMap) {
+ out << BeginSeq;
+ out << "item 1";
+ out << BeginMap;
+ out << Key << "pens" << Value << 8;
+ out << Key << "pencils" << Value << 14;
+ out << EndMap;
+ out << "item 2";
+ out << EndSeq;
+
+ ExpectEmit("- item 1\n- pens: 8\n pencils: 14\n- item 2");
+}
+
+TEST_F(EmitterTest, NestedBlockMap) {
+ out << BeginMap;
+ out << Key << "name";
+ out << Value << "Fred";
+ out << Key << "grades";
+ out << Value;
+ out << BeginMap;
+ out << Key << "algebra" << Value << "A";
+ out << Key << "physics" << Value << "C+";
+ out << Key << "literature" << Value << "B";
+ out << EndMap;
+ out << EndMap;
+
+ ExpectEmit(
+ "name: Fred\ngrades:\n algebra: A\n physics: C+\n literature: B");
+}
+
+TEST_F(EmitterTest, NestedFlowMap) {
+ out << Flow;
+ out << BeginMap;
+ out << Key << "name";
+ out << Value << "Fred";
+ out << Key << "grades";
+ out << Value;
+ out << BeginMap;
+ out << Key << "algebra" << Value << "A";
+ out << Key << "physics" << Value << "C+";
+ out << Key << "literature" << Value << "B";
+ out << EndMap;
+ out << EndMap;
+
+ ExpectEmit("{name: Fred, grades: {algebra: A, physics: C+, literature: B}}");
+}
+
+TEST_F(EmitterTest, MapListMix) {
+ out << BeginMap;
+ out << Key << "name";
+ out << Value << "Bob";
+ out << Key << "position";
+ out << Value;
+ out << Flow << BeginSeq << 2 << 4 << EndSeq;
+ out << Key << "invincible" << Value << OnOffBool << false;
+ out << EndMap;
+
+ ExpectEmit("name: Bob\nposition: [2, 4]\ninvincible: off");
+}
+
+TEST_F(EmitterTest, SimpleLongKey) {
+ out << LongKey;
+ out << BeginMap;
+ out << Key << "height";
+ out << Value << "5'9\"";
+ out << Key << "weight";
+ out << Value << 145;
+ out << EndMap;
+
+ ExpectEmit("? height\n: 5'9\"\n? weight\n: 145");
+}
+
+TEST_F(EmitterTest, SingleLongKey) {
+ const std::string shortKey(1024, 'a');
+ const std::string longKey(1025, 'a');
+ out << BeginMap;
+ out << Key << "age";
+ out << Value << "24";
+ out << LongKey << Key << "height";
+ out << Value << "5'9\"";
+ out << Key << "weight";
+ out << Value << 145;
+ out << Key << shortKey;
+ out << Value << "1";
+ out << Key << longKey;
+ out << Value << "1";
+ out << EndMap;
+
+ ExpectEmit("age: 24\n? height\n: 5'9\"\nweight: 145\n" + shortKey +
+ ": 1\n? " + longKey + "\n: 1");
+}
+
+TEST_F(EmitterTest, ComplexLongKey) {
+ out << LongKey;
+ out << BeginMap;
+ out << Key << BeginSeq << 1 << 3 << EndSeq;
+ out << Value << "monster";
+ out << Key << Flow << BeginSeq << 2 << 0 << EndSeq;
+ out << Value << "demon";
+ out << EndMap;
+
+ ExpectEmit("? - 1\n - 3\n: monster\n? [2, 0]\n: demon");
+}
+
+TEST_F(EmitterTest, AutoLongKey) {
+ out << BeginMap;
+ out << Key << BeginSeq << 1 << 3 << EndSeq;
+ out << Value << "monster";
+ out << Key << Flow << BeginSeq << 2 << 0 << EndSeq;
+ out << Value << "demon";
+ out << Key << "the origin";
+ out << Value << "angel";
+ out << EndMap;
+
+ ExpectEmit("? - 1\n - 3\n: monster\n[2, 0]: demon\nthe origin: angel");
+}
+
+TEST_F(EmitterTest, ScalarFormat) {
+ out << BeginSeq;
+ out << "simple scalar";
+ out << SingleQuoted << "explicit single-quoted scalar";
+ out << DoubleQuoted << "explicit double-quoted scalar";
+ out << "auto-detected\ndouble-quoted scalar";
+ out << "a non-\"auto-detected\" double-quoted scalar";
+ out << Literal
+ << "literal scalar\nthat may span\nmany, many\nlines "
+ "and have \"whatever\" crazy\tsymbols that we like";
+ out << EndSeq;
+
+ ExpectEmit(
+ "- simple scalar\n- 'explicit single-quoted scalar'\n- \"explicit "
+ "double-quoted scalar\"\n- \"auto-detected\\ndouble-quoted "
+ "scalar\"\n- a "
+ "non-\"auto-detected\" double-quoted scalar\n- |\n literal scalar\n "
+ " "
+ "that may span\n many, many\n lines and have \"whatever\" "
+ "crazy\tsymbols that we like");
+}
+
+TEST_F(EmitterTest, LiteralWithoutTrailingSpaces) {
+ out << YAML::BeginMap;
+ out << YAML::Key << "key";
+ out << YAML::Value << YAML::Literal;
+ out << "expect that with two newlines\n\n"
+ "no spaces are emitted in the empty line";
+ out << YAML::EndMap;
+
+ ExpectEmit(
+ "key: |\n"
+ " expect that with two newlines\n\n"
+ " no spaces are emitted in the empty line");
+}
+
+TEST_F(EmitterTest, AutoLongKeyScalar) {
+ out << BeginMap;
+ out << Key << Literal << "multi-line\nscalar";
+ out << Value << "and its value";
+ out << EndMap;
+
+ ExpectEmit("? |\n multi-line\n scalar\n: and its value");
+}
+
+TEST_F(EmitterTest, LongKeyFlowMap) {
+ out << Flow;
+ out << BeginMap;
+ out << Key << "simple key";
+ out << Value << "and value";
+ out << LongKey << Key << "long key";
+ out << Value << "and its value";
+ out << EndMap;
+
+ ExpectEmit("{simple key: and value, ? long key: and its value}");
+}
+
+TEST_F(EmitterTest, BlockMapAsKey) {
+ out << BeginMap;
+ out << Key;
+ out << BeginMap;
+ out << Key << "key" << Value << "value";
+ out << Key << "next key" << Value << "next value";
+ out << EndMap;
+ out << Value;
+ out << "total value";
+ out << EndMap;
+
+ ExpectEmit("? key: value\n next key: next value\n: total value");
+}
+
+TEST_F(EmitterTest, TaggedBlockMapAsKey) {
+ out << BeginMap;
+ out << Key;
+ out << LocalTag("innerMap");
+ out << BeginMap;
+ out << Key << "key" << Value << "value";
+ out << EndMap;
+ out << Value;
+ out << "outerValue";
+ out << EndMap;
+
+ ExpectEmit(R"(? !innerMap
+ key: value
+: outerValue)");
+}
+
+TEST_F(EmitterTest, TaggedBlockListAsKey) {
+ out << BeginMap;
+ out << Key;
+ out << LocalTag("innerList");
+ out << BeginSeq;
+ out << "listItem";
+ out << EndSeq;
+ out << Value;
+ out << "outerValue";
+ out << EndMap;
+
+ ExpectEmit(R"(? !innerList
+ - listItem
+: outerValue)");
+}
+
+TEST_F(EmitterTest, AliasAndAnchor) {
+ out << BeginSeq;
+ out << Anchor("fred");
+ out << BeginMap;
+ out << Key << "name" << Value << "Fred";
+ out << Key << "age" << Value << 42;
+ out << EndMap;
+ out << Alias("fred");
+ out << EndSeq;
+
+ ExpectEmit("- &fred\n name: Fred\n age: 42\n- *fred");
+}
+
+TEST_F(EmitterTest, AliasOnKey) {
+ out << BeginSeq;
+ out << Anchor("name") << "Name";
+ out << BeginMap;
+ out << Key << Alias("name") << Value << "Fred";
+ out << EndMap;
+ out << Flow << BeginMap;
+ out << Key << Alias("name") << Value << "Mike";
+ out << EndMap;
+ out << EndSeq;
+ ExpectEmit(R"(- &name Name
+- *name : Fred
+- {*name : Mike})");
+}
+
+TEST_F(EmitterTest, AliasAndAnchorWithNull) {
+ out << BeginSeq;
+ out << Anchor("fred") << Null;
+ out << Alias("fred");
+ out << EndSeq;
+
+ ExpectEmit("- &fred ~\n- *fred");
+}
+
+TEST_F(EmitterTest, AliasAndAnchorInFlow) {
+ out << Flow << BeginSeq;
+ out << Anchor("fred");
+ out << BeginMap;
+ out << Key << "name" << Value << "Fred";
+ out << Key << "age" << Value << 42;
+ out << EndMap;
+ out << Alias("fred");
+ out << EndSeq;
+
+ ExpectEmit("[&fred {name: Fred, age: 42}, *fred]");
+}
+
+TEST_F(EmitterTest, SimpleVerbatimTag) {
+ out << VerbatimTag("!foo") << "bar";
+
+ ExpectEmit("!<!foo> bar");
+}
+
+TEST_F(EmitterTest, VerbatimTagInBlockSeq) {
+ out << BeginSeq;
+ out << VerbatimTag("!foo") << "bar";
+ out << "baz";
+ out << EndSeq;
+
+ ExpectEmit("- !<!foo> bar\n- baz");
+}
+
+TEST_F(EmitterTest, VerbatimTagInFlowSeq) {
+ out << Flow << BeginSeq;
+ out << VerbatimTag("!foo") << "bar";
+ out << "baz";
+ out << EndSeq;
+
+ ExpectEmit("[!<!foo> bar, baz]");
+}
+
+TEST_F(EmitterTest, VerbatimTagInFlowSeqWithNull) {
+ out << Flow << BeginSeq;
+ out << VerbatimTag("!foo") << Null;
+ out << "baz";
+ out << EndSeq;
+
+ ExpectEmit("[!<!foo> ~, baz]");
+}
+
+TEST_F(EmitterTest, VerbatimTagInBlockMap) {
+ out << BeginMap;
+ out << Key << VerbatimTag("!foo") << "bar";
+ out << Value << VerbatimTag("!waz") << "baz";
+ out << EndMap;
+
+ ExpectEmit("? !<!foo> bar\n: !<!waz> baz");
+}
+
+TEST_F(EmitterTest, VerbatimTagInFlowMap) {
+ out << Flow << BeginMap;
+ out << Key << VerbatimTag("!foo") << "bar";
+ out << Value << "baz";
+ out << EndMap;
+
+ ExpectEmit("{!<!foo> bar: baz}");
+}
+
+TEST_F(EmitterTest, VerbatimTagInFlowMapWithNull) {
+ out << Flow << BeginMap;
+ out << Key << VerbatimTag("!foo") << Null;
+ out << Value << "baz";
+ out << EndMap;
+
+ ExpectEmit("{!<!foo> ~: baz}");
+}
+
+TEST_F(EmitterTest, VerbatimTagWithEmptySeq) {
+ out << VerbatimTag("!foo") << BeginSeq << EndSeq;
+
+ ExpectEmit("!<!foo>\n[]");
+}
+
+TEST_F(EmitterTest, VerbatimTagWithEmptyMap) {
+ out << VerbatimTag("!bar") << BeginMap << EndMap;
+
+ ExpectEmit("!<!bar>\n{}");
+}
+
+TEST_F(EmitterTest, VerbatimTagWithEmptySeqAndMap) {
+ out << BeginSeq;
+ out << VerbatimTag("!foo") << BeginSeq << EndSeq;
+ out << VerbatimTag("!bar") << BeginMap << EndMap;
+ out << EndSeq;
+
+ ExpectEmit("- !<!foo>\n []\n- !<!bar>\n {}");
+}
+
+TEST_F(EmitterTest, ByKindTagWithScalar) {
+ out << BeginSeq;
+ out << DoubleQuoted << "12";
+ out << "12";
+ out << TagByKind << "12";
+ out << EndSeq;
+
+ ExpectEmit("- \"12\"\n- 12\n- ! 12");
+}
+
+TEST_F(EmitterTest, LocalTagInNameHandle) {
+ out << LocalTag("a", "foo") << "bar";
+
+ ExpectEmit("!a!foo bar");
+}
+
+TEST_F(EmitterTest, LocalTagWithScalar) {
+ out << LocalTag("foo") << "bar";
+
+ ExpectEmit("!foo bar");
+}
+
+TEST_F(EmitterTest, ComplexDoc) {
+ out << BeginMap;
+ out << Key << "receipt";
+ out << Value << "Oz-Ware Purchase Invoice";
+ out << Key << "date";
+ out << Value << "2007-08-06";
+ out << Key << "customer";
+ out << Value;
+ out << BeginMap;
+ out << Key << "given";
+ out << Value << "Dorothy";
+ out << Key << "family";
+ out << Value << "Gale";
+ out << EndMap;
+ out << Key << "items";
+ out << Value;
+ out << BeginSeq;
+ out << BeginMap;
+ out << Key << "part_no";
+ out << Value << "A4786";
+ out << Key << "descrip";
+ out << Value << "Water Bucket (Filled)";
+ out << Key << "price";
+ out << Value << 1.47;
+ out << Key << "quantity";
+ out << Value << 4;
+ out << EndMap;
+ out << BeginMap;
+ out << Key << "part_no";
+ out << Value << "E1628";
+ out << Key << "descrip";
+ out << Value << "High Heeled \"Ruby\" Slippers";
+ out << Key << "price";
+ out << Value << 100.27;
+ out << Key << "quantity";
+ out << Value << 1;
+ out << EndMap;
+ out << EndSeq;
+ out << Key << "bill-to";
+ out << Value << Anchor("id001");
+ out << BeginMap;
+ out << Key << "street";
+ out << Value << Literal << "123 Tornado Alley\nSuite 16";
+ out << Key << "city";
+ out << Value << "East Westville";
+ out << Key << "state";
+ out << Value << "KS";
+ out << EndMap;
+ out << Key << "ship-to";
+ out << Value << Alias("id001");
+ out << EndMap;
+
+ ExpectEmit(
+ "receipt: Oz-Ware Purchase Invoice\ndate: 2007-08-06\ncustomer:\n "
+ "given: Dorothy\n family: Gale\nitems:\n - part_no: A4786\n "
+ "descrip: Water Bucket (Filled)\n price: 1.47\n quantity: 4\n - "
+ "part_no: E1628\n descrip: High Heeled \"Ruby\" Slippers\n price: "
+ "100.27\n quantity: 1\nbill-to: &id001\n street: |\n 123 Tornado "
+ "Alley\n Suite 16\n city: East Westville\n state: KS\nship-to: "
+ "*id001");
+}
+
+TEST_F(EmitterTest, STLContainers) {
+ out << BeginSeq;
+ std::vector<int> primes;
+ primes.push_back(2);
+ primes.push_back(3);
+ primes.push_back(5);
+ primes.push_back(7);
+ primes.push_back(11);
+ primes.push_back(13);
+ out << Flow << primes;
+ std::map<std::string, int> ages;
+ ages["Daniel"] = 26;
+ ages["Jesse"] = 24;
+ out << ages;
+ out << EndSeq;
+
+ ExpectEmit("- [2, 3, 5, 7, 11, 13]\n- Daniel: 26\n Jesse: 24");
+}
+
+TEST_F(EmitterTest, CommentStyle) {
+ out.SetPreCommentIndent(1);
+ out.SetPostCommentIndent(2);
+ out << BeginMap;
+ out << Key << "method";
+ out << Value << "least squares" << Comment("should we change this method?");
+ out << EndMap;
+
+ ExpectEmit("method: least squares # should we change this method?");
+}
+
+TEST_F(EmitterTest, SimpleComment) {
+ out << BeginMap;
+ out << Key << "method";
+ out << Value << "least squares" << Comment("should we change this method?");
+ out << EndMap;
+
+ ExpectEmit("method: least squares # should we change this method?");
+}
+
+TEST_F(EmitterTest, MultiLineComment) {
+ out << BeginSeq;
+ out << "item 1"
+ << Comment(
+ "really really long\ncomment that couldn't "
+ "possibly\nfit on one line");
+ out << "item 2";
+ out << EndSeq;
+
+ ExpectEmit(
+ "- item 1 # really really long\n # comment that couldn't "
+ "possibly\n # fit on one line\n- item 2");
+}
+
+TEST_F(EmitterTest, ComplexComments) {
+ out << BeginMap;
+ out << LongKey << Key << "long key" << Comment("long key");
+ out << Value << "value";
+ out << EndMap;
+
+ ExpectEmit("? long key # long key\n: value");
+}
+
+TEST_F(EmitterTest, InitialComment) {
+ out << Comment("A comment describing the purpose of the file.");
+ out << BeginMap << Key << "key" << Value << "value" << EndMap;
+
+ ExpectEmit("# A comment describing the purpose of the file.\nkey: value");
+}
+
+TEST_F(EmitterTest, InitialCommentWithDocIndicator) {
+ out << BeginDoc << Comment("A comment describing the purpose of the file.");
+ out << BeginMap << Key << "key" << Value << "value" << EndMap;
+
+ ExpectEmit(
+ "---\n# A comment describing the purpose of the file.\nkey: value");
+}
+
+TEST_F(EmitterTest, CommentInFlowSeq) {
+ out << Flow << BeginSeq << "foo" << Comment("foo!") << "bar" << EndSeq;
+
+ ExpectEmit("[foo, # foo!\nbar]");
+}
+
+TEST_F(EmitterTest, CommentInFlowMap) {
+ out << Flow << BeginMap;
+ out << Key << "foo" << Value << "foo value";
+ out << Key << "bar" << Value << "bar value" << Comment("bar!");
+ out << Key << "baz" << Value << "baz value" << Comment("baz!");
+ out << EndMap;
+
+ ExpectEmit(
+ "{foo: foo value, bar: bar value, # bar!\nbaz: baz value, # baz!\n}");
+}
+
+TEST_F(EmitterTest, Indentation) {
+ out << Indent(4);
+ out << BeginSeq;
+ out << BeginMap;
+ out << Key << "key 1" << Value << "value 1";
+ out << Key << "key 2" << Value << BeginSeq << "a"
+ << "b"
+ << "c" << EndSeq;
+ out << EndMap;
+ out << EndSeq;
+
+ ExpectEmit(
+ "- key 1: value 1\n key 2:\n - a\n - b\n - "
+ " c");
+}
+
+TEST_F(EmitterTest, SimpleGlobalSettings) {
+ out.SetIndent(4);
+ out.SetMapFormat(LongKey);
+
+ out << BeginSeq;
+ out << BeginMap;
+ out << Key << "key 1" << Value << "value 1";
+ out << Key << "key 2" << Value << Flow << BeginSeq << "a"
+ << "b"
+ << "c" << EndSeq;
+ out << EndMap;
+ out << EndSeq;
+
+ ExpectEmit("- ? key 1\n : value 1\n ? key 2\n : [a, b, c]");
+}
+
+TEST_F(EmitterTest, GlobalLongKeyOnSeq) {
+ out.SetMapFormat(LongKey);
+
+ out << BeginMap;
+ out << Key << Anchor("key");
+ out << BeginSeq << "a"
+ << "b" << EndSeq;
+ out << Value << Anchor("value");
+ out << BeginSeq << "c"
+ << "d" << EndSeq;
+ out << Key << Alias("key") << Value << Alias("value");
+ out << EndMap;
+
+ ExpectEmit(R"(? &key
+ - a
+ - b
+: &value
+ - c
+ - d
+? *key
+: *value)");
+}
+
+TEST_F(EmitterTest, GlobalLongKeyOnMap) {
+ out.SetMapFormat(LongKey);
+
+ out << BeginMap;
+ out << Key << Anchor("key");
+ out << BeginMap << "a"
+ << "b" << EndMap;
+ out << Value << Anchor("value");
+ out << BeginMap << "c"
+ << "d" << EndMap;
+ out << Key << Alias("key") << Value << Alias("value");
+ out << EndMap;
+
+ ExpectEmit(R"(? &key
+ ? a
+ : b
+: &value
+ ? c
+ : d
+? *key
+: *value)");
+}
+
+TEST_F(EmitterTest, GlobalSettingStyleOnSeqNode) {
+ Node n(Load(R"(foo:
+ - 1
+ - 2
+ - 3
+bar: aa)"));
+ out.SetSeqFormat(YAML::Flow);
+ out << n;
+ ExpectEmit(R"(foo: [1, 2, 3]
+bar: aa)");
+}
+
+TEST_F(EmitterTest, GlobalSettingStyleOnMapNode) {
+ Node n(Load(R"(-
+ foo: a
+ bar: b
+- 2
+- 3)"));
+ out.SetMapFormat(YAML::Flow);
+ out << n;
+ ExpectEmit(R"(- {foo: a, bar: b}
+- 2
+- 3)");
+}
+
+TEST_F(EmitterTest, ComplexGlobalSettings) {
+ out << BeginSeq;
+ out << Block;
+ out << BeginMap;
+ out << Key << "key 1" << Value << "value 1";
+ out << Key << "key 2" << Value;
+ out.SetSeqFormat(Flow);
+ out << BeginSeq << "a"
+ << "b"
+ << "c" << EndSeq;
+ out << EndMap;
+ out << BeginMap;
+ out << Key << BeginSeq << 1 << 2 << EndSeq;
+ out << Value << BeginMap << Key << "a" << Value << "b" << EndMap;
+ out << EndMap;
+ out << EndSeq;
+
+ ExpectEmit("- key 1: value 1\n key 2: [a, b, c]\n- [1, 2]:\n a: b");
+}
+
+TEST_F(EmitterTest, Null) {
+ out << BeginSeq;
+ out << Null;
+ out << BeginMap;
+ out << Key << "null value" << Value << Null;
+ out << Key << Null << Value << "null key";
+ out << EndMap;
+ out << EndSeq;
+
+ ExpectEmit("- ~\n- null value: ~\n ~: null key");
+}
+
+TEST_F(EmitterTest, OutputCharset) {
+ out << BeginSeq;
+ out.SetOutputCharset(EmitNonAscii);
+ out << "\x24 \xC2\xA2 \xE2\x82\xAC";
+ out.SetOutputCharset(EscapeNonAscii);
+ out << "\x24 \xC2\xA2 \xE2\x82\xAC";
+ out << EndSeq;
+
+ ExpectEmit("- \x24 \xC2\xA2 \xE2\x82\xAC\n- \"\x24 \\xa2 \\u20ac\"");
+}
+
+TEST_F(EmitterTest, EscapedUnicode) {
+ out << EscapeNonAscii << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
+
+ ExpectEmit("\"$ \\xa2 \\u20ac \\U00024b62\"");
+}
+
+TEST_F(EmitterTest, Unicode) {
+ out << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
+ ExpectEmit("\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2");
+}
+
+TEST_F(EmitterTest, DoubleQuotedUnicode) {
+ out << DoubleQuoted << "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
+ ExpectEmit("\"\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2\"");
+}
+
+TEST_F(EmitterTest, EscapedJsonString) {
+ out.SetStringFormat(DoubleQuoted);
+ out.SetOutputCharset(EscapeAsJson);
+ out << "\" \\ "
+ "\x01 \x02 \x03 \x04 \x05 \x06 \x07 \x08 \x09 \x0A \x0B \x0C \x0D \x0E \x0F "
+ "\x10 \x11 \x12 \x13 \x14 \x15 \x16 \x17 \x18 \x19 \x1A \x1B \x1C \x1D \x1E \x1F "
+ "\x24 \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2";
+
+ ExpectEmit(R"("\" \\ \u0001 \u0002 \u0003 \u0004 \u0005 \u0006 \u0007 \b \t )"
+ R"(\n \u000b \f \r \u000e \u000f \u0010 \u0011 \u0012 \u0013 )"
+ R"(\u0014 \u0015 \u0016 \u0017 \u0018 \u0019 \u001a \u001b )"
+ R"(\u001c \u001d \u001e \u001f )"
+ "$ \xC2\xA2 \xE2\x82\xAC \xF0\xA4\xAD\xA2\"");
+}
+
+TEST_F(EmitterTest, EscapedCharacters) {
+ out << BeginSeq
+ << '\x00'
+ << '\x0C'
+ << '\x0D'
+ << EndSeq;
+
+ ExpectEmit("- \"\\x00\"\n- \"\\f\"\n- \"\\r\"");
+}
+
+TEST_F(EmitterTest, CharactersEscapedAsJson) {
+ out.SetOutputCharset(EscapeAsJson);
+ out << BeginSeq
+ << '\x00'
+ << '\x0C'
+ << '\x0D'
+ << EndSeq;
+
+ ExpectEmit("- \"\\u0000\"\n- \"\\f\"\n- \"\\r\"");
+}
+
+TEST_F(EmitterTest, DoubleQuotedString) {
+ out << DoubleQuoted << "\" \\ \n \t \r \b \x15 \xEF\xBB\xBF \x24";
+ ExpectEmit("\"\\\" \\\\ \\n \\t \\r \\b \\x15 \\ufeff $\"");
+}
+
+struct Foo {
+ Foo() : x(0) {}
+ Foo(int x_, const std::string& bar_) : x(x_), bar(bar_) {}
+
+ int x;
+ std::string bar;
+};
+
+Emitter& operator<<(Emitter& out, const Foo& foo) {
+ out << BeginMap;
+ out << Key << "x" << Value << foo.x;
+ out << Key << "bar" << Value << foo.bar;
+ out << EndMap;
+ return out;
+}
+
+TEST_F(EmitterTest, UserType) {
+ out << BeginSeq;
+ out << Foo(5, "hello");
+ out << Foo(3, "goodbye");
+ out << EndSeq;
+
+ ExpectEmit("- x: 5\n bar: hello\n- x: 3\n bar: goodbye");
+}
+
+TEST_F(EmitterTest, UserType2) {
+ out << BeginSeq;
+ out << Foo(5, "\r");
+ out << EndSeq;
+
+ ExpectEmit("- x: 5\n bar: \"\\r\"");
+}
+
+TEST_F(EmitterTest, UserTypeInContainer) {
+ std::vector<Foo> fv;
+ fv.push_back(Foo(5, "hello"));
+ fv.push_back(Foo(3, "goodbye"));
+ out << fv;
+
+ ExpectEmit("- x: 5\n bar: hello\n- x: 3\n bar: goodbye");
+}
+
+template <typename T>
+Emitter& operator<<(Emitter& out, const T* v) {
+ if (v)
+ out << *v;
+ else
+ out << Null;
+ return out;
+}
+
+TEST_F(EmitterTest, PointerToInt) {
+ int foo = 5;
+ int* bar = &foo;
+ int* baz = 0;
+ out << BeginSeq;
+ out << bar << baz;
+ out << EndSeq;
+
+ ExpectEmit("- 5\n- ~");
+}
+
+TEST_F(EmitterTest, PointerToUserType) {
+ Foo foo(5, "hello");
+ Foo* bar = &foo;
+ Foo* baz = 0;
+ out << BeginSeq;
+ out << bar << baz;
+ out << EndSeq;
+
+ ExpectEmit("- x: 5\n bar: hello\n- ~");
+}
+
+TEST_F(EmitterTest, NewlineAtEnd) {
+ out << "Hello" << Newline << Newline;
+ ExpectEmit("Hello\n\n");
+}
+
+TEST_F(EmitterTest, NewlineInBlockSequence) {
+ out << BeginSeq;
+ out << "a" << Newline << "b"
+ << "c" << Newline << "d";
+ out << EndSeq;
+ ExpectEmit("- a\n\n- b\n- c\n\n- d");
+}
+
+TEST_F(EmitterTest, NewlineInFlowSequence) {
+ out << Flow << BeginSeq;
+ out << "a" << Newline << "b"
+ << "c" << Newline << "d";
+ out << EndSeq;
+ ExpectEmit("[a,\nb, c,\nd]");
+}
+
+TEST_F(EmitterTest, NewlineInBlockMap) {
+ out << BeginMap;
+ out << Key << "a" << Value << "foo" << Newline;
+ out << Key << "b" << Newline << Value << "bar";
+ out << LongKey << Key << "c" << Newline << Value << "car";
+ out << EndMap;
+ ExpectEmit("a: foo\nb:\n bar\n? c\n\n: car");
+}
+
+TEST_F(EmitterTest, NewlineInFlowMap) {
+ out << Flow << BeginMap;
+ out << Key << "a" << Value << "foo" << Newline;
+ out << Key << "b" << Value << "bar";
+ out << EndMap;
+ ExpectEmit("{a: foo,\nb: bar}");
+}
+
+TEST_F(EmitterTest, LotsOfNewlines) {
+ out << BeginSeq;
+ out << "a" << Newline;
+ out << BeginSeq;
+ out << "b"
+ << "c" << Newline;
+ out << EndSeq;
+ out << Newline;
+ out << BeginMap;
+ out << Newline << Key << "d" << Value << Newline << "e";
+ out << LongKey << Key << "f" << Newline << Value << "foo";
+ out << EndMap;
+ out << EndSeq;
+ ExpectEmit("- a\n\n-\n - b\n - c\n\n\n-\n d:\n e\n ? f\n\n : foo");
+}
+
+TEST_F(EmitterTest, Binary) {
+ out << Binary(reinterpret_cast<const unsigned char*>("Hello, World!"), 13);
+ ExpectEmit("!!binary \"SGVsbG8sIFdvcmxkIQ==\"");
+}
+
+TEST_F(EmitterTest, LongBinary) {
+ out << Binary(
+ reinterpret_cast<const unsigned char*>(
+ "Man is distinguished, not only by his reason, but by this "
+ "singular passion from other animals, which is a lust of the "
+ "mind, that by a perseverance of delight in the continued and "
+ "indefatigable generation of knowledge, exceeds the short "
+ "vehemence of any carnal pleasure.\n"),
+ 270);
+ ExpectEmit(
+ "!!binary "
+ "\"TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieS"
+ "B0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIG"
+ "x1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbi"
+ "B0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZG"
+ "dlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS"
+ "4K\"");
+}
+
+TEST_F(EmitterTest, EmptyBinary) {
+ out << Binary(reinterpret_cast<const unsigned char*>(""), 0);
+ ExpectEmit("!!binary \"\"");
+}
+
+TEST_F(EmitterTest, ColonAtEndOfScalar) {
+ out << "a:";
+ ExpectEmit("\"a:\"");
+}
+
+TEST_F(EmitterTest, ColonAsScalar) {
+ out << BeginMap;
+ out << Key << "apple" << Value << ":";
+ out << Key << "banana" << Value << ":";
+ out << EndMap;
+ ExpectEmit("apple: \":\"\nbanana: \":\"");
+}
+
+TEST_F(EmitterTest, ColonAtEndOfScalarInFlow) {
+ out << Flow << BeginMap << Key << "C:" << Value << "C:" << EndMap;
+ ExpectEmit("{\"C:\": \"C:\"}");
+}
+
+TEST_F(EmitterTest, GlobalBoolFormatting) {
+ out << BeginSeq;
+ out.SetBoolFormat(UpperCase);
+ out.SetBoolFormat(YesNoBool);
+ out << true;
+ out << false;
+ out.SetBoolFormat(TrueFalseBool);
+ out << true;
+ out << false;
+ out.SetBoolFormat(OnOffBool);
+ out << true;
+ out << false;
+ out.SetBoolFormat(LowerCase);
+ out.SetBoolFormat(YesNoBool);
+ out << true;
+ out << false;
+ out.SetBoolFormat(TrueFalseBool);
+ out << true;
+ out << false;
+ out.SetBoolFormat(OnOffBool);
+ out << true;
+ out << false;
+ out.SetBoolFormat(CamelCase);
+ out.SetBoolFormat(YesNoBool);
+ out << true;
+ out << false;
+ out.SetBoolFormat(TrueFalseBool);
+ out << true;
+ out << false;
+ out.SetBoolFormat(OnOffBool);
+ out << true;
+ out << false;
+ out.SetBoolFormat(ShortBool);
+ out.SetBoolFormat(UpperCase);
+ out.SetBoolFormat(YesNoBool);
+ out << true;
+ out << false;
+ out.SetBoolFormat(TrueFalseBool);
+ out << true;
+ out << false;
+ out.SetBoolFormat(OnOffBool);
+ out << true;
+ out << false;
+ out << EndSeq;
+ ExpectEmit(
+ "- YES\n- NO\n- TRUE\n- FALSE\n- ON\n- OFF\n"
+ "- yes\n- no\n- true\n- false\n- on\n- off\n"
+ "- Yes\n- No\n- True\n- False\n- On\n- Off\n"
+ "- Y\n- N\n- Y\n- N\n- Y\n- N");
+}
+
+TEST_F(EmitterTest, BoolFormatting) {
+ out << BeginSeq;
+ out << TrueFalseBool << UpperCase << true;
+ out << TrueFalseBool << CamelCase << true;
+ out << TrueFalseBool << LowerCase << true;
+ out << TrueFalseBool << UpperCase << false;
+ out << TrueFalseBool << CamelCase << false;
+ out << TrueFalseBool << LowerCase << false;
+ out << YesNoBool << UpperCase << true;
+ out << YesNoBool << CamelCase << true;
+ out << YesNoBool << LowerCase << true;
+ out << YesNoBool << UpperCase << false;
+ out << YesNoBool << CamelCase << false;
+ out << YesNoBool << LowerCase << false;
+ out << OnOffBool << UpperCase << true;
+ out << OnOffBool << CamelCase << true;
+ out << OnOffBool << LowerCase << true;
+ out << OnOffBool << UpperCase << false;
+ out << OnOffBool << CamelCase << false;
+ out << OnOffBool << LowerCase << false;
+ out << ShortBool << UpperCase << true;
+ out << ShortBool << CamelCase << true;
+ out << ShortBool << LowerCase << true;
+ out << ShortBool << UpperCase << false;
+ out << ShortBool << CamelCase << false;
+ out << ShortBool << LowerCase << false;
+ out << EndSeq;
+ ExpectEmit(
+ "- TRUE\n- True\n- true\n- FALSE\n- False\n- false\n"
+ "- YES\n- Yes\n- yes\n- NO\n- No\n- no\n"
+ "- ON\n- On\n- on\n- OFF\n- Off\n- off\n"
+ "- Y\n- Y\n- y\n- N\n- N\n- n");
+}
+
+TEST_F(EmitterTest, GlobalNullFormatting) {
+ out << Flow << BeginSeq;
+ out.SetNullFormat(LowerNull);
+ out << Null;
+ out.SetNullFormat(UpperNull);
+ out << Null;
+ out.SetNullFormat(CamelNull);
+ out << Null;
+ out.SetNullFormat(TildeNull);
+ out << Null;
+ out << EndSeq;
+ ExpectEmit("[null, NULL, Null, ~]");
+}
+
+TEST_F(EmitterTest, NullFormatting) {
+ out << Flow << BeginSeq;
+ out << LowerNull << Null;
+ out << UpperNull << Null;
+ out << CamelNull << Null;
+ out << TildeNull << Null;
+ out << EndSeq;
+ ExpectEmit("[null, NULL, Null, ~]");
+}
+
+TEST_F(EmitterTest, NullFormattingOnNode) {
+ Node n(Load("null"));
+ out << Flow << BeginSeq;
+ out.SetNullFormat(LowerNull);
+ out << n;
+ out.SetNullFormat(UpperNull);
+ out << n;
+ out.SetNullFormat(CamelNull);
+ out << n;
+ out.SetNullFormat(TildeNull);
+ out << n;
+ out << EndSeq;
+ ExpectEmit("[null, NULL, Null, ~]");
+}
+
+// TODO: Fix this test.
+// TEST_F(EmitterTest, DocStartAndEnd) {
+// out << BeginDoc;
+// out << BeginSeq << 1 << 2 << 3 << EndSeq;
+// out << BeginDoc;
+// out << "Hi there!";
+// out << EndDoc;
+// out << EndDoc;
+// out << EndDoc;
+// out << BeginDoc;
+// out << VerbatimTag("foo") << "bar";
+// ExpectEmit(
+// "---\n- 1\n- 2\n- 3\n---\nHi there!\n...\n...\n...\n---\n!<foo> bar");
+//}
+
+TEST_F(EmitterTest, ImplicitDocStart) {
+ out << "Hi";
+ out << "Bye";
+ out << "Oops";
+ ExpectEmit("Hi\n---\nBye\n---\nOops");
+}
+
+TEST_F(EmitterTest, EmptyString) {
+ out << BeginMap;
+ out << Key << "key" << Value << "";
+ out << EndMap;
+ ExpectEmit("key: \"\"");
+}
+
+TEST_F(EmitterTest, SingleChar) {
+ out << BeginSeq;
+ out << 'a';
+ out << ':';
+ out << (char)0x10;
+ out << '\n';
+ out << ' ';
+ out << '\t';
+ out << EndSeq;
+ ExpectEmit("- a\n- \":\"\n- \"\\x10\"\n- \"\\n\"\n- \" \"\n- \"\\t\"");
+}
+
+TEST_F(EmitterTest, DefaultPrecision) {
+ out << BeginSeq;
+ out << 1.3125f;
+ out << 1.23455810546875;
+ out << EndSeq;
+ ExpectEmit("- 1.3125\n- 1.23455810546875");
+}
+
+TEST_F(EmitterTest, SetPrecision) {
+ out << BeginSeq;
+ out << FloatPrecision(3) << 1.3125f;
+ out << DoublePrecision(6) << 1.23455810546875;
+ out << EndSeq;
+ ExpectEmit("- 1.31\n- 1.23456");
+}
+
+TEST_F(EmitterTest, DashInBlockContext) {
+ out << BeginMap;
+ out << Key << "key" << Value << "-";
+ out << EndMap;
+ ExpectEmit("key: \"-\"");
+}
+
+TEST_F(EmitterTest, HexAndOct) {
+ out << Flow << BeginSeq;
+ out << 31;
+ out << Hex << 31;
+ out << Oct << 31;
+ out << EndSeq;
+ ExpectEmit("[31, 0x1f, 037]");
+}
+
+TEST_F(EmitterTest, CompactMapWithNewline) {
+ out << Comment("Characteristics");
+ out << BeginSeq;
+ out << BeginMap;
+ out << Key << "color" << Value << "blue";
+ out << Key << "height" << Value << 120;
+ out << EndMap;
+ out << Newline << Newline;
+ out << Comment("Skills");
+ out << BeginMap;
+ out << Key << "attack" << Value << 23;
+ out << Key << "intelligence" << Value << 56;
+ out << EndMap;
+ out << EndSeq;
+
+ ExpectEmit(
+ "# Characteristics\n"
+ "- color: blue\n"
+ " height: 120\n"
+ "\n"
+ "# Skills\n"
+ "- attack: 23\n"
+ " intelligence: 56");
+}
+
+TEST_F(EmitterTest, ForceSingleQuotedToDouble) {
+ out << SingleQuoted << "Hello\nWorld";
+
+ ExpectEmit("\"Hello\\nWorld\"");
+}
+
+TEST_F(EmitterTest, QuoteNull) {
+ out << "null";
+
+ ExpectEmit("\"null\"");
+}
+
+TEST_F(EmitterTest, ValueOfDoubleQuote) {
+ out << YAML::BeginMap;
+ out << YAML::Key << "foo" << YAML::Value << '"';
+ out << YAML::EndMap;
+
+ ExpectEmit("foo: \"\\\"\"");
+}
+
+TEST_F(EmitterTest, ValueOfBackslash) {
+ out << YAML::BeginMap;
+ out << YAML::Key << "foo" << YAML::Value << '\\';
+ out << YAML::EndMap;
+
+ ExpectEmit("foo: \"\\\\\"");
+}
+
+TEST_F(EmitterTest, Infinity) {
+ out << YAML::BeginMap;
+ out << YAML::Key << "foo" << YAML::Value
+ << std::numeric_limits<float>::infinity();
+ out << YAML::Key << "bar" << YAML::Value
+ << std::numeric_limits<double>::infinity();
+ out << YAML::EndMap;
+
+ ExpectEmit(
+ "foo: .inf\n"
+ "bar: .inf");
+}
+
+TEST_F(EmitterTest, NegInfinity) {
+ out << YAML::BeginMap;
+ out << YAML::Key << "foo" << YAML::Value
+ << -std::numeric_limits<float>::infinity();
+ out << YAML::Key << "bar" << YAML::Value
+ << -std::numeric_limits<double>::infinity();
+ out << YAML::EndMap;
+
+ ExpectEmit(
+ "foo: -.inf\n"
+ "bar: -.inf");
+}
+
+TEST_F(EmitterTest, NaN) {
+ out << YAML::BeginMap;
+ out << YAML::Key << "foo" << YAML::Value
+ << std::numeric_limits<float>::quiet_NaN();
+ out << YAML::Key << "bar" << YAML::Value
+ << std::numeric_limits<double>::quiet_NaN();
+ out << YAML::EndMap;
+
+ ExpectEmit(
+ "foo: .nan\n"
+ "bar: .nan");
+}
+
+TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapWithNewLine) {
+ out << YAML::BeginMap;
+
+ out << YAML::Key << "NodeA" << YAML::Value << YAML::BeginMap;
+ out << YAML::Key << "k" << YAML::Value << YAML::Flow << YAML::BeginSeq;
+ out << YAML::BeginMap << YAML::Key << "i" << YAML::Value << 0 << YAML::EndMap
+ << YAML::Newline;
+ out << YAML::BeginMap << YAML::Key << "i" << YAML::Value << 1 << YAML::EndMap
+ << YAML::Newline;
+ out << YAML::EndSeq;
+ out << YAML::EndMap;
+
+ out << YAML::Key << "NodeB" << YAML::Value << YAML::BeginMap;
+ out << YAML::Key << "k" << YAML::Value << YAML::Flow << YAML::BeginSeq;
+ out << YAML::BeginMap << YAML::Key << "i" << YAML::Value << 0 << YAML::EndMap
+ << YAML::Newline;
+ out << YAML::BeginMap << YAML::Key << "i" << YAML::Value << 1 << YAML::EndMap
+ << YAML::Newline;
+ out << YAML::EndSeq;
+ out << YAML::EndMap;
+
+ out << YAML::EndMap;
+
+ ExpectEmit(R"(NodeA:
+ k: [{i: 0},
+ {i: 1},
+ ]
+NodeB:
+ k: [{i: 0},
+ {i: 1},
+ ])");
+}
+
+TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapWithNewLineUsingAliases) {
+ out << BeginMap;
+
+ out << Key << "Node" << Anchor("Node") << Value << BeginMap;
+ out << Key << "k" << Value << Flow << BeginSeq;
+ out << BeginMap << Key << "i" << Value << 0 << EndMap;
+ out << YAML::Newline;
+ out << BeginMap << Key << "i" << Value << 1 << EndMap;
+ out << YAML::Newline;
+ out << EndSeq << EndMap;
+
+ out << Key << "NodeA" << Alias("Node");
+ out << Key << "NodeB" << Alias("Node");
+
+ out << EndMap;
+
+ ExpectEmit(R"(Node: &Node
+ k: [{i: 0},
+ {i: 1},
+ ]
+NodeA: *Node
+NodeB: *Node)");
+}
+
+TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapUsingAliases) {
+ out << BeginMap;
+
+ out << Key << "Node" << Anchor("Node") << Value << BeginMap;
+ out << Key << "k" << Value << Flow << BeginSeq;
+ out << BeginMap << Key << "i" << Value << 0 << EndMap;
+ out << BeginMap << Key << "i" << Value << 1 << EndMap;
+ out << EndSeq << EndMap;
+
+ out << Key << "NodeA" << Alias("Node");
+ out << Key << "NodeB" << Alias("Node");
+
+ out << EndMap;
+
+ ExpectEmit(R"(Node: &Node
+ k: [{i: 0}, {i: 1}]
+NodeA: *Node
+NodeB: *Node)");
+}
+
+TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapWithNewLineUsingAliases2) {
+ out << BeginMap;
+
+ out << Key << "Seq" << Anchor("Seq") << Flow << BeginSeq;
+ out << BeginMap << Key << "i" << Value << 0 << EndMap;
+ out << YAML::Newline;
+ out << BeginMap << Key << "i" << Value << 1 << EndMap;
+ out << YAML::Newline;
+ out << EndSeq;
+
+ out << Key << "NodeA" << Value << BeginMap;
+ out << Key << "k" << Value << Alias("Seq") << EndMap;
+ out << Key << "NodeB" << Value << BeginMap;
+ out << Key << "k" << Value << Alias("Seq") << EndMap;
+
+ out << EndMap;
+
+ ExpectEmit(R"(Seq: &Seq [{i: 0},
+ {i: 1},
+ ]
+NodeA:
+ k: *Seq
+NodeB:
+ k: *Seq)");
+}
+
+TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapUsingAliases2) {
+ out << BeginMap;
+
+ out << Key << "Seq" << Anchor("Seq") << Value << Flow << BeginSeq;
+ out << BeginMap << Key << "i" << Value << 0 << EndMap;
+ out << BeginMap << Key << "i" << Value << 1 << EndMap;
+ out << EndSeq;
+
+ out << Key << "NodeA" << Value << BeginMap;
+ out << Key << "k" << Value << Alias("Seq") << EndMap;
+ out << Key << "NodeB" << Value << BeginMap;
+ out << Key << "k" << Value << Alias("Seq") << EndMap;
+
+ out << EndMap;
+
+ ExpectEmit(R"(Seq: &Seq [{i: 0}, {i: 1}]
+NodeA:
+ k: *Seq
+NodeB:
+ k: *Seq)");
+}
+
+TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapWithNewLineUsingAliases3) {
+ out << BeginMap;
+
+ out << Key << "Keys" << Value << Flow << BeginSeq;
+ out << Anchor("k0") << BeginMap << Key << "i" << Value << 0 << EndMap
+ << Newline;
+ out << Anchor("k1") << BeginMap << Key << "i" << Value << 1 << EndMap
+ << Newline;
+ out << EndSeq;
+
+ out << Key << "NodeA" << Value << BeginMap;
+ out << Key << "k" << Value << Flow << BeginSeq;
+ out << Alias("k0") << Newline << Alias("k1") << Newline;
+ out << EndSeq << EndMap;
+
+ out << Key << "NodeB" << Value << BeginMap;
+ out << Key << "k" << Value << Flow << BeginSeq;
+ out << Alias("k0") << Newline << Alias("k1") << Newline;
+ out << EndSeq << EndMap;
+
+ out << EndMap;
+
+ ExpectEmit(R"(Keys: [&k0 {i: 0},
+&k1 {i: 1},
+ ]
+NodeA:
+ k: [*k0,
+ *k1,
+ ]
+NodeB:
+ k: [*k0,
+ *k1,
+ ])");
+}
+
+TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapUsingAliases3a) {
+ out << BeginMap;
+
+ out << Key << "Keys" << Value << BeginSeq;
+ out << Anchor("k0") << BeginMap << Key << "i" << Value << 0 << EndMap;
+ out << Anchor("k1") << BeginMap << Key << "i" << Value << 1 << EndMap;
+ out << EndSeq;
+
+ out << Key << "NodeA" << Value << BeginMap;
+ out << Key << "k" << Value << Flow << BeginSeq;
+ out << Alias("k0") << Alias("k1");
+ out << EndSeq << EndMap;
+
+ out << Key << "NodeB" << Value << BeginMap;
+ out << Key << "k" << Value << Flow << BeginSeq;
+ out << Alias("k0") << Alias("k1");
+ out << EndSeq << EndMap;
+
+ out << EndMap;
+
+ ExpectEmit(R"(Keys:
+ - &k0
+ i: 0
+ - &k1
+ i: 1
+NodeA:
+ k: [*k0, *k1]
+NodeB:
+ k: [*k0, *k1])");
+}
+
+TEST_F(EmitterTest, ComplexFlowSeqEmbeddingAMapUsingAliases3b) {
+ out << BeginMap;
+
+ out << Key << "Keys" << Value << Flow << BeginSeq;
+ out << Anchor("k0") << BeginMap << Key << "i" << Value << 0 << EndMap;
+ out << Anchor("k1") << BeginMap << Key << "i" << Value << 1 << EndMap;
+ out << EndSeq;
+
+ out << Key << "NodeA" << Value << BeginMap;
+ out << Key << "k" << Value << Flow << BeginSeq;
+ out << Alias("k0") << Alias("k1");
+ out << EndSeq << EndMap;
+
+ out << Key << "NodeB" << Value << BeginMap;
+ out << Key << "k" << Value << Flow << BeginSeq;
+ out << Alias("k0") << Alias("k1");
+ out << EndSeq << EndMap;
+
+ out << EndMap;
+
+ ExpectEmit(R"(Keys: [&k0 {i: 0}, &k1 {i: 1}]
+NodeA:
+ k: [*k0, *k1]
+NodeB:
+ k: [*k0, *k1])");
+}
+
+TEST_F(EmitterTest, AnchorEncoding) {
+ Node node;
+ node["--- &$ [*$]1"] = 1;
+ out << node;
+ ExpectEmit("\"--- &$ [*$]1\": 1");
+ Node reparsed = YAML::Load(out.c_str());
+ EXPECT_EQ(reparsed["--- &$ [*$]1"].as<int>(), 1);
+}
+
+class EmitterErrorTest : public ::testing::Test {
+ protected:
+ void ExpectEmitError(const std::string& expectedError) {
+ ASSERT_FALSE(out.good()) << "Emitter cleanly produced: " << out.c_str();
+ EXPECT_EQ(expectedError, out.GetLastError());
+ }
+
+ Emitter out;
+};
+
+TEST_F(EmitterErrorTest, BadLocalTag) {
+ out << LocalTag("e!far") << "bar";
+
+ ExpectEmitError("invalid tag");
+}
+
+TEST_F(EmitterErrorTest, BadTagAndTag) {
+ out << VerbatimTag("!far") << VerbatimTag("!foo") << "bar";
+ ExpectEmitError(ErrorMsg::INVALID_TAG);
+}
+
+TEST_F(EmitterErrorTest, BadAnchorAndAnchor) {
+ out << Anchor("far") << Anchor("foo") << "bar";
+ ExpectEmitError(ErrorMsg::INVALID_ANCHOR);
+}
+
+TEST_F(EmitterErrorTest, BadEmptyAnchorOnGroup) {
+ out << BeginSeq << "bar" << Anchor("foo") << EndSeq;
+ ExpectEmitError(ErrorMsg::INVALID_ANCHOR);
+}
+
+TEST_F(EmitterErrorTest, BadEmptyTagOnGroup) {
+ out << BeginSeq << "bar" << VerbatimTag("!foo") << EndSeq;
+ ExpectEmitError(ErrorMsg::INVALID_TAG);
+}
+
+TEST_F(EmitterErrorTest, ExtraEndSeq) {
+ out << BeginSeq;
+ out << "Hello";
+ out << "World";
+ out << EndSeq;
+ out << EndSeq;
+
+ ExpectEmitError(ErrorMsg::UNEXPECTED_END_SEQ);
+}
+
+TEST_F(EmitterErrorTest, ExtraEndMap) {
+ out << BeginMap;
+ out << Key << "Hello" << Value << "World";
+ out << EndMap;
+ out << EndMap;
+
+ ExpectEmitError(ErrorMsg::UNEXPECTED_END_MAP);
+}
+
+TEST_F(EmitterErrorTest, InvalidAnchor) {
+ out << BeginSeq;
+ out << Anchor("new\nline") << "Test";
+ out << EndSeq;
+
+ ExpectEmitError(ErrorMsg::INVALID_ANCHOR);
+}
+
+TEST_F(EmitterErrorTest, InvalidAlias) {
+ out << BeginSeq;
+ out << Alias("new\nline");
+ out << EndSeq;
+
+ ExpectEmitError(ErrorMsg::INVALID_ALIAS);
+}
+
+} // namespace
+} // namespace YAML
--- /dev/null
+#include <sstream>
+
+#include "handler_test.h"
+#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+
+#include "gtest/gtest.h"
+
+using ::testing::_;
+using ::testing::InSequence;
+
+namespace YAML {
+namespace {
+typedef void (*EncodingFn)(std::ostream&, int);
+
+inline char Byte(int ch) {
+ return static_cast<char>(
+ static_cast<unsigned char>(static_cast<unsigned int>(ch)));
+}
+
+void EncodeToUtf8(std::ostream& stream, int ch) {
+ if (ch <= 0x7F) {
+ stream << Byte(ch);
+ } else if (ch <= 0x7FF) {
+ stream << Byte(0xC0 | (ch >> 6));
+ stream << Byte(0x80 | (ch & 0x3F));
+ } else if (ch <= 0xFFFF) {
+ stream << Byte(0xE0 | (ch >> 12));
+ stream << Byte(0x80 | ((ch >> 6) & 0x3F));
+ stream << Byte(0x80 | (ch & 0x3F));
+ } else if (ch <= 0x1FFFFF) {
+ stream << Byte(0xF0 | (ch >> 18));
+ stream << Byte(0x80 | ((ch >> 12) & 0x3F));
+ stream << Byte(0x80 | ((ch >> 6) & 0x3F));
+ stream << Byte(0x80 | (ch & 0x3F));
+ }
+}
+
+bool SplitUtf16HighChar(std::ostream& stream, EncodingFn encoding, int ch) {
+ int biasedValue = ch - 0x10000;
+ if (biasedValue < 0) {
+ return false;
+ }
+ int high = 0xD800 | (biasedValue >> 10);
+ int low = 0xDC00 | (biasedValue & 0x3FF);
+ encoding(stream, high);
+ encoding(stream, low);
+ return true;
+}
+
+void EncodeToUtf16LE(std::ostream& stream, int ch) {
+ if (!SplitUtf16HighChar(stream, &EncodeToUtf16LE, ch)) {
+ stream << Byte(ch & 0xFF) << Byte(ch >> 8);
+ }
+}
+
+void EncodeToUtf16BE(std::ostream& stream, int ch) {
+ if (!SplitUtf16HighChar(stream, &EncodeToUtf16BE, ch)) {
+ stream << Byte(ch >> 8) << Byte(ch & 0xFF);
+ }
+}
+
+void EncodeToUtf32LE(std::ostream& stream, int ch) {
+ stream << Byte(ch & 0xFF) << Byte((ch >> 8) & 0xFF) << Byte((ch >> 16) & 0xFF)
+ << Byte((ch >> 24) & 0xFF);
+}
+
+void EncodeToUtf32BE(std::ostream& stream, int ch) {
+ stream << Byte((ch >> 24) & 0xFF) << Byte((ch >> 16) & 0xFF)
+ << Byte((ch >> 8) & 0xFF) << Byte(ch & 0xFF);
+}
+
+class EncodingTest : public HandlerTest {
+ protected:
+ void SetUpEncoding(EncodingFn encoding, bool declareEncoding) {
+ if (declareEncoding) {
+ encoding(m_yaml, 0xFEFF);
+ }
+
+ AddEntry(encoding, 0x0021, 0x007E); // Basic Latin
+ AddEntry(encoding, 0x00A1, 0x00FF); // Latin-1 Supplement
+ AddEntry(encoding, 0x0660, 0x06FF); // Arabic (largest contiguous block)
+
+ // CJK unified ideographs (multiple lines)
+ AddEntry(encoding, 0x4E00, 0x4EFF);
+ AddEntry(encoding, 0x4F00, 0x4FFF);
+ AddEntry(encoding, 0x5000, 0x51FF); // 512 character line
+ AddEntry(encoding, 0x5200, 0x54FF); // 768 character line
+ AddEntry(encoding, 0x5500, 0x58FF); // 1024 character line
+
+ AddEntry(encoding, 0x103A0, 0x103C3); // Old Persian
+
+ m_yaml.seekg(0, std::ios::beg);
+ }
+
+ void Run() {
+ InSequence sequence;
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ for (std::size_t i = 0; i < m_entries.size(); i++) {
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, m_entries[i]));
+ }
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+
+ Parse(m_yaml.str());
+ }
+
+ private:
+ std::stringstream m_yaml;
+ std::vector<std::string> m_entries;
+
+ void AddEntry(EncodingFn encoding, int startCh, int endCh) {
+ encoding(m_yaml, '-');
+ encoding(m_yaml, ' ');
+ encoding(m_yaml, '|');
+ encoding(m_yaml, '\n');
+ encoding(m_yaml, ' ');
+ encoding(m_yaml, ' ');
+
+ std::stringstream entry;
+ for (int ch = startCh; ch <= endCh; ++ch) {
+ encoding(m_yaml, ch);
+ EncodeToUtf8(entry, ch);
+ }
+ encoding(m_yaml, '\n');
+ EncodeToUtf8(entry, '\n');
+
+ m_entries.push_back(entry.str());
+ }
+};
+
+TEST_F(EncodingTest, UTF8_noBOM) {
+ SetUpEncoding(&EncodeToUtf8, false);
+ Run();
+}
+
+TEST_F(EncodingTest, UTF8_BOM) {
+ SetUpEncoding(&EncodeToUtf8, true);
+ Run();
+}
+
+TEST_F(EncodingTest, UTF16LE_noBOM) {
+ SetUpEncoding(&EncodeToUtf16LE, false);
+ Run();
+}
+
+TEST_F(EncodingTest, UTF16LE_BOM) {
+ SetUpEncoding(&EncodeToUtf16LE, true);
+ Run();
+}
+
+TEST_F(EncodingTest, UTF16BE_noBOM) {
+ SetUpEncoding(&EncodeToUtf16BE, false);
+ Run();
+}
+
+TEST_F(EncodingTest, UTF16BE_BOM) {
+ SetUpEncoding(&EncodeToUtf16BE, true);
+ Run();
+}
+
+TEST_F(EncodingTest, UTF32LE_noBOM) {
+ SetUpEncoding(&EncodeToUtf32LE, false);
+ Run();
+}
+
+TEST_F(EncodingTest, UTF32LE_BOM) {
+ SetUpEncoding(&EncodeToUtf32LE, true);
+ Run();
+}
+
+TEST_F(EncodingTest, UTF32BE_noBOM) {
+ SetUpEncoding(&EncodeToUtf32BE, false);
+ Run();
+}
+
+TEST_F(EncodingTest, UTF32BE_BOM) {
+ SetUpEncoding(&EncodeToUtf32BE, true);
+ Run();
+}
+}
+}
--- /dev/null
+#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+
+#include "gtest/gtest.h"
+
+#define EXPECT_THROW_EXCEPTION(exception_type, statement, message) \
+ ASSERT_THROW(statement, exception_type); \
+ try { \
+ statement; \
+ } catch (const exception_type& e) { \
+ EXPECT_EQ(e.msg, message); \
+ }
+
+namespace YAML {
+namespace {
+
+TEST(ErrorMessageTest, BadSubscriptErrorMessage) {
+ const char *example_yaml = "first:\n"
+ " second: 1\n"
+ " third: 2\n";
+
+ Node doc = Load(example_yaml);
+
+ // Test that printable key is part of error message
+ EXPECT_THROW_EXCEPTION(YAML::BadSubscript, doc["first"]["second"]["fourth"],
+ "operator[] call on a scalar (key: \"fourth\")");
+
+ EXPECT_THROW_EXCEPTION(YAML::BadSubscript, doc["first"]["second"][37],
+ "operator[] call on a scalar (key: \"37\")");
+
+
+ // Non-printable key is not included in error message
+ EXPECT_THROW_EXCEPTION(YAML::BadSubscript,
+ doc["first"]["second"][std::vector<int>()],
+ "operator[] call on a scalar");
+
+ EXPECT_THROW_EXCEPTION(YAML::BadSubscript, doc["first"]["second"][Node()],
+ "operator[] call on a scalar");
+}
+
+TEST(ErrorMessageTest, Ex9_1_InvalidNodeErrorMessage) {
+ const char *example_yaml = "first:\n"
+ " second: 1\n"
+ " third: 2\n";
+
+ const Node doc = Load(example_yaml);
+
+ // Test that printable key is part of error message
+ EXPECT_THROW_EXCEPTION(YAML::InvalidNode, doc["first"]["fourth"].as<int>(),
+ "invalid node; first invalid key: \"fourth\"");
+
+ EXPECT_THROW_EXCEPTION(YAML::InvalidNode, doc["first"][37].as<int>(),
+ "invalid node; first invalid key: \"37\"");
+
+ // Non-printable key is not included in error message
+ EXPECT_THROW_EXCEPTION(YAML::InvalidNode,
+ doc["first"][std::vector<int>()].as<int>(),
+ "invalid node; this may result from using a map "
+ "iterator as a sequence iterator, or vice-versa");
+}
+}
+}
--- /dev/null
+#include "handler_test.h"
+#include "yaml-cpp/yaml.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using ::testing::_;
+
+namespace YAML {
+namespace {
+
+typedef HandlerTest GenEmitterTest;
+
+TEST_F(GenEmitterTest, testf2a8b6e6359fb2c30830) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa2c9c04eab06a05bf1a3) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc5fae995bf84b2f62627) {
+ Emitter out;
+ out << BeginDoc;
+ out << "foo";
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test208b4fb7399a936fce93) {
+ Emitter out;
+ out << BeginDoc;
+ out << "foo";
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test402085442ada9788bc4e) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test279346c761f7d9a10aec) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test386f6766d57a48ccb316) {
+ Emitter out;
+ out << BeginDoc;
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test989baa41ede860374193) {
+ Emitter out;
+ out << BeginDoc;
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test718fa11b9bfa9dfc6632) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << "foo\n";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7986c74c7cab2ff062e7) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << "foo\n";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1a432be0760ebcf72dde) {
+ Emitter out;
+ out << BeginDoc;
+ out << "foo\n";
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9b4714c8c6dd71f963f1) {
+ Emitter out;
+ out << BeginDoc;
+ out << "foo\n";
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test59d039102f43b05233b2) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << "foo\n";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test15371be5fc126b3601ee) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << "foo\n";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5a2a5702a41d71567a10) {
+ Emitter out;
+ out << BeginDoc;
+ out << "foo\n";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7975acd31f55f66c21a9) {
+ Emitter out;
+ out << BeginDoc;
+ out << "foo\n";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9ab358e41e3af0e1852c) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6571b17e1089f3f34d41) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7c8476d0a02eeab3326f) {
+ Emitter out;
+ out << BeginDoc;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0883fa5d170d96324325) {
+ Emitter out;
+ out << BeginDoc;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7f44d870f57878e83749) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << VerbatimTag("tag");
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc7b8d9af2a71da438220) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa27a4f0174aee7622160) {
+ Emitter out;
+ out << BeginDoc;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf06e77dc66bc51682e57) {
+ Emitter out;
+ out << BeginDoc;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test28c636f42558c217d90b) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa8e930c2f4f761519825) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc73b721f492b45035034) {
+ Emitter out;
+ out << BeginDoc;
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb401b54145c71ea07848) {
+ Emitter out;
+ out << BeginDoc;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test380d9af0ae2e27279526) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << Anchor("anchor");
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6969308096c6106d1f55) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << Anchor("anchor");
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa8afc0036fffa3b2d185) {
+ Emitter out;
+ out << BeginDoc;
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7b41f0a32b90bf5f138d) {
+ Emitter out;
+ out << BeginDoc;
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test99b1e0027d74c641f4fc) {
+ Emitter out;
+ out << Comment("comment");
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8e45fdb3ff3c00d56f27) {
+ Emitter out;
+ out << Comment("comment");
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf898ade0c92d48d498cf) {
+ Emitter out;
+ out << "foo";
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3eb11fe6897b9638b90c) {
+ Emitter out;
+ out << "foo";
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test4e7428248511a461fdae) {
+ Emitter out;
+ out << Comment("comment");
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb811cba8e9f57399cd40) {
+ Emitter out;
+ out << Comment("comment");
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc625669ef35d9165757f) {
+ Emitter out;
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0bc005214f48707274f7) {
+ Emitter out;
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testdccc5288dfb2f680dd82) {
+ Emitter out;
+ out << Comment("comment");
+ out << "foo\n";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0a928620b149d5644a3b) {
+ Emitter out;
+ out << Comment("comment");
+ out << "foo\n";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test72bf9f8ba5207fb041c3) {
+ Emitter out;
+ out << "foo\n";
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test39ba33ec287e431e70d0) {
+ Emitter out;
+ out << "foo\n";
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testce39fe4e650942b617c6) {
+ Emitter out;
+ out << Comment("comment");
+ out << "foo\n";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test680e99eab986e1cdac01) {
+ Emitter out;
+ out << Comment("comment");
+ out << "foo\n";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste6e7f73dfac0048154af) {
+ Emitter out;
+ out << "foo\n";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test19e2c91493d21a389511) {
+ Emitter out;
+ out << "foo\n";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc15cdbdbf9661c853def) {
+ Emitter out;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa349878c464f03fa6d4e) {
+ Emitter out;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc063a846f87b1e20e4e9) {
+ Emitter out;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testdfb3a9ec6da3b792f392) {
+ Emitter out;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6f545990782be38424bf) {
+ Emitter out;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9d7dd5e044527a4e8f31) {
+ Emitter out;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testba570ae83f89342779ff) {
+ Emitter out;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc6fc50c169793aa60531) {
+ Emitter out;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testd10a9c9671992acd494d) {
+ Emitter out;
+ out << Comment("comment");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testd5ee8a3bdb42c8639ad4) {
+ Emitter out;
+ out << Comment("comment");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test24914f6c2b7f7d5843c4) {
+ Emitter out;
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9af19fe8c77aa18cd462) {
+ Emitter out;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc2f9274717aaf39b0838) {
+ Emitter out;
+ out << Comment("comment");
+ out << Anchor("anchor");
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test75f3a7f62b5b77411653) {
+ Emitter out;
+ out << Comment("comment");
+ out << Anchor("anchor");
+ out << "foo";
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testea51373e6b4e598b2adf) {
+ Emitter out;
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa594204f0724101d4931) {
+ Emitter out;
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test87638f2fba55c5235720) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test786f027ec8e380bdeb45) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9d9ca2fc29536ef5d392) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testde9c33927d8f706e5191) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa03392eb1d9af2180eb2) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8826ba8a4954e2775441) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf116d1ab8a1646bb4295) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1d4afe394248c5d6f190) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test4cc7b190d6dd08368f08) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc623063380afa67c57c4) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste24ef3f378c4c33107b2) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test2aa8f68b872fd07fde8c) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test940bf9330572d48b476f) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testd710bce67052a991abfa) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testd2ac557dae648cd1ba66) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb394f0e282404d1235d3) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testaf620080909b118a715d) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testfc23fc6f424006e5907f) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testbc5517fe466dd4988ce2) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc0db52f1be33ddf93852) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test279a9eef5b2d2cf98ecf) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7f55b2f00c1090e43af5) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1be996b4b790d9bd565d) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa5dea69e968ea27412cc) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test77fe0d4370db4aa8af1a) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6d0319a28dd1a931f211) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0031c4cd5331366162a6) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc0c74d483811e3322ed2) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0d0938c9dca1e78401d6) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0c83b8f0404e62673099) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test733fd2f94ae082ea6076) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test04b57f98a492b0f2c1ad) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test80d83a80f235341f1bff) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testecbe137bf7436ccd7976) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf14f2e8202cacdf9252d) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9c029f7cf565580a56fd) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test129cd28cda34c7b97a89) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1c55ee081412be96e00f) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf9e9d15d9e09a8e98681) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test03dd7104722840fe7fee) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste6c856a08270255404b6) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf285ed8797058c0e4e2f) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test906076647b894281787e) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8a836336041c56130c5c) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc7f61ada097fb34f24ce) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testec075d926fd1f95a1bae) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa79ce9edc0c3593faa31) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test525c133ebf8f46a1962f) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb06604d03a8c9cfbe7c2) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste268ba5f2d54120eb665) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7a646350a81bba70e44a) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test025df570e0d8a1f818da) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test897087b9aba1d5773870) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa45ee0501da4a4e5da54) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste751c06ea558ccca1821) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8526d26e85cc930eecec) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste9a5a4a0f0e44311d01a) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testac8a091ab93b65aee893) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testee014788f524623b5075) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test57a067545c01c42a7b4e) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test948ac02da8825214c869) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa3d6c5e8a1658c1dd726) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test548d71006d7cafde91da) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test35e08ea7459dbee9eab8) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test87e79665a4339434d781) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test4928d09bc979129c05ca) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1d2f73011af6b4486504) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test2460718f7277d5f42306) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test52309e87b3f0185f982b) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa51d8f1cedfead1de5ab) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test537bf14b4d578f212f4d) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste19e3fd4d5cd52bf6754) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf27e53142f2ca0e96a99) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8ce13fdbb0e53e131cbe) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9fa693277f014353aa34) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc3e4849fb38bc3556f45) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test34049495795f40da2d52) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test14353701fc865919ab50) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test74547fc0ba8d387c5423) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test52d2b69b185f6ccfff4c) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test44d442585e5bc9a7644a) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3dc263684801dec471c9) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa04cde3245ad9b929b9a) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testd911e740ca36e0509dfa) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testde44215fe9b2e87846ba) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6390021323a4889f19d2) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1db2fcb7347f6cb37dd4) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test06b32e9d75498ee291d2) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test86654989004963952b15) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test53d875fc5058faa44a4e) {
+ Emitter out;
+ out << BeginSeq;
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3f4b49a82b6e07eb11fd) {
+ Emitter out;
+ out << BeginSeq;
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testae4e2fa09d6a34077b6e) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb181b63559d96d5f848c) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test817661fec7d3730f4fa6) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test34bb2700e9688718fa5a) {
+ Emitter out;
+ out << BeginSeq;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test84e3c1999b6888d2e897) {
+ Emitter out;
+ out << BeginSeq;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa9d113656780031a99f5) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1cd1ead50aaa7b827068) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1389f95066b07eac89ef) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test709f3a5c294f47f62c1e) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8a238d7fdee02a368203) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0d13534e2949ea35ca96) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test10fe6827ed46e0e063a7) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc7eb6d9da57005534c1c) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3f424efd76e1d32727eb) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test2bdc361bc6b056f02465) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0cc1936afe5637ba1376) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7d3e2f793963d3480545) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf3f50e76d7ef6e2b2bff) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testcbf1cff67fec9148df1c) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test168bd4b8dc78b4d524ee) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb616ef26030304bca6ef) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9fda976f36ddb23b38ee) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test48e8c45c081edc86deb2) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test30f5136e817ddd8158de) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testeb51d66281f593566172) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testef6ffa5fa4658785ef00) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6db34efc6b59e8a7ba18) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test537b9ecc9d9a5b546a9c) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testfadd6ee259c13382f5ce) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test974ae82483391d01787b) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7fc68b49cfe198b30eeb) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test41644c59ff95f8ec5ec2) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa3a24413b537aece4834) {
+ Emitter out;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc4516128af938868b120) {
+ Emitter out;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testef3c20a56c8a3993cc2d) {
+ Emitter out;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test83aceee2ee6446347fba) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5a054d76c67b6de340e2) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc6706e6b6fc94d1e4752) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test72f3ded341d6b5d21803) {
+ Emitter out;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7dc830828b604b5d1839) {
+ Emitter out;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3a5baef0d6a62e5880ef) {
+ Emitter out;
+ out << BeginSeq;
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testfe7bf25b7a5525cab12a) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test817bf3d583230e503f8e) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testab122e386b3e30ea59e2) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test466c3e0dbec8e9660837) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9fc49f92e554cd85e349) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf9d2f39bdbd217d70868) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1ce3d77707f18ec48a19) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test71df6ecc32e49ea961d4) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8f37b0a6cc287f8c922f) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf992e2a1f7d737647506) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testd79381f97cdd0af81ae4) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test74ca1feb5f0c520a8518) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste86e6fd56707272c091b) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1e6f73bc378c184c786b) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3fbac5e1aef66dc40bf7) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test558c4bf1c9c6e4e81e98) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testfa6d88b26c0072cddb26) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test40a5af3360fb3d9e79f1) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test451dd95b95b7e958bb03) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1717ad2d772bafb9b573) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testedc6737e8b2f5b23b42e) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test771c7d28c0b8c184e2c7) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test469a446f0b22e9b6d269) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testec45b0503f312be47336) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1bfc4f39d6730acb6a12) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9bc9a72ad06084dc8cf8) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test62c996cdfc1d3b77b7ec) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1d038936a340d5bef490) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7057f64ac570dbe3c1ca) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testbfe0890de3ffc73f0f9d) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5faa7320a493247b4f8b) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test929fbc93b3d6d98b1f0a) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testcc7d1ad7797581b37549) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1115ba981ba8f739ddf2) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf7ca743a82040e1313a8) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa4e0257ad6c987178ca4) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb65ceea0d4080b44180e) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test4fcd60d48dbd7b07e289) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test92704937d4e130b43390) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test029a31902f93dfa9ea7b) {
+ Emitter out;
+ out << BeginSeq;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test40b4e7494e5b850d26f4) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginMap;
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test64d2ab5993b67281212b) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginMap;
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste71b9b975d71c18a2897) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << Comment("comment");
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test138039761e432a5ba11e) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << EndMap;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6684d2eacb3f094bfc84) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << EndMap;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8624a705f2167d4db358) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test90877a1ec609edb69bce) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5f925d3c910a7e32bb99) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testffeb4955bf4ee9510a88) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test769ee82c3bfc52d7a85d) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testdc4e16b5a48fe16102b4) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testd3c578e5b5a6813a73c7) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0034b2c9905b34f7f22e) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste911e620becf080a4d96) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7f8bbf619609651a2e55) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test2974bda177bed72619f4) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testbc7a1599883ed8c27262) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test323e14a02e02b94939fb) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test705ff113324bf0b4897c) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test587f5739ba58f0e21e0e) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test31a8c7da96ebe3da3f6e) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0b6fe270e4cf9fc21181) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testaf5869c722ea0dfb3394) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc348837f92793a778246) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9d26ae9ec8db76a06a6f) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test28691969bbaa41191640) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb38c27cd2556a14bb479) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1103d3c99e3525075da6) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testeb7edb5d1dfd039c72c3) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa9862d708fcb755db479) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testae3e98286336f0c5d2af) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8bd970000ae21619e864) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginDoc;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0a960fe3efeeb1b4fafe) {
+ Emitter out;
+ out << BeginDoc;
+ out << Comment("comment");
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testffec1dcba9a2622b57a3) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9a181b6042027e7977bf) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5b42728bff7e0dd63ae8) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa17514c4db3a70fe5084) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test2ac903a52c526db4b34b) {
+ Emitter out;
+ out << BeginDoc;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testbebc6bc66d04a91bfa9c) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0918e247384bfc94d831) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf8512b2ebdaad8ae4cae) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test01a1d249079c380030ca) {
+ Emitter out;
+ out << BeginMap;
+ out << EndMap;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testcb48737e9c352108dc56) {
+ Emitter out;
+ out << BeginMap;
+ out << EndMap;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testdea8106f3dce46929197) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test2b91aa87abdaa0fc0b20) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9c8b1fe0c5bbbf6a787e) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8808d4be9571f365f79a) {
+ Emitter out;
+ out << BeginMap;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste77c95c5163513fa25c5) {
+ Emitter out;
+ out << BeginMap;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa3ed6e26dac366240579) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test136adbd0ad47d74cfa22) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test77f384e8387e39b54691) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf8f016177cf9e428fcd4) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1cec69d3c95937f4137a) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb1fe1a5c5c064bdfe505) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test14200fdf4de8797d8dfb) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testde7595a96199f66d7ac0) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb1434e1f508509c0ade4) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0d3bd788298201abbe67) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3c716f5c232001f04805) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa55ef29eecbda5bc5b69) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test55ddd593defa5ee8da90) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7326f87fd5c3adff317b) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5ebc413d376f3b965879) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test4c7159334e528e2cfff8) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6a6bc06cdfee9f58a094) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0beedfaace1b1e71d0c6) {
+ Emitter out;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9f65fafc369193908b7b) {
+ Emitter out;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3a5c3ac504d7a58a08ca) {
+ Emitter out;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << EndDoc;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc007513c868038dd3a68) {
+ Emitter out;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << EndDoc;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test89f3ba065cbd341381ec) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test692c2652cee84e90c096) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test761fba62f7617a03fbf0) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste960a69bc06912eb8c76) {
+ Emitter out;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << Comment("comment");
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8f6187c6c2419dbf1770) {
+ Emitter out;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testba6cb3810a074fabc55e) {
+ Emitter out;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testac695c3621ec3f104672) {
+ Emitter out;
+ out << BeginMap;
+ out << VerbatimTag("tag");
+ out << Anchor("anchor");
+ out << "foo";
+ out << VerbatimTag("tag");
+ out << Anchor("other");
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 1, "foo"));
+ EXPECT_CALL(handler, OnAnchor(_, "other"));
+ EXPECT_CALL(handler, OnScalar(_, "tag", 2, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test86494a6bcb6a65e7029e) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb406fb13323c199d709c) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test4409f685a3e80b9ab415) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa74ace9c1f5e18cf3f2a) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testabfc8ce2ca4c3dafa013) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << "foo";
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test07ff4bbae6104c4e30c1) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << "foo";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1e3559cacab6d46c98fe) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << "foo";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test795830e12e5a20213a7e) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test849f2c88c71734fcf3f3) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7bb139ac1f14e8ae04e2) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test58655e359c60bf73986f) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testde9f70648448cbd37245) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testfff25037c90a64db8771) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test94b24a286074cac9b881) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0c678fe6c6dbd3ccf4eb) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test15f6ce577f139b9f1b61) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5e927c8865f44b5c1abe) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test235aebc60786962899f1) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test45e109e1bc3ca312091d) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9a58086d44719b21c6b3) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa3ac3fa06ae69e9f5c9d) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9ccaf628d78cc8f27857) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6b8483101720027fd945) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1549a08694b053f8a2cb) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0417f66daae22676ad66) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6b3d4384d27d0ac90b01) {
+ Emitter out;
+ out << BeginMap;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testbf166fa245c204799ea8) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testdf279b50896e8f084ed3) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7d9b55fe33dfdc6cf930) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test2b0f0825ac5d9ac3baf7) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste4865b227f48a727aafe) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb02fb812ae14499cc30e) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa395515c1bce39e737b7) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test813be458848be1ba3bf1) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test23ab6af7b3fc7957a03d) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc5fb40e239029d9efa58) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test88b5c599a4f9ac52f951) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3995578993108fa25f88) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test61a24036be6f8cd49a28) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc13e02ab3c1bd1db6e55) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb3ca69f6d7a888644064) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test4e6337821c858c2f7cfa) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8dc4a01d956c779dd8b0) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1dae9c6350559f6b9f89) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9f891b1cdde286863956) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test0704315052c50c54b17a) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7f5b47cf1d2571afc033) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5040c19e850e3046d32d) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test110665e2f3409ef307ff) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste9e1549f96267f93651c) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6a5b6a20fdb6f7c3279e) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7c568c68f77e34d5c714) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testfd8fe783b5297c92d17f) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test418b1426e630825a7c85) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8161c5e486d317e7864e) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa48e1915ca7c919db445) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test27124815aea27c053aab) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste751377e4a74306bc555) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test36a4cc298255efdd1ef5) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test43471dee97b0506909b2) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test959c85b4e833f72173a6) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3a09723dce29399bc865) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test958e404277a1c55139af) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb1823407ab0601edc9cb) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9993e9dad983b28960aa) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << "foo";
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8e87f559b25a9a20e11c) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testeb431be8504451636efe) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf876965882befc7355df) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf7e1d47f266f0b940fed) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste5a4bc646f2182b78cc1) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6cbedca25c9a8a6bb42e) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test07613cc34874a5b47577) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa55b7ac19580aeb82d32) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test458f9af92dfb9f64a488) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc4a9c3769e95770bb455) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testae56654f89fa2416f3db) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1635f71f27e7303c730e) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testcd9d835a8d8b8622c63b) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3c2d1f91e57040cb8fdd) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9bd5b4c002b3b637747f) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf6c71199cd45b5b8e7e0) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test865b02b69742e5513963) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test86eb8783dc4367cda931) {
+ Emitter out;
+ out << BeginMap;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7f6604058a9d8e2e1219) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test676b4abcb3cf0530e4da) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste7e52980e73d442a602b) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc3d6f480087db4bcd3a1) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6943516ed43da6944e96) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb7e880522d0778ae6e6f) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testec39ee51992618c7b154) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test39f768713a9b3aaffe0d) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << EndMap;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf287a68abc5b8ff7784d) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc36154aa87842ba9699f) {
+ Emitter out;
+ out << BeginMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndMap;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa75da84dfc8ee5507157) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc54a03d1735615f7bd60) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf5d72aba828875527d6f) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9e8681a1b27a8524ec5e) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test34678928e79e6eb160f4) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test07c6d6b9e133553d4532) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1531642db71e1aa8dd1c) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test22fde02c0bd0ecb8a527) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test72430574ba42559cf917) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test067bce5d8aa6281a3e6f) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb1839ee8ced911bb1ed1) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5899c9cd7e5a40077178) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test834f4e4a74c0ac6cd011) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testd3aeee7524918cf227e7) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7c587549aa0bbd6e2d53) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc684ba00d512b6009b02) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testbe39189b638b9e0214dd) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test80326240018ececfa606) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8a74653a376d02a2b6db) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testaa82cace20492eb66f60) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testcd4a1cdb4e2a24cae5c1) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testa9ef5ab0eada79175f6a) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test4060ba4b4f9b8193dcc4) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6cd2fc4be08857654fa0) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testadb892f6183cde28d9cc) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5e830445d6cafe856b09) {
+ Emitter out;
+ out << BeginSeq;
+ out << "foo";
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test16a7d875f6358bdd36ee) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test75b4342605739c88bc3f) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test7d42488f1a02d045d278) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9ce404764c03c6644c98) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf9e413cd5405efcbd432) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test757c82faa95e2e507ee9) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb73d72bf5de11964969f) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3926f169b9dce6db913f) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test77b0cc7e618a09e0556d) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6817f3e5da2ad8823025) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test817ae48b78359d60888b) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9db1bf6278dd7de937e6) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test4d5ca5c891442ddf7e84) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testfb6eb22f4bf080b9ac8b) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3ce4b4ec89282d701502) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testaf53ae415739a8812200) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test72d3de78c6508500cb00) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6dd3d3703718b37fa2a4) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc0beca9064d8081d45c1) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test14c55f7cd295d89763ca) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test72a93f054d9296607dff) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf0ac164fe5c38cc36922) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test74efb7c560fd057d25ba) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test43adceaba606a7f5013f) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test94160894abf5f0650ec9) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testb77f1131af63dae91031) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test296aa575c385013e91f0) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test339bddce4b70064141c4) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test991a70285cf143adb7fe) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1b1ae70c1b5e7a1a2502) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test02e58fb30f5a5b3616ec) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testbdc3952445cad78094e2) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5d24f2ab8e24cb71d6c9) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1ca2c58583cb7dd8a765) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6086aee45faab48750ad) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testdac42de03b96b1207ec4) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test10d18ea5e198359e218b) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test56218e461d6be3a18500) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9acfd124b72471e34bbd) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test2a1c3780a4dfaa43646e) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test91e4c547fdab9e8b1c67) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test3d7e8318208742fe4358) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test2e4a92f93d5f9d8c5fed) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9abf5d48ef7c6f2ed8a0) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testc3428819fe7cfe88cf10) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8007ba3728b0fdbb0cb8) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6eedc1e3db4ceee9caf6) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testd892f2048c7066c74b7e) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test736430339c2a221b6d89) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test6d51f33adb9324f438d1) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test00d50067643ed73a3f7f) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << Comment("comment");
+ out << EndSeq;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test5fc029e9d46151d31a80) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test328542a5a4b65371d2c6) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testf791a97db1c96e9f16c7) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginSeq;
+ out << "foo";
+ out << EndSeq;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test44ac18a00d604391a169) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste7ff269f6d95faa06abe) {
+ Emitter out;
+ out << Comment("comment");
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test8d056d159803415c2c85) {
+ Emitter out;
+ out << BeginSeq;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test47ef0ff3da945fda8680) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test1f981851e5a72a91614b) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test783be6c196784ca7ff30) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test217dcab50ef45ac6d344) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testec71f98bc646a34c9327) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << Comment("comment");
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test04595ac13c58c0740048) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << Comment("comment");
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test18d724e2ff0f869e9947) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << Comment("comment");
+ out << EndMap;
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, test9f80798acafd4cfec0aa) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << Comment("comment");
+ out << EndSeq;
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, testeabc051f6366e0275232) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+TEST_F(GenEmitterTest, teste33a98fb01ea45cc91dc) {
+ Emitter out;
+ out << BeginSeq;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << BeginMap;
+ out << "foo";
+ out << "bar";
+ out << EndMap;
+ out << EndSeq;
+ out << Comment("comment");
+
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, _));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(out.c_str());
+}
+
+} // namespace
+} // namespace YAML
--- /dev/null
+#include "handler_test.h"
+#include "specexamples.h" // IWYU pragma: keep
+#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using ::testing::_;
+
+#define EXPECT_THROW_PARSER_EXCEPTION(statement, message) \
+ ASSERT_THROW(statement, ParserException); \
+ try { \
+ statement; \
+ } catch (const ParserException& e) { \
+ EXPECT_EQ(e.msg, message); \
+ }
+
+namespace YAML {
+namespace {
+
+typedef HandlerTest HandlerSpecTest;
+
+TEST_F(HandlerSpecTest, Ex2_1_SeqScalars) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Mark McGwire"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Ken Griffey"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_1);
+}
+
+TEST_F(HandlerSpecTest, Ex2_2_MappingScalarsToScalars) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "hr"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "65"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "avg"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "0.278"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "rbi"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "147"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_2);
+}
+
+TEST_F(HandlerSpecTest, Ex2_3_MappingScalarsToSequences) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "american"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Boston Red Sox"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Detroit Tigers"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "New York Yankees"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "national"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "New York Mets"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Chicago Cubs"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Atlanta Braves"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_3);
+}
+
+TEST_F(HandlerSpecTest, Ex2_4_SequenceOfMappings) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "name"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Mark McGwire"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "hr"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "65"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "avg"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "0.278"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "name"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "hr"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "63"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "avg"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "0.288"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_4);
+}
+
+TEST_F(HandlerSpecTest, Ex2_5_SequenceOfSequences) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "name"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "hr"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "avg"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Mark McGwire"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "65"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "0.278"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "63"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "0.288"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_5);
+}
+
+TEST_F(HandlerSpecTest, Ex2_6_MappingOfMappings) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Mark McGwire"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "hr"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "65"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "avg"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "0.278"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "hr"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "63"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "avg"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "0.288"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_6);
+}
+
+TEST_F(HandlerSpecTest, Ex2_7_TwoDocumentsInAStream) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Mark McGwire"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Ken Griffey"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Chicago Cubs"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "St Louis Cardinals"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_7);
+}
+
+TEST_F(HandlerSpecTest, Ex2_8_PlayByPlayFeed) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "time"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "20:03:20"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "player"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "action"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "strike (miss)"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "time"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "20:03:47"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "player"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "action"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "grand slam"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_8);
+}
+
+TEST_F(HandlerSpecTest, Ex2_9_SingleDocumentWithTwoComments) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "hr"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Mark McGwire"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "rbi"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Ken Griffey"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_9);
+}
+
+TEST_F(HandlerSpecTest, Ex2_10_SimpleAnchor) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "hr"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Mark McGwire"));
+ EXPECT_CALL(handler, OnAnchor(_, "SS"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "rbi"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnAlias(_, 1));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Ken Griffey"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_10);
+}
+
+TEST_F(HandlerSpecTest, Ex2_11_MappingBetweenSequences) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Detroit Tigers"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Chicago cubs"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2001-07-23"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "New York Yankees"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Atlanta Braves"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2001-07-02"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2001-08-12"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2001-08-14"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_11);
+}
+
+TEST_F(HandlerSpecTest, Ex2_12_CompactNestedMapping) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "item"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Super Hoop"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "quantity"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "1"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "item"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Basketball"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "quantity"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "4"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "item"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Big Shoes"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "quantity"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "1"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_12);
+}
+
+TEST_F(HandlerSpecTest, Ex2_13_InLiteralsNewlinesArePreserved) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0,
+ "\\//||\\/||\n"
+ "// || ||__"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_13);
+}
+
+TEST_F(HandlerSpecTest, Ex2_14_InFoldedScalarsNewlinesBecomeSpaces) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler,
+ OnScalar(_, "!", 0,
+ "Mark McGwire's year was crippled by a knee injury."));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_14);
+}
+
+TEST_F(HandlerSpecTest,
+ Ex2_15_FoldedNewlinesArePreservedForMoreIndentedAndBlankLines) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(
+ handler,
+ OnScalar(_, "!", 0,
+ "Sammy Sosa completed another fine season with great stats.\n"
+ "\n"
+ " 63 Home Runs\n"
+ " 0.288 Batting Average\n"
+ "\n"
+ "What a year!"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_15);
+}
+
+TEST_F(HandlerSpecTest, Ex2_16_IndentationDeterminesScope) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "name"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Mark McGwire"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "accomplishment"));
+ EXPECT_CALL(handler,
+ OnScalar(_, "!", 0,
+ "Mark set a major league home run record in 1998.\n"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "stats"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0,
+ "65 Home Runs\n"
+ "0.278 Batting Average\n"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_16);
+}
+
+TEST_F(HandlerSpecTest, Ex2_17_QuotedScalars) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "unicode"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "Sosa did fine.\xE2\x98\xBA"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "control"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "\b1998\t1999\t2000\n"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "hex esc"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "\x0d\x0a is \r\n"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "single"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "\"Howdy!\" he cried."));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "quoted"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, " # Not a 'comment'."));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "tie-fighter"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "|\\-*-/|"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_17);
+}
+
+TEST_F(HandlerSpecTest, Ex2_18_MultiLineFlowScalars) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "plain"));
+ EXPECT_CALL(handler,
+ OnScalar(_, "?", 0, "This unquoted scalar spans many lines."));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "quoted"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "So does this quoted scalar.\n"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_18);
+}
+
+TEST_F(HandlerSpecTest, Ex2_19_Integers) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "canonical"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "12345"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "decimal"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "+12345"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "octal"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "0o14"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "hexadecimal"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "0xC"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_19);
+}
+
+TEST_F(HandlerSpecTest, Ex2_20_FloatingPoint) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "canonical"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "1.23015e+3"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "exponential"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "12.3015e+02"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "fixed"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "1230.15"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "negative infinity"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "-.inf"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "not a number"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, ".NaN"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_20);
+}
+
+TEST_F(HandlerSpecTest, Ex2_21_Miscellaneous) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "booleans"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "true"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "false"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "string"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "012345"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_21);
+}
+
+TEST_F(HandlerSpecTest, Ex2_22_Timestamps) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "canonical"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2001-12-15T02:59:43.1Z"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "iso8601"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2001-12-14t21:59:43.10-05:00"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "spaced"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2001-12-14 21:59:43.10 -5"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "date"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2002-12-14"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_22);
+}
+
+TEST_F(HandlerSpecTest, Ex2_23_VariousExplicitTags) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "not-date"));
+ EXPECT_CALL(handler, OnScalar(_, "tag:yaml.org,2002:str", 0, "2002-04-28"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "picture"));
+ EXPECT_CALL(handler, OnScalar(_, "tag:yaml.org,2002:binary", 0,
+ "R0lGODlhDAAMAIQAAP//9/X\n"
+ "17unp5WZmZgAAAOfn515eXv\n"
+ "Pz7Y6OjuDg4J+fn5OTk6enp\n"
+ "56enmleECcgggoBADs=\n"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "application specific tag"));
+ EXPECT_CALL(handler, OnScalar(_, "!something", 0,
+ "The semantics of the tag\n"
+ "above may be different for\n"
+ "different documents."));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_23);
+}
+
+TEST_F(HandlerSpecTest, Ex2_24_GlobalTags) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "tag:clarkevans.com,2002:shape", 0,
+ EmitterStyle::Block));
+ EXPECT_CALL(handler, OnMapStart(_, "tag:clarkevans.com,2002:circle", 0,
+ EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "center"));
+ EXPECT_CALL(handler, OnAnchor(_, "ORIGIN"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 1, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "x"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "73"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "y"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "129"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "radius"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "7"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "tag:clarkevans.com,2002:line", 0,
+ EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "start"));
+ EXPECT_CALL(handler, OnAlias(_, 1));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "finish"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "x"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "89"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "y"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "102"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "tag:clarkevans.com,2002:label", 0,
+ EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "start"));
+ EXPECT_CALL(handler, OnAlias(_, 1));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "color"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "0xFFEEBB"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "text"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Pretty vector drawing."));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_24);
+}
+
+TEST_F(HandlerSpecTest, Ex2_25_UnorderedSets) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler,
+ OnMapStart(_, "tag:yaml.org,2002:set", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Mark McGwire"));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Ken Griffey"));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_25);
+}
+
+TEST_F(HandlerSpecTest, Ex2_26_OrderedMappings) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "tag:yaml.org,2002:omap", 0,
+ EmitterStyle::Block));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Mark McGwire"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "65"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy Sosa"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "63"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Ken Griffey"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "58"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_26);
+}
+
+TEST_F(HandlerSpecTest, Ex2_27_Invoice) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "tag:clarkevans.com,2002:invoice", 0,
+ EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "invoice"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "34843"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "date"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2001-01-23"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bill-to"));
+ EXPECT_CALL(handler, OnAnchor(_, "id001"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 1, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "given"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Chris"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "family"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Dumars"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "address"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "lines"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0,
+ "458 Walkman Dr.\n"
+ "Suite #292\n"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "city"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Royal Oak"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "state"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "MI"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "postal"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "48046"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "ship-to"));
+ EXPECT_CALL(handler, OnAlias(_, 1));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "product"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "sku"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "BL394D"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "quantity"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "4"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "description"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Basketball"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "price"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "450.00"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "sku"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "BL4438H"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "quantity"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "1"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "description"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Super Hoop"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "price"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2392.00"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "tax"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "251.42"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "total"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "4443.52"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "comments"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0,
+ "Late afternoon is best. Backup contact is "
+ "Nancy Billsmer @ 338-4338."));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_27);
+}
+
+TEST_F(HandlerSpecTest, Ex2_28_LogFile) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Time"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2001-11-23 15:01:42 -5"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "User"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "ed"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Warning"));
+ EXPECT_CALL(handler,
+ OnScalar(_, "?", 0, "This is an error message for the log file"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Time"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2001-11-23 15:02:31 -5"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "User"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "ed"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Warning"));
+ EXPECT_CALL(handler,
+ OnScalar(_, "?", 0, "A slightly different error message."));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Date"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "2001-11-23 15:03:17 -5"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "User"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "ed"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Fatal"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Unknown variable \"bar\""));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Stack"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "file"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "TopClass.py"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "line"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "23"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "code"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "x = MoreObject(\"345\\n\")\n"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "file"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "MoreClass.py"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "line"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "58"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "code"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo = bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex2_28);
+}
+
+// TODO: 5.1 - 5.2 BOM
+
+TEST_F(HandlerSpecTest, Ex5_3_BlockStructureIndicators) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "sequence"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "one"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "two"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "mapping"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "sky"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "blue"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "sea"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "green"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex5_3);
+}
+
+TEST_F(HandlerSpecTest, Ex5_4_FlowStructureIndicators) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "sequence"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "one"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "two"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "mapping"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "sky"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "blue"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "sea"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "green"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex5_4);
+}
+
+TEST_F(HandlerSpecTest, Ex5_5_CommentIndicator) { Parse(ex5_5); }
+
+TEST_F(HandlerSpecTest, Ex5_6_NodePropertyIndicators) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "anchored"));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "!local", 1, "value"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "alias"));
+ EXPECT_CALL(handler, OnAlias(_, 1));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex5_6);
+}
+
+TEST_F(HandlerSpecTest, Ex5_7_BlockScalarIndicators) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "literal"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "some\ntext\n"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "folded"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "some text\n"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex5_7);
+}
+
+TEST_F(HandlerSpecTest, Ex5_8_QuotedScalarIndicators) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "single"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "text"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "double"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "text"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex5_8);
+}
+
+// TODO: 5.9 directive
+// TODO: 5.10 reserved indicator
+
+TEST_F(HandlerSpecTest, Ex5_11_LineBreakCharacters) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0,
+ "Line break (no glyph)\n"
+ "Line break (glyphed)\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex5_11);
+}
+
+TEST_F(HandlerSpecTest, Ex5_12_TabsAndSpaces) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "quoted"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "Quoted\t"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "block"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0,
+ "void main() {\n"
+ "\tprintf(\"Hello, world!\\n\");\n"
+ "}"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex5_12);
+}
+
+TEST_F(HandlerSpecTest, Ex5_13_EscapedCharacters) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(
+ handler,
+ OnScalar(_, "!", 0,
+ "Fun with \x5C \x22 \x07 \x08 \x1B \x0C \x0A \x0D \x09 \x0B " +
+ std::string("\x00", 1) +
+ " \x20 \xA0 \x85 \xe2\x80\xa8 \xe2\x80\xa9 A A A"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex5_13);
+}
+
+TEST_F(HandlerSpecTest, Ex5_14_InvalidEscapedCharacters) {
+ EXPECT_THROW_PARSER_EXCEPTION(IgnoreParse(ex5_14),
+ std::string(ErrorMsg::INVALID_ESCAPE) + "c");
+}
+
+TEST_F(HandlerSpecTest, Ex6_1_IndentationSpaces) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Not indented"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "By one space"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "By four\n spaces\n"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Flow style"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "By two"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Also by two"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Still by two"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_1);
+}
+
+TEST_F(HandlerSpecTest, Ex6_2_IndentationIndicators) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "a"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "b"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "c"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "d"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_2);
+}
+
+TEST_F(HandlerSpecTest, Ex6_3_SeparationSpaces) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "baz"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "baz"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_3);
+}
+
+TEST_F(HandlerSpecTest, Ex6_4_LinePrefixes) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "plain"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "text lines"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "quoted"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "text lines"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "block"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "text\n \tlines\n"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_4);
+}
+
+TEST_F(HandlerSpecTest, Ex6_5_EmptyLines) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Folding"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "Empty line\nas a line feed"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Chomping"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "Clipped empty lines\n"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_5);
+}
+
+TEST_F(HandlerSpecTest, Ex6_6_LineFolding) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "trimmed\n\n\nas space"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_6);
+}
+
+TEST_F(HandlerSpecTest, Ex6_7_BlockFolding) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo \n\n\t bar\n\nbaz\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_7);
+}
+
+TEST_F(HandlerSpecTest, Ex6_8_FlowFolding) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, " foo\nbar\nbaz "));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_8);
+}
+
+TEST_F(HandlerSpecTest, Ex6_9_SeparatedComment) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "key"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "value"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_9);
+}
+
+TEST_F(HandlerSpecTest, Ex6_10_CommentLines) { Parse(ex6_10); }
+
+TEST_F(HandlerSpecTest, _MultiLineComments) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "key"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "value"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_11);
+}
+
+TEST_F(HandlerSpecTest, Ex6_12_SeparationSpacesII) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "first"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sammy"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "last"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Sosa"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "hr"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "65"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "avg"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "0.278"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_12);
+}
+
+TEST_F(HandlerSpecTest, Ex6_13_ReservedDirectives) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_13);
+}
+
+TEST_F(HandlerSpecTest, Ex6_14_YAMLDirective) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_14);
+}
+
+TEST_F(HandlerSpecTest, Ex6_15_InvalidRepeatedYAMLDirective) {
+ EXPECT_THROW_PARSER_EXCEPTION(IgnoreParse(ex6_15),
+ ErrorMsg::REPEATED_YAML_DIRECTIVE);
+}
+
+TEST_F(HandlerSpecTest, Ex6_16_TagDirective) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag:yaml.org,2002:str", 0, "foo"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_16);
+}
+
+TEST_F(HandlerSpecTest, Ex6_17_InvalidRepeatedTagDirective) {
+ EXPECT_THROW_PARSER_EXCEPTION(IgnoreParse(ex6_17),
+ ErrorMsg::REPEATED_TAG_DIRECTIVE);
+}
+
+TEST_F(HandlerSpecTest, Ex6_18_PrimaryTagHandle) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!foo", 0, "bar"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag:example.com,2000:app/foo", 0, "bar"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_18);
+}
+
+TEST_F(HandlerSpecTest, Ex6_19_SecondaryTagHandle) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag:example.com,2000:app/int", 0, "1 - 3"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_19);
+}
+
+TEST_F(HandlerSpecTest, Ex6_20_TagHandles) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "tag:example.com,2000:app/foo", 0, "bar"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_20);
+}
+
+TEST_F(HandlerSpecTest, Ex6_21_LocalTagPrefix) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!my-light", 0, "fluorescent"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!my-light", 0, "green"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_21);
+}
+
+TEST_F(HandlerSpecTest, Ex6_22_GlobalTagPrefix) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "tag:example.com,2000:app/foo", 0, "bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_22);
+}
+
+TEST_F(HandlerSpecTest, Ex6_23_NodeProperties) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnAnchor(_, "a1"));
+ EXPECT_CALL(handler, OnScalar(_, "tag:yaml.org,2002:str", 1, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "tag:yaml.org,2002:str", 0, "bar"));
+ EXPECT_CALL(handler, OnAnchor(_, "a2"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 2, "baz"));
+ EXPECT_CALL(handler, OnAlias(_, 1));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_23);
+}
+
+TEST_F(HandlerSpecTest, Ex6_24_VerbatimTags) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "tag:yaml.org,2002:str", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "!bar", 0, "baz"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_24);
+}
+
+// TODO: Implement
+TEST_F(HandlerSpecTest, DISABLED_Ex6_25_InvalidVerbatimTags) {
+ Parse(ex6_25);
+ FAIL() << "not implemented yet";
+}
+
+TEST_F(HandlerSpecTest, Ex6_26_TagShorthands) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "!local", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "tag:yaml.org,2002:str", 0, "bar"));
+ EXPECT_CALL(handler,
+ OnScalar(_, "tag:example.com,2000:app/tag%21", 0, "baz"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_26);
+}
+
+TEST_F(HandlerSpecTest, Ex6_27a_InvalidTagShorthands) {
+ EXPECT_THROW_PARSER_EXCEPTION(IgnoreParse(ex6_27a),
+ ErrorMsg::TAG_WITH_NO_SUFFIX);
+}
+
+// TODO: should we reject this one (since !h! is not declared)?
+TEST_F(HandlerSpecTest, DISABLED_Ex6_27b_InvalidTagShorthands) {
+ Parse(ex6_27b);
+ FAIL() << "not implemented yet";
+}
+
+TEST_F(HandlerSpecTest, Ex6_28_NonSpecificTags) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "12"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "12"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "12"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_28);
+}
+
+TEST_F(HandlerSpecTest, Ex6_29_NodeAnchors) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "First occurrence"));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "Value"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Second occurrence"));
+ EXPECT_CALL(handler, OnAlias(_, 1));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex6_29);
+}
+
+TEST_F(HandlerSpecTest, Ex7_1_AliasNodes) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "First occurrence"));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 1, "Foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Second occurrence"));
+ EXPECT_CALL(handler, OnAlias(_, 1));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Override anchor"));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 2, "Bar"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Reuse anchor"));
+ EXPECT_CALL(handler, OnAlias(_, 2));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_1);
+}
+
+TEST_F(HandlerSpecTest, Ex7_2_EmptyNodes) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "tag:yaml.org,2002:str", 0, ""));
+ EXPECT_CALL(handler, OnScalar(_, "tag:yaml.org,2002:str", 0, ""));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_2);
+}
+
+TEST_F(HandlerSpecTest, Ex7_3_CompletelyEmptyNodes) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_3);
+}
+
+TEST_F(HandlerSpecTest, Ex7_4_DoubleQuotedImplicitKeys) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "implicit block key"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "implicit flow key"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "value"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_4);
+}
+
+TEST_F(HandlerSpecTest, Ex7_5_DoubleQuotedLineBreaks) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(
+ handler,
+ OnScalar(_, "!", 0,
+ "folded to a space,\nto a line feed, or \t \tnon-content"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_5);
+}
+
+TEST_F(HandlerSpecTest, Ex7_6_DoubleQuotedLines) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(
+ handler,
+ OnScalar(_, "!", 0, " 1st non-empty\n2nd non-empty 3rd non-empty "));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_6);
+}
+
+TEST_F(HandlerSpecTest, Ex7_7_SingleQuotedCharacters) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "here's to \"quotes\""));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_7);
+}
+
+TEST_F(HandlerSpecTest, Ex7_8_SingleQuotedImplicitKeys) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "implicit block key"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "implicit flow key"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "value"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_8);
+}
+
+TEST_F(HandlerSpecTest, Ex7_9_SingleQuotedLines) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(
+ handler,
+ OnScalar(_, "!", 0, " 1st non-empty\n2nd non-empty 3rd non-empty "));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_9);
+}
+
+TEST_F(HandlerSpecTest, Ex7_10_PlainCharacters) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "::vector"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, ": - ()"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "Up, up, and away!"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "-123"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "http://example.com/foo#bar"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "::vector"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, ": - ()"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "Up, up, and away!"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "-123"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "http://example.com/foo#bar"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_10);
+}
+
+TEST_F(HandlerSpecTest, Ex7_11_PlainImplicitKeys) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "implicit block key"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "implicit flow key"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "value"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_11);
+}
+
+TEST_F(HandlerSpecTest, Ex7_12_PlainLines) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0,
+ "1st non-empty\n2nd non-empty 3rd non-empty"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_12);
+}
+
+TEST_F(HandlerSpecTest, Ex7_13_FlowSequence) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "one"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "two"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "three"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "four"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_13);
+}
+
+TEST_F(HandlerSpecTest, Ex7_14_FlowSequenceEntries) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "double quoted"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "single quoted"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "plain text"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "nested"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "single"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "pair"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_14);
+}
+
+TEST_F(HandlerSpecTest, Ex7_15_FlowMappings) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "one"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "two"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "three"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "four"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "five"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "six"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "seven"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "eight"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_15);
+}
+
+TEST_F(HandlerSpecTest, Ex7_16_FlowMappingEntries) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "explicit"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "entry"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "implicit"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "entry"));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_16);
+}
+
+TEST_F(HandlerSpecTest, Ex7_17_FlowMappingSeparateValues) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "unquoted"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "separate"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "http://foo.com"));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "omitted value"));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "omitted key"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_17);
+}
+
+TEST_F(HandlerSpecTest, Ex7_18_FlowMappingAdjacentValues) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "adjacent"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "value"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "readable"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "value"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "empty"));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_18);
+}
+
+TEST_F(HandlerSpecTest, Ex7_19_SinglePairFlowMappings) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_19);
+}
+
+TEST_F(HandlerSpecTest, Ex7_20_SinglePairExplicitEntry) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo bar"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "baz"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_20);
+}
+
+TEST_F(HandlerSpecTest, Ex7_21_SinglePairImplicitEntries) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "YAML"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "separate"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Default));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "empty key entry"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "JSON"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "like"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "adjacent"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_21);
+}
+
+TEST_F(HandlerSpecTest, Ex7_22_InvalidImplicitKeys) {
+ EXPECT_THROW_PARSER_EXCEPTION(IgnoreParse(ex7_22), ErrorMsg::END_OF_SEQ_FLOW);
+}
+
+TEST_F(HandlerSpecTest, Ex7_23_FlowContent) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "a"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "b"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Flow));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "a"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "b"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "a"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "b"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "c"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_23);
+}
+
+TEST_F(HandlerSpecTest, Ex7_24_FlowNodes) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "tag:yaml.org,2002:str", 0, "a"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "b"));
+ EXPECT_CALL(handler, OnAnchor(_, "anchor"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 1, "c"));
+ EXPECT_CALL(handler, OnAlias(_, 1));
+ EXPECT_CALL(handler, OnScalar(_, "tag:yaml.org,2002:str", 0, ""));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex7_24);
+}
+
+TEST_F(HandlerSpecTest, Ex8_1_BlockScalarHeader) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "literal\n"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, " folded\n"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "keep\n\n"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, " strip"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_1);
+}
+
+TEST_F(HandlerSpecTest, Ex8_2_BlockIndentationHeader) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "detected\n"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "\n\n# detected\n"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, " explicit\n"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "\t\ndetected\n"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_2);
+}
+
+TEST_F(HandlerSpecTest, Ex8_3a_InvalidBlockScalarIndentationIndicators) {
+ EXPECT_THROW_PARSER_EXCEPTION(IgnoreParse(ex8_3a), ErrorMsg::END_OF_SEQ);
+}
+
+TEST_F(HandlerSpecTest, Ex8_3b_InvalidBlockScalarIndentationIndicators) {
+ EXPECT_THROW_PARSER_EXCEPTION(IgnoreParse(ex8_3b), ErrorMsg::END_OF_SEQ);
+}
+
+TEST_F(HandlerSpecTest, Ex8_3c_InvalidBlockScalarIndentationIndicators) {
+ EXPECT_THROW_PARSER_EXCEPTION(IgnoreParse(ex8_3c), ErrorMsg::END_OF_SEQ);
+}
+
+TEST_F(HandlerSpecTest, Ex8_4_ChompingFinalLineBreak) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "strip"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "text"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "clip"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "text\n"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "keep"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "text\n"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_4);
+}
+
+TEST_F(HandlerSpecTest, DISABLED_Ex8_5_ChompingTrailingLines) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "strip"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "# text"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "clip"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "# text\n"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "keep"));
+ // NOTE: I believe this is a bug in the YAML spec -
+ // it should be "# text\n\n"
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "# text\n"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_5);
+}
+
+TEST_F(HandlerSpecTest, Ex8_6_EmptyScalarChomping) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "strip"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, ""));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "clip"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, ""));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "keep"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "\n"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_6);
+}
+
+TEST_F(HandlerSpecTest, Ex8_7_LiteralScalar) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "literal\n\ttext\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_7);
+}
+
+TEST_F(HandlerSpecTest, Ex8_8_LiteralContent) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "\n\nliteral\n \n\ntext\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_8);
+}
+
+TEST_F(HandlerSpecTest, Ex8_9_FoldedScalar) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "folded text\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_9);
+}
+
+TEST_F(HandlerSpecTest, Ex8_10_FoldedLines) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler,
+ OnScalar(_, "!", 0,
+ "\nfolded line\nnext line\n * bullet\n\n * list\n * "
+ "lines\n\nlast line\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_10);
+}
+
+TEST_F(HandlerSpecTest, Ex8_11_MoreIndentedLines) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler,
+ OnScalar(_, "!", 0,
+ "\nfolded line\nnext line\n * bullet\n\n * list\n * "
+ "lines\n\nlast line\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_11);
+}
+
+TEST_F(HandlerSpecTest, Ex8_12_EmptySeparationLines) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler,
+ OnScalar(_, "!", 0,
+ "\nfolded line\nnext line\n * bullet\n\n * list\n * "
+ "lines\n\nlast line\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_12);
+}
+
+TEST_F(HandlerSpecTest, Ex8_13_FinalEmptyLines) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler,
+ OnScalar(_, "!", 0,
+ "\nfolded line\nnext line\n * bullet\n\n * list\n * "
+ "lines\n\nlast line\n"));
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_13);
+}
+
+TEST_F(HandlerSpecTest, Ex8_14_BlockSequence) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "block sequence"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "one"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "two"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "three"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_14);
+}
+
+TEST_F(HandlerSpecTest, Ex8_15_BlockSequenceEntryTypes) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "block node\n"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "one"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "two"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "one"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "two"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_15);
+}
+
+TEST_F(HandlerSpecTest, Ex8_16_BlockMappings) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "block mapping"));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "key"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "value"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_16);
+}
+
+TEST_F(HandlerSpecTest, Ex8_17_ExplicitBlockMappingEntries) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "explicit key"));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "block key\n"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "one"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "two"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_17);
+}
+
+TEST_F(HandlerSpecTest, Ex8_18_ImplicitBlockMappingEntries) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "plain key"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "in-line value"));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "quoted key"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "entry"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_18);
+}
+
+TEST_F(HandlerSpecTest, Ex8_19_CompactBlockMappings) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "sun"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "yellow"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "earth"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "blue"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "moon"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "white"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_19);
+}
+
+TEST_F(HandlerSpecTest, Ex8_20_BlockNodeTypes) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnSequenceStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "flow in block"));
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "Block scalar\n"));
+ EXPECT_CALL(handler,
+ OnMapStart(_, "tag:yaml.org,2002:map", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_20);
+}
+
+TEST_F(HandlerSpecTest, DISABLED_Ex8_21_BlockScalarNodes) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "literal"));
+ // NOTE: I believe this is a bug in the YAML spec
+ // - it should be "value\n"
+ EXPECT_CALL(handler, OnScalar(_, "!", 0, "value"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "folded"));
+ EXPECT_CALL(handler, OnScalar(_, "!foo", 0, "value"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_21);
+}
+
+TEST_F(HandlerSpecTest, Ex8_22_BlockCollectionNodes) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "sequence"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "tag:yaml.org,2002:seq", 0,
+ EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "entry"));
+ EXPECT_CALL(handler, OnSequenceStart(_, "tag:yaml.org,2002:seq", 0,
+ EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "nested"));
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnSequenceEnd());
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "mapping"));
+ EXPECT_CALL(handler,
+ OnMapStart(_, "tag:yaml.org,2002:map", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse(ex8_22);
+}
+} // namespace
+} // namespace YAML
--- /dev/null
+#include "handler_test.h"
+#include "specexamples.h" // IWYU pragma: keep
+#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using ::testing::_;
+
+#define EXPECT_THROW_PARSER_EXCEPTION(statement, message) \
+ ASSERT_THROW(statement, ParserException); \
+ try { \
+ statement; \
+ } catch (const ParserException& e) { \
+ EXPECT_EQ(e.msg, message); \
+ }
+
+namespace YAML {
+namespace {
+
+TEST_F(HandlerTest, NoEndOfMapFlow) {
+ EXPECT_THROW_PARSER_EXCEPTION(IgnoreParse("---{header: {id: 1"),
+ ErrorMsg::END_OF_MAP_FLOW);
+}
+
+TEST_F(HandlerTest, PlainScalarStartingWithQuestionMark) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "?bar"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse("foo: ?bar");
+}
+
+TEST_F(HandlerTest, NullStringScalar) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "foo"));
+ EXPECT_CALL(handler, OnNull(_, 0));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse("foo: null");
+}
+
+TEST_F(HandlerTest, CommentOnNewlineOfMapValueWithNoSpaces) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "key"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "value"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse("key: value\n# comment");
+}
+
+TEST_F(HandlerTest, CommentOnNewlineOfMapValueWithOneSpace) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "key"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "value"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse("key: value\n # comment");
+}
+
+TEST_F(HandlerTest, CommentOnNewlineOfMapValueWithManySpace) {
+ EXPECT_CALL(handler, OnDocumentStart(_));
+ EXPECT_CALL(handler, OnMapStart(_, "?", 0, EmitterStyle::Block));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "key"));
+ EXPECT_CALL(handler, OnScalar(_, "?", 0, "value"));
+ EXPECT_CALL(handler, OnMapEnd());
+ EXPECT_CALL(handler, OnDocumentEnd());
+ Parse("key: value\n # comment");
+}
+} // namespace
+} // namespace YAML
--- /dev/null
+#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+
+#include "gtest/gtest.h"
+
+namespace YAML {
+namespace {
+TEST(LoadNodeTest, Reassign) {
+ Node node = Load("foo");
+ node = Node();
+ EXPECT_TRUE(node.IsNull());
+}
+
+TEST(LoadNodeTest, FallbackValues) {
+ Node node = Load("foo: bar\nx: 2");
+ EXPECT_EQ("bar", node["foo"].as<std::string>());
+ EXPECT_EQ("bar", node["foo"].as<std::string>("hello"));
+ EXPECT_EQ("hello", node["baz"].as<std::string>("hello"));
+ EXPECT_EQ(2, node["x"].as<int>());
+ EXPECT_EQ(2, node["x"].as<int>(5));
+ EXPECT_EQ(5, node["y"].as<int>(5));
+}
+
+TEST(LoadNodeTest, NumericConversion) {
+ EXPECT_EQ(1.5f, Load("1.5").as<float>());
+ EXPECT_EQ(1.5, Load("1.5").as<double>());
+ EXPECT_THROW(Load("1.5").as<int>(), TypedBadConversion<int>);
+ EXPECT_EQ(1, Load("1").as<int>());
+ EXPECT_EQ(1.0f, Load("1").as<float>());
+ EXPECT_NE(Load(".nan").as<float>(), Load(".nan").as<float>());
+ EXPECT_EQ(std::numeric_limits<float>::infinity(), Load(".inf").as<float>());
+ EXPECT_EQ(-std::numeric_limits<float>::infinity(), Load("-.inf").as<float>());
+ EXPECT_EQ(21, Load("0x15").as<int>());
+ EXPECT_EQ(13, Load("015").as<int>());
+ EXPECT_EQ(-128, +Load("-128").as<int8_t>());
+ EXPECT_EQ(127, +Load("127").as<int8_t>());
+ EXPECT_THROW(Load("128").as<int8_t>(), TypedBadConversion<signed char>);
+ EXPECT_EQ(255, +Load("255").as<uint8_t>());
+ EXPECT_THROW(Load("256").as<uint8_t>(), TypedBadConversion<unsigned char>);
+ // test as<char>/as<uint8_t> with ‘a’,"ab",'1',"127"
+ EXPECT_EQ('a', Load("a").as<char>());
+ EXPECT_THROW(Load("ab").as<char>(), TypedBadConversion<char>);
+ EXPECT_EQ('1', Load("1").as<char>());
+ EXPECT_THROW(Load("127").as<char>(), TypedBadConversion<char>);
+ EXPECT_THROW(Load("a").as<uint8_t>(), TypedBadConversion<unsigned char>);
+ EXPECT_THROW(Load("ab").as<uint8_t>(), TypedBadConversion<unsigned char>);
+ EXPECT_EQ(1, +Load("1").as<uint8_t>());
+ // Throw exception: convert a negative number to an unsigned number.
+ EXPECT_THROW(Load("-128").as<unsigned>(), TypedBadConversion<unsigned int>);
+ EXPECT_THROW(Load("-128").as<unsigned short>(), TypedBadConversion<unsigned short>);
+ EXPECT_THROW(Load("-128").as<unsigned long>(), TypedBadConversion<unsigned long>);
+ EXPECT_THROW(Load("-128").as<unsigned long long>(), TypedBadConversion<unsigned long long>);
+ EXPECT_THROW(Load("-128").as<uint8_t>(), TypedBadConversion<unsigned char>);
+}
+
+TEST(LoadNodeTest, Binary) {
+ Node node = Load(
+ "[!!binary \"SGVsbG8sIFdvcmxkIQ==\", !!binary "
+ "\"TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieS"
+ "B0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIG"
+ "x1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbi"
+ "B0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZG"
+ "dlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS"
+ "4K\"]");
+ EXPECT_EQ(Binary(reinterpret_cast<const unsigned char*>("Hello, World!"), 13),
+ node[0].as<Binary>());
+ EXPECT_EQ(Binary(reinterpret_cast<const unsigned char*>(
+ "Man is distinguished, not only by his reason, "
+ "but by this singular passion from other "
+ "animals, which is a lust of the mind, that by "
+ "a perseverance of delight in the continued and "
+ "indefatigable generation of knowledge, exceeds "
+ "the short vehemence of any carnal pleasure.\n"),
+ 270),
+ node[1].as<Binary>());
+}
+
+TEST(LoadNodeTest, BinaryWithWhitespaces) {
+ Node node = Load(
+ "binaryText: !binary |-\n"
+ " TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieS\n"
+ " B0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIG\n"
+ " x1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbi\n"
+ " B0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZG\n"
+ " dlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS\n"
+ " 4K");
+ EXPECT_EQ(Binary(reinterpret_cast<const unsigned char*>(
+ "Man is distinguished, not only by his reason, "
+ "but by this singular passion from other "
+ "animals, which is a lust of the mind, that by "
+ "a perseverance of delight in the continued and "
+ "indefatigable generation of knowledge, exceeds "
+ "the short vehemence of any carnal pleasure.\n"),
+ 270),
+ node["binaryText"].as<Binary>());
+}
+
+TEST(LoadNodeTest, IterateSequence) {
+ Node node = Load("[1, 3, 5, 7]");
+ int seq[] = {1, 3, 5, 7};
+ int i = 0;
+ for (const_iterator it = node.begin(); it != node.end(); ++it) {
+ EXPECT_TRUE(i < 4);
+ int x = seq[i++];
+ EXPECT_EQ(x, it->as<int>());
+ }
+ EXPECT_EQ(4, i);
+}
+
+TEST(LoadNodeTest, IterateMap) {
+ Node node = Load("{a: A, b: B, c: C}");
+ int i = 0;
+ for (const_iterator it = node.begin(); it != node.end(); ++it) {
+ EXPECT_TRUE(i < 3);
+ i++;
+ EXPECT_EQ(it->second.as<char>(), it->first.as<char>() + 'A' - 'a');
+ }
+ EXPECT_EQ(3, i);
+}
+
+#ifdef BOOST_FOREACH
+TEST(LoadNodeTest, ForEach) {
+ Node node = Load("[1, 3, 5, 7]");
+ int seq[] = {1, 3, 5, 7};
+ int i = 0;
+ BOOST_FOREACH (const Node& item, node) {
+ int x = seq[i++];
+ EXPECT_EQ(x, item.as<int>());
+ }
+}
+
+TEST(LoadNodeTest, ForEachMap) {
+ Node node = Load("{a: A, b: B, c: C}");
+ BOOST_FOREACH (const const_iterator::value_type& p, node) {
+ EXPECT_EQ(p.second.as<char>(), p.first.as<char>() + 'A' - 'a');
+ }
+}
+#endif
+
+TEST(LoadNodeTest, CloneScalar) {
+ Node node = Load("!foo monkey");
+ Node clone = Clone(node);
+ EXPECT_FALSE(clone == node);
+ EXPECT_EQ(clone.as<std::string>(), node.as<std::string>());
+ EXPECT_EQ(clone.Tag(), node.Tag());
+}
+
+TEST(LoadNodeTest, CloneSeq) {
+ Node node = Load("[1, 3, 5, 7]");
+ Node clone = Clone(node);
+ EXPECT_FALSE(clone == node);
+ EXPECT_EQ(NodeType::Sequence, clone.Type());
+ EXPECT_EQ(clone.size(), node.size());
+ for (std::size_t i = 0; i < node.size(); i++) {
+ EXPECT_EQ(clone[i].as<int>(), node[i].as<int>());
+ }
+}
+
+TEST(LoadNodeTest, CloneMap) {
+ Node node = Load("{foo: bar}");
+ Node clone = Clone(node);
+ EXPECT_FALSE(clone == node);
+ EXPECT_EQ(NodeType::Map, clone.Type());
+ EXPECT_EQ(clone.size(), node.size());
+ EXPECT_EQ(clone["foo"].as<std::string>(), node["foo"].as<std::string>());
+}
+
+TEST(LoadNodeTest, CloneAlias) {
+ Node node = Load("&foo [*foo]");
+ Node clone = Clone(node);
+ EXPECT_FALSE(clone == node);
+ EXPECT_EQ(NodeType::Sequence, clone.Type());
+ EXPECT_EQ(clone.size(), node.size());
+ EXPECT_EQ(clone[0], clone);
+}
+
+TEST(LoadNodeTest, ForceInsertIntoMap) {
+ Node node;
+ node["a"] = "b";
+ node.force_insert("x", "y");
+ node.force_insert("a", 5);
+ EXPECT_EQ(3, node.size());
+ EXPECT_EQ(NodeType::Map, node.Type());
+ bool ab = false;
+ bool a5 = false;
+ bool xy = false;
+ for (const_iterator it = node.begin(); it != node.end(); ++it) {
+ if (it->first.as<std::string>() == "a") {
+ if (it->second.as<std::string>() == "b")
+ ab = true;
+ else if (it->second.as<std::string>() == "5")
+ a5 = true;
+ } else if (it->first.as<std::string>() == "x" &&
+ it->second.as<std::string>() == "y")
+ xy = true;
+ }
+ EXPECT_TRUE(ab);
+ EXPECT_TRUE(a5);
+ EXPECT_TRUE(xy);
+}
+
+TEST(LoadNodeTest, ResetNode) {
+ Node node = Load("[1, 2, 3]");
+ EXPECT_TRUE(!node.IsNull());
+ Node other = node;
+ node.reset();
+ EXPECT_TRUE(node.IsNull());
+ EXPECT_TRUE(!other.IsNull());
+ node.reset(other);
+ EXPECT_TRUE(!node.IsNull());
+ EXPECT_EQ(node, other);
+}
+
+TEST(LoadNodeTest, EmptyString) {
+ Node node = Load("\"\"");
+ EXPECT_TRUE(!node.IsNull());
+}
+
+TEST(LoadNodeTest, DereferenceIteratorError) {
+ Node node = Load("[{a: b}, 1, 2]");
+ EXPECT_THROW(node.begin()->first.as<int>(), InvalidNode);
+ EXPECT_EQ(true, (*node.begin()).IsMap());
+ EXPECT_EQ(true, node.begin()->IsMap());
+ EXPECT_THROW((*node.begin()->begin()).Type(), InvalidNode);
+ EXPECT_THROW(node.begin()->begin()->Type(), InvalidNode);
+}
+
+TEST(NodeTest, EmitEmptyNode) {
+ Node node;
+ Emitter emitter;
+ emitter << node;
+ EXPECT_EQ("", std::string(emitter.c_str()));
+}
+
+TEST(NodeTest, ParseNodeStyle) {
+ EXPECT_EQ(EmitterStyle::Flow, Load("[1, 2, 3]").Style());
+ EXPECT_EQ(EmitterStyle::Flow, Load("{foo: bar}").Style());
+ EXPECT_EQ(EmitterStyle::Block, Load("- foo\n- bar").Style());
+ EXPECT_EQ(EmitterStyle::Block, Load("foo: bar").Style());
+}
+
+struct ParserExceptionTestCase {
+ std::string name;
+ std::string input;
+ std::string expected_exception;
+};
+
+TEST(NodeTest, IncompleteJson) {
+ std::vector<ParserExceptionTestCase> tests = {
+ {"JSON map without value", "{\"access\"", ErrorMsg::END_OF_MAP_FLOW},
+ {"JSON map with colon but no value", "{\"access\":",
+ ErrorMsg::END_OF_MAP_FLOW},
+ {"JSON map with unclosed value quote", "{\"access\":\"",
+ ErrorMsg::END_OF_MAP_FLOW},
+ {"JSON map without end brace", "{\"access\":\"abc\"",
+ ErrorMsg::END_OF_MAP_FLOW},
+ };
+ for (const ParserExceptionTestCase& test : tests) {
+ try {
+ Load(test.input);
+ FAIL() << "Expected exception " << test.expected_exception << " for "
+ << test.name << ", input: " << test.input;
+ } catch (const ParserException& e) {
+ EXPECT_EQ(test.expected_exception, e.msg);
+ }
+ }
+}
+
+struct SingleNodeTestCase {
+ std::string input;
+ NodeType::value nodeType;
+ int nodeSize;
+ std::string expected_content;
+};
+
+TEST(NodeTest, SpecialFlow) {
+ std::vector<SingleNodeTestCase> tests = {
+ {"[:]", NodeType::Sequence, 1, "[{~: ~}]"},
+ {"[a:]", NodeType::Sequence, 1, "[{a: ~}]"},
+ {"[:a]", NodeType::Sequence, 1, "[:a]"},
+ {"[,]", NodeType::Sequence, 1, "[~]"},
+ {"[a:,]", NodeType::Sequence, 1, "[{a: ~}]"},
+ {"{:}", NodeType::Map, 1, "{~: ~}"},
+ {"{a:}", NodeType::Map, 1, "{a: ~}"},
+ {"{:a}", NodeType::Map, 1, "{:a: ~}"},
+ {"{,}", NodeType::Map, 1, "{~: ~}"},
+ {"{a:,}", NodeType::Map, 1, "{a: ~}"},
+ //testcase for the trailing TAB of scalar
+ {"key\t: value\t", NodeType::Map, 1, "key: value"},
+ {"key\t: value\t #comment", NodeType::Map, 1, "key: value"},
+ {"{key\t: value\t}", NodeType::Map, 1, "{key: value}"},
+ {"{key\t: value\t #comment\n}", NodeType::Map, 1, "{key: value}"},
+ };
+ for (const SingleNodeTestCase& test : tests) {
+ Node node = Load(test.input);
+ Emitter emitter;
+ emitter << node;
+ EXPECT_EQ(test.nodeType, node.Type());
+ EXPECT_EQ(test.nodeSize, node.size());
+ EXPECT_EQ(test.expected_content, std::string(emitter.c_str()));
+ }
+}
+
+TEST(NodeTest, IncorrectFlow) {
+ std::vector<ParserExceptionTestCase> tests = {
+ {"Incorrect yaml: \"{:]\"", "{:]", ErrorMsg::FLOW_END},
+ {"Incorrect yaml: \"[:}\"", "[:}", ErrorMsg::FLOW_END},
+ };
+ for (const ParserExceptionTestCase test : tests) {
+ try {
+ Load(test.input);
+ FAIL() << "Expected exception " << test.expected_exception << " for "
+ << test.name << ", input: " << test.input;
+ } catch (const ParserException& e) {
+ EXPECT_EQ(test.expected_exception, e.msg);
+ }
+ }
+}
+
+TEST(NodeTest, LoadTildeAsNull) {
+ Node node = Load("~");
+ ASSERT_TRUE(node.IsNull());
+ EXPECT_EQ(node.as<std::string>(), "null");
+ EXPECT_EQ(node.as<std::string>("~"), "null");
+}
+
+TEST(NodeTest, LoadNullWithStrTag) {
+ Node node = Load("!!str null");
+ EXPECT_EQ(node.Tag(), "tag:yaml.org,2002:str");
+ EXPECT_EQ(node.as<std::string>(), "null");
+}
+
+TEST(NodeTest, LoadQuotedNull) {
+ Node node = Load("\"null\"");
+ EXPECT_EQ(node.as<std::string>(), "null");
+}
+
+TEST(NodeTest, LoadTagWithParenthesis) {
+ Node node = Load("!Complex(Tag) foo");
+ EXPECT_EQ(node.Tag(), "!Complex(Tag)");
+ EXPECT_EQ(node.as<std::string>(), "foo");
+}
+
+TEST(NodeTest, LoadTagWithNullScalar) {
+ Node node = Load("!2");
+ EXPECT_TRUE(node.IsNull());
+}
+
+TEST(LoadNodeTest, BlockCRNLEncoded) {
+ Node node = Load(
+ "blockText: |\r\n"
+ " some arbitrary text \r\n"
+ " spanning some \r\n"
+ " lines, that are split \r\n"
+ " by CR and NL\r\n"
+ "followup: 1");
+ EXPECT_EQ(
+ "some arbitrary text \nspanning some \nlines, that are split \nby CR and "
+ "NL\n",
+ node["blockText"].as<std::string>());
+ EXPECT_EQ(1, node["followup"].as<int>());
+}
+
+} // namespace
+} // namespace YAML
--- /dev/null
+#include "specexamples.h"
+#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+
+#include "gtest/gtest.h"
+
+#define EXPECT_THROW_PARSER_EXCEPTION(statement, message) \
+ ASSERT_THROW(statement, ParserException); \
+ try { \
+ statement; \
+ } catch (const ParserException& e) { \
+ EXPECT_EQ(e.msg, message); \
+ }
+
+namespace YAML {
+namespace {
+
+TEST(NodeSpecTest, Ex2_1_SeqScalars) {
+ Node doc = Load(ex2_1);
+ EXPECT_TRUE(doc.IsSequence());
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("Mark McGwire", doc[0].as<std::string>());
+ EXPECT_EQ("Sammy Sosa", doc[1].as<std::string>());
+ EXPECT_EQ("Ken Griffey", doc[2].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_2_MappingScalarsToScalars) {
+ Node doc = Load(ex2_2);
+ EXPECT_TRUE(doc.IsMap());
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("65", doc["hr"].as<std::string>());
+ EXPECT_EQ("0.278", doc["avg"].as<std::string>());
+ EXPECT_EQ("147", doc["rbi"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_3_MappingScalarsToSequences) {
+ Node doc = Load(ex2_3);
+ EXPECT_TRUE(doc.IsMap());
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(3, doc["american"].size());
+ EXPECT_EQ("Boston Red Sox", doc["american"][0].as<std::string>());
+ EXPECT_EQ("Detroit Tigers", doc["american"][1].as<std::string>());
+ EXPECT_EQ("New York Yankees", doc["american"][2].as<std::string>());
+ EXPECT_EQ(3, doc["national"].size());
+ EXPECT_EQ("New York Mets", doc["national"][0].as<std::string>());
+ EXPECT_EQ("Chicago Cubs", doc["national"][1].as<std::string>());
+ EXPECT_EQ("Atlanta Braves", doc["national"][2].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_4_SequenceOfMappings) {
+ Node doc = Load(ex2_4);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(3, doc[0].size());
+ EXPECT_EQ("Mark McGwire", doc[0]["name"].as<std::string>());
+ EXPECT_EQ("65", doc[0]["hr"].as<std::string>());
+ EXPECT_EQ("0.278", doc[0]["avg"].as<std::string>());
+ EXPECT_EQ(3, doc[1].size());
+ EXPECT_EQ("Sammy Sosa", doc[1]["name"].as<std::string>());
+ EXPECT_EQ("63", doc[1]["hr"].as<std::string>());
+ EXPECT_EQ("0.288", doc[1]["avg"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_5_SequenceOfSequences) {
+ Node doc = Load(ex2_5);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ(3, doc[0].size());
+ EXPECT_EQ("name", doc[0][0].as<std::string>());
+ EXPECT_EQ("hr", doc[0][1].as<std::string>());
+ EXPECT_EQ("avg", doc[0][2].as<std::string>());
+ EXPECT_EQ(3, doc[1].size());
+ EXPECT_EQ("Mark McGwire", doc[1][0].as<std::string>());
+ EXPECT_EQ("65", doc[1][1].as<std::string>());
+ EXPECT_EQ("0.278", doc[1][2].as<std::string>());
+ EXPECT_EQ(3, doc[2].size());
+ EXPECT_EQ("Sammy Sosa", doc[2][0].as<std::string>());
+ EXPECT_EQ("63", doc[2][1].as<std::string>());
+ EXPECT_EQ("0.288", doc[2][2].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_6_MappingOfMappings) {
+ Node doc = Load(ex2_6);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(2, doc["Mark McGwire"].size());
+ EXPECT_EQ("65", doc["Mark McGwire"]["hr"].as<std::string>());
+ EXPECT_EQ("0.278", doc["Mark McGwire"]["avg"].as<std::string>());
+ EXPECT_EQ(2, doc["Sammy Sosa"].size());
+ EXPECT_EQ("63", doc["Sammy Sosa"]["hr"].as<std::string>());
+ EXPECT_EQ("0.288", doc["Sammy Sosa"]["avg"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_7_TwoDocumentsInAStream) {
+ std::vector<Node> docs = LoadAll(ex2_7);
+ EXPECT_EQ(2, docs.size());
+
+ {
+ Node doc = docs[0];
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("Mark McGwire", doc[0].as<std::string>());
+ EXPECT_EQ("Sammy Sosa", doc[1].as<std::string>());
+ EXPECT_EQ("Ken Griffey", doc[2].as<std::string>());
+ }
+
+ {
+ Node doc = docs[1];
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ("Chicago Cubs", doc[0].as<std::string>());
+ EXPECT_EQ("St Louis Cardinals", doc[1].as<std::string>());
+ }
+}
+
+TEST(NodeSpecTest, Ex2_8_PlayByPlayFeed) {
+ std::vector<Node> docs = LoadAll(ex2_8);
+ EXPECT_EQ(2, docs.size());
+
+ {
+ Node doc = docs[0];
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("20:03:20", doc["time"].as<std::string>());
+ EXPECT_EQ("Sammy Sosa", doc["player"].as<std::string>());
+ EXPECT_EQ("strike (miss)", doc["action"].as<std::string>());
+ }
+
+ {
+ Node doc = docs[1];
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("20:03:47", doc["time"].as<std::string>());
+ EXPECT_EQ("Sammy Sosa", doc["player"].as<std::string>());
+ EXPECT_EQ("grand slam", doc["action"].as<std::string>());
+ }
+}
+
+TEST(NodeSpecTest, Ex2_9_SingleDocumentWithTwoComments) {
+ Node doc = Load(ex2_9);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(2, doc["hr"].size());
+ EXPECT_EQ("Mark McGwire", doc["hr"][0].as<std::string>());
+ EXPECT_EQ("Sammy Sosa", doc["hr"][1].as<std::string>());
+ EXPECT_EQ(2, doc["rbi"].size());
+ EXPECT_EQ("Sammy Sosa", doc["rbi"][0].as<std::string>());
+ EXPECT_EQ("Ken Griffey", doc["rbi"][1].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_10_SimpleAnchor) {
+ Node doc = Load(ex2_10);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(2, doc["hr"].size());
+ EXPECT_EQ("Mark McGwire", doc["hr"][0].as<std::string>());
+ EXPECT_EQ("Sammy Sosa", doc["hr"][1].as<std::string>());
+ EXPECT_EQ(2, doc["rbi"].size());
+ EXPECT_EQ("Sammy Sosa", doc["rbi"][0].as<std::string>());
+ EXPECT_EQ("Ken Griffey", doc["rbi"][1].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_11_MappingBetweenSequences) {
+ Node doc = Load(ex2_11);
+
+ std::vector<std::string> tigers_cubs;
+ tigers_cubs.push_back("Detroit Tigers");
+ tigers_cubs.push_back("Chicago cubs");
+
+ std::vector<std::string> yankees_braves;
+ yankees_braves.push_back("New York Yankees");
+ yankees_braves.push_back("Atlanta Braves");
+
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(1, doc[tigers_cubs].size());
+ EXPECT_EQ("2001-07-23", doc[tigers_cubs][0].as<std::string>());
+ EXPECT_EQ(3, doc[yankees_braves].size());
+ EXPECT_EQ("2001-07-02", doc[yankees_braves][0].as<std::string>());
+ EXPECT_EQ("2001-08-12", doc[yankees_braves][1].as<std::string>());
+ EXPECT_EQ("2001-08-14", doc[yankees_braves][2].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_12_CompactNestedMapping) {
+ Node doc = Load(ex2_12);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ(2, doc[0].size());
+ EXPECT_EQ("Super Hoop", doc[0]["item"].as<std::string>());
+ EXPECT_EQ(1, doc[0]["quantity"].as<int>());
+ EXPECT_EQ(2, doc[1].size());
+ EXPECT_EQ("Basketball", doc[1]["item"].as<std::string>());
+ EXPECT_EQ(4, doc[1]["quantity"].as<int>());
+ EXPECT_EQ(2, doc[2].size());
+ EXPECT_EQ("Big Shoes", doc[2]["item"].as<std::string>());
+ EXPECT_EQ(1, doc[2]["quantity"].as<int>());
+}
+
+TEST(NodeSpecTest, Ex2_13_InLiteralsNewlinesArePreserved) {
+ Node doc = Load(ex2_13);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ "\\//||\\/||\n"
+ "// || ||__");
+}
+
+TEST(NodeSpecTest, Ex2_14_InFoldedScalarsNewlinesBecomeSpaces) {
+ Node doc = Load(ex2_14);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ "Mark McGwire's year was crippled by a knee injury.");
+}
+
+TEST(NodeSpecTest,
+ Ex2_15_FoldedNewlinesArePreservedForMoreIndentedAndBlankLines) {
+ Node doc = Load(ex2_15);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ "Sammy Sosa completed another fine season with great stats.\n\n"
+ " 63 Home Runs\n"
+ " 0.288 Batting Average\n\n"
+ "What a year!");
+}
+
+TEST(NodeSpecTest, Ex2_16_IndentationDeterminesScope) {
+ Node doc = Load(ex2_16);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("Mark McGwire", doc["name"].as<std::string>());
+ EXPECT_TRUE(doc["accomplishment"].as<std::string>() ==
+ "Mark set a major league home run record in 1998.\n");
+ EXPECT_TRUE(doc["stats"].as<std::string>() ==
+ "65 Home Runs\n0.278 Batting Average\n");
+}
+
+TEST(NodeSpecTest, Ex2_17_QuotedScalars) {
+ Node doc = Load(ex2_17);
+ EXPECT_EQ(6, doc.size());
+ EXPECT_EQ("Sosa did fine.\xe2\x98\xba", doc["unicode"].as<std::string>());
+ EXPECT_EQ("\b1998\t1999\t2000\n", doc["control"].as<std::string>());
+ EXPECT_EQ("\x0d\x0a is \r\n", doc["hex esc"].as<std::string>());
+ EXPECT_EQ("\"Howdy!\" he cried.", doc["single"].as<std::string>());
+ EXPECT_EQ(" # Not a 'comment'.", doc["quoted"].as<std::string>());
+ EXPECT_EQ("|\\-*-/|", doc["tie-fighter"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_18_MultiLineFlowScalars) {
+ Node doc = Load(ex2_18);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_TRUE(doc["plain"].as<std::string>() ==
+ "This unquoted scalar spans many lines.");
+ EXPECT_TRUE(doc["quoted"].as<std::string>() ==
+ "So does this quoted scalar.\n");
+}
+
+// TODO: 2.19 - 2.22 schema tags
+
+TEST(NodeSpecTest, Ex2_23_VariousExplicitTags) {
+ Node doc = Load(ex2_23);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("tag:yaml.org,2002:str", doc["not-date"].Tag());
+ EXPECT_EQ("2002-04-28", doc["not-date"].as<std::string>());
+ EXPECT_EQ("tag:yaml.org,2002:binary", doc["picture"].Tag());
+ EXPECT_TRUE(doc["picture"].as<std::string>() ==
+ "R0lGODlhDAAMAIQAAP//9/X\n"
+ "17unp5WZmZgAAAOfn515eXv\n"
+ "Pz7Y6OjuDg4J+fn5OTk6enp\n"
+ "56enmleECcgggoBADs=\n");
+ EXPECT_EQ("!something", doc["application specific tag"].Tag());
+ EXPECT_TRUE(doc["application specific tag"].as<std::string>() ==
+ "The semantics of the tag\n"
+ "above may be different for\n"
+ "different documents.");
+}
+
+TEST(NodeSpecTest, Ex2_24_GlobalTags) {
+ Node doc = Load(ex2_24);
+ EXPECT_EQ("tag:clarkevans.com,2002:shape", doc.Tag());
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("tag:clarkevans.com,2002:circle", doc[0].Tag());
+ EXPECT_EQ(2, doc[0].size());
+ EXPECT_EQ(2, doc[0]["center"].size());
+ EXPECT_EQ(73, doc[0]["center"]["x"].as<int>());
+ EXPECT_EQ(129, doc[0]["center"]["y"].as<int>());
+ EXPECT_EQ(7, doc[0]["radius"].as<int>());
+ EXPECT_EQ("tag:clarkevans.com,2002:line", doc[1].Tag());
+ EXPECT_EQ(2, doc[1].size());
+ EXPECT_EQ(2, doc[1]["start"].size());
+ EXPECT_EQ(73, doc[1]["start"]["x"].as<int>());
+ EXPECT_EQ(129, doc[1]["start"]["y"].as<int>());
+ EXPECT_EQ(2, doc[1]["finish"].size());
+ EXPECT_EQ(89, doc[1]["finish"]["x"].as<int>());
+ EXPECT_EQ(102, doc[1]["finish"]["y"].as<int>());
+ EXPECT_EQ("tag:clarkevans.com,2002:label", doc[2].Tag());
+ EXPECT_EQ(3, doc[2].size());
+ EXPECT_EQ(2, doc[2]["start"].size());
+ EXPECT_EQ(73, doc[2]["start"]["x"].as<int>());
+ EXPECT_EQ(129, doc[2]["start"]["y"].as<int>());
+ EXPECT_EQ("0xFFEEBB", doc[2]["color"].as<std::string>());
+ EXPECT_EQ("Pretty vector drawing.", doc[2]["text"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_25_UnorderedSets) {
+ Node doc = Load(ex2_25);
+ EXPECT_EQ("tag:yaml.org,2002:set", doc.Tag());
+ EXPECT_EQ(3, doc.size());
+ EXPECT_TRUE(doc["Mark McGwire"].IsNull());
+ EXPECT_TRUE(doc["Sammy Sosa"].IsNull());
+ EXPECT_TRUE(doc["Ken Griffey"].IsNull());
+}
+
+TEST(NodeSpecTest, Ex2_16_OrderedMappings) {
+ Node doc = Load(ex2_26);
+ EXPECT_EQ("tag:yaml.org,2002:omap", doc.Tag());
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ(1, doc[0].size());
+ EXPECT_EQ(65, doc[0]["Mark McGwire"].as<int>());
+ EXPECT_EQ(1, doc[1].size());
+ EXPECT_EQ(63, doc[1]["Sammy Sosa"].as<int>());
+ EXPECT_EQ(1, doc[2].size());
+ EXPECT_EQ(58, doc[2]["Ken Griffey"].as<int>());
+}
+
+TEST(NodeSpecTest, Ex2_27_Invoice) {
+ Node doc = Load(ex2_27);
+ EXPECT_EQ("tag:clarkevans.com,2002:invoice", doc.Tag());
+ EXPECT_EQ(8, doc.size());
+ EXPECT_EQ(34843, doc["invoice"].as<int>());
+ EXPECT_EQ("2001-01-23", doc["date"].as<std::string>());
+ EXPECT_EQ(3, doc["bill-to"].size());
+ EXPECT_EQ("Chris", doc["bill-to"]["given"].as<std::string>());
+ EXPECT_EQ("Dumars", doc["bill-to"]["family"].as<std::string>());
+ EXPECT_EQ(4, doc["bill-to"]["address"].size());
+ EXPECT_TRUE(doc["bill-to"]["address"]["lines"].as<std::string>() ==
+ "458 Walkman Dr.\nSuite #292\n");
+ EXPECT_TRUE(doc["bill-to"]["address"]["city"].as<std::string>() ==
+ "Royal Oak");
+ EXPECT_EQ("MI", doc["bill-to"]["address"]["state"].as<std::string>());
+ EXPECT_EQ("48046", doc["bill-to"]["address"]["postal"].as<std::string>());
+ EXPECT_EQ(3, doc["ship-to"].size());
+ EXPECT_EQ("Chris", doc["ship-to"]["given"].as<std::string>());
+ EXPECT_EQ("Dumars", doc["ship-to"]["family"].as<std::string>());
+ EXPECT_EQ(4, doc["ship-to"]["address"].size());
+ EXPECT_TRUE(doc["ship-to"]["address"]["lines"].as<std::string>() ==
+ "458 Walkman Dr.\nSuite #292\n");
+ EXPECT_TRUE(doc["ship-to"]["address"]["city"].as<std::string>() ==
+ "Royal Oak");
+ EXPECT_EQ("MI", doc["ship-to"]["address"]["state"].as<std::string>());
+ EXPECT_EQ("48046", doc["ship-to"]["address"]["postal"].as<std::string>());
+ EXPECT_EQ(2, doc["product"].size());
+ EXPECT_EQ(4, doc["product"][0].size());
+ EXPECT_EQ("BL394D", doc["product"][0]["sku"].as<std::string>());
+ EXPECT_EQ(4, doc["product"][0]["quantity"].as<int>());
+ EXPECT_TRUE(doc["product"][0]["description"].as<std::string>() ==
+ "Basketball");
+ EXPECT_EQ("450.00", doc["product"][0]["price"].as<std::string>());
+ EXPECT_EQ(4, doc["product"][1].size());
+ EXPECT_EQ("BL4438H", doc["product"][1]["sku"].as<std::string>());
+ EXPECT_EQ(1, doc["product"][1]["quantity"].as<int>());
+ EXPECT_TRUE(doc["product"][1]["description"].as<std::string>() ==
+ "Super Hoop");
+ EXPECT_EQ("2392.00", doc["product"][1]["price"].as<std::string>());
+ EXPECT_EQ("251.42", doc["tax"].as<std::string>());
+ EXPECT_EQ("4443.52", doc["total"].as<std::string>());
+ EXPECT_EQ(
+ "Late afternoon is best. Backup contact is Nancy Billsmer @ 338-4338.",
+ doc["comments"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex2_28_LogFile) {
+ std::vector<Node> docs = LoadAll(ex2_28);
+ EXPECT_EQ(3, docs.size());
+
+ {
+ Node doc = docs[0];
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("2001-11-23 15:01:42 -5", doc["Time"].as<std::string>());
+ EXPECT_EQ("ed", doc["User"].as<std::string>());
+ EXPECT_TRUE(doc["Warning"].as<std::string>() ==
+ "This is an error message for the log file");
+ }
+
+ {
+ Node doc = docs[1];
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("2001-11-23 15:02:31 -5", doc["Time"].as<std::string>());
+ EXPECT_EQ("ed", doc["User"].as<std::string>());
+ EXPECT_TRUE(doc["Warning"].as<std::string>() ==
+ "A slightly different error message.");
+ }
+
+ {
+ Node doc = docs[2];
+ EXPECT_EQ(4, doc.size());
+ EXPECT_EQ("2001-11-23 15:03:17 -5", doc["Date"].as<std::string>());
+ EXPECT_EQ("ed", doc["User"].as<std::string>());
+ EXPECT_EQ("Unknown variable \"bar\"", doc["Fatal"].as<std::string>());
+ EXPECT_EQ(2, doc["Stack"].size());
+ EXPECT_EQ(3, doc["Stack"][0].size());
+ EXPECT_EQ("TopClass.py", doc["Stack"][0]["file"].as<std::string>());
+ EXPECT_EQ("23", doc["Stack"][0]["line"].as<std::string>());
+ EXPECT_TRUE(doc["Stack"][0]["code"].as<std::string>() ==
+ "x = MoreObject(\"345\\n\")\n");
+ EXPECT_EQ(3, doc["Stack"][1].size());
+ EXPECT_EQ("MoreClass.py", doc["Stack"][1]["file"].as<std::string>());
+ EXPECT_EQ("58", doc["Stack"][1]["line"].as<std::string>());
+ EXPECT_EQ("foo = bar", doc["Stack"][1]["code"].as<std::string>());
+ }
+}
+
+// TODO: 5.1 - 5.2 BOM
+
+TEST(NodeSpecTest, Ex5_3_BlockStructureIndicators) {
+ Node doc = Load(ex5_3);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(2, doc["sequence"].size());
+ EXPECT_EQ("one", doc["sequence"][0].as<std::string>());
+ EXPECT_EQ("two", doc["sequence"][1].as<std::string>());
+ EXPECT_EQ(2, doc["mapping"].size());
+ EXPECT_EQ("blue", doc["mapping"]["sky"].as<std::string>());
+ EXPECT_EQ("green", doc["mapping"]["sea"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex5_4_FlowStructureIndicators) {
+ Node doc = Load(ex5_4);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(2, doc["sequence"].size());
+ EXPECT_EQ("one", doc["sequence"][0].as<std::string>());
+ EXPECT_EQ("two", doc["sequence"][1].as<std::string>());
+ EXPECT_EQ(2, doc["mapping"].size());
+ EXPECT_EQ("blue", doc["mapping"]["sky"].as<std::string>());
+ EXPECT_EQ("green", doc["mapping"]["sea"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex5_5_CommentIndicator) {
+ Node doc = Load(ex5_5);
+ EXPECT_TRUE(doc.IsNull());
+}
+
+TEST(NodeSpecTest, Ex5_6_NodePropertyIndicators) {
+ Node doc = Load(ex5_6);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_TRUE(doc["anchored"].as<std::string>() ==
+ "value"); // TODO: assert tag
+ EXPECT_EQ("value", doc["alias"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex5_7_BlockScalarIndicators) {
+ Node doc = Load(ex5_7);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ("some\ntext\n", doc["literal"].as<std::string>());
+ EXPECT_EQ("some text\n", doc["folded"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex5_8_QuotedScalarIndicators) {
+ Node doc = Load(ex5_8);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ("text", doc["single"].as<std::string>());
+ EXPECT_EQ("text", doc["double"].as<std::string>());
+}
+
+// TODO: 5.9 directive
+// TODO: 5.10 reserved indicator
+
+TEST(NodeSpecTest, Ex5_11_LineBreakCharacters) {
+ Node doc = Load(ex5_11);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ "Line break (no glyph)\nLine break (glyphed)\n");
+}
+
+TEST(NodeSpecTest, Ex5_12_TabsAndSpaces) {
+ Node doc = Load(ex5_12);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ("Quoted\t", doc["quoted"].as<std::string>());
+ EXPECT_TRUE(doc["block"].as<std::string>() ==
+ "void main() {\n"
+ "\tprintf(\"Hello, world!\\n\");\n"
+ "}");
+}
+
+TEST(NodeSpecTest, Ex5_13_EscapedCharacters) {
+ Node doc = Load(ex5_13);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ "Fun with \x5C \x22 \x07 \x08 \x1B \x0C \x0A \x0D \x09 \x0B " +
+ std::string("\x00", 1) +
+ " \x20 \xA0 \x85 \xe2\x80\xa8 \xe2\x80\xa9 A A A");
+}
+
+TEST(NodeSpecTest, Ex5_14_InvalidEscapedCharacters) {
+ EXPECT_THROW_PARSER_EXCEPTION(Load(ex5_14),
+ std::string(ErrorMsg::INVALID_ESCAPE) + "c");
+}
+
+TEST(NodeSpecTest, Ex6_1_IndentationSpaces) {
+ Node doc = Load(ex6_1);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ(2, doc["Not indented"].size());
+ EXPECT_TRUE(doc["Not indented"]["By one space"].as<std::string>() ==
+ "By four\n spaces\n");
+ EXPECT_EQ(3, doc["Not indented"]["Flow style"].size());
+ EXPECT_TRUE(doc["Not indented"]["Flow style"][0].as<std::string>() ==
+ "By two");
+ EXPECT_TRUE(doc["Not indented"]["Flow style"][1].as<std::string>() ==
+ "Also by two");
+ EXPECT_TRUE(doc["Not indented"]["Flow style"][2].as<std::string>() ==
+ "Still by two");
+}
+
+TEST(NodeSpecTest, Ex6_2_IndentationIndicators) {
+ Node doc = Load(ex6_2);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ(2, doc["a"].size());
+ EXPECT_EQ("b", doc["a"][0].as<std::string>());
+ EXPECT_EQ(2, doc["a"][1].size());
+ EXPECT_EQ("c", doc["a"][1][0].as<std::string>());
+ EXPECT_EQ("d", doc["a"][1][1].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_3_SeparationSpaces) {
+ Node doc = Load(ex6_3);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(1, doc[0].size());
+ EXPECT_EQ("bar", doc[0]["foo"].as<std::string>());
+ EXPECT_EQ(2, doc[1].size());
+ EXPECT_EQ("baz", doc[1][0].as<std::string>());
+ EXPECT_EQ("baz", doc[1][1].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_4_LinePrefixes) {
+ Node doc = Load(ex6_4);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("text lines", doc["plain"].as<std::string>());
+ EXPECT_EQ("text lines", doc["quoted"].as<std::string>());
+ EXPECT_EQ("text\n \tlines\n", doc["block"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_5_EmptyLines) {
+ Node doc = Load(ex6_5);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ("Empty line\nas a line feed", doc["Folding"].as<std::string>());
+ EXPECT_EQ("Clipped empty lines\n", doc["Chomping"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_6_LineFolding) {
+ Node doc = Load(ex6_6);
+ EXPECT_EQ("trimmed\n\n\nas space", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_7_BlockFolding) {
+ Node doc = Load(ex6_7);
+ EXPECT_EQ("foo \n\n\t bar\n\nbaz\n", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_8_FlowFolding) {
+ Node doc = Load(ex6_8);
+ EXPECT_EQ(" foo\nbar\nbaz ", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_9_SeparatedComment) {
+ Node doc = Load(ex6_9);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ("value", doc["key"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_10_CommentLines) {
+ Node doc = Load(ex6_10);
+ EXPECT_TRUE(doc.IsNull());
+}
+
+TEST(NodeSpecTest, Ex6_11_MultiLineComments) {
+ Node doc = Load(ex6_11);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ("value", doc["key"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_12_SeparationSpacesII) {
+ Node doc = Load(ex6_12);
+
+ std::map<std::string, std::string> sammy;
+ sammy["first"] = "Sammy";
+ sammy["last"] = "Sosa";
+
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ(2, doc[sammy].size());
+ EXPECT_EQ(65, doc[sammy]["hr"].as<int>());
+ EXPECT_EQ("0.278", doc[sammy]["avg"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_13_ReservedDirectives) {
+ Node doc = Load(ex6_13);
+ EXPECT_EQ("foo", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_14_YAMLDirective) {
+ Node doc = Load(ex6_14);
+ EXPECT_EQ("foo", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_15_InvalidRepeatedYAMLDirective) {
+ EXPECT_THROW_PARSER_EXCEPTION(Load(ex6_15),
+ ErrorMsg::REPEATED_YAML_DIRECTIVE);
+}
+
+TEST(NodeSpecTest, Ex6_16_TagDirective) {
+ Node doc = Load(ex6_16);
+ EXPECT_EQ("tag:yaml.org,2002:str", doc.Tag());
+ EXPECT_EQ("foo", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_17_InvalidRepeatedTagDirective) {
+ EXPECT_THROW_PARSER_EXCEPTION(Load(ex6_17), ErrorMsg::REPEATED_TAG_DIRECTIVE);
+}
+
+TEST(NodeSpecTest, Ex6_18_PrimaryTagHandle) {
+ std::vector<Node> docs = LoadAll(ex6_18);
+ EXPECT_EQ(2, docs.size());
+
+ {
+ Node doc = docs[0];
+ EXPECT_EQ("!foo", doc.Tag());
+ EXPECT_EQ("bar", doc.as<std::string>());
+ }
+
+ {
+ Node doc = docs[1];
+ EXPECT_EQ("tag:example.com,2000:app/foo", doc.Tag());
+ EXPECT_EQ("bar", doc.as<std::string>());
+ }
+}
+
+TEST(NodeSpecTest, Ex6_19_SecondaryTagHandle) {
+ Node doc = Load(ex6_19);
+ EXPECT_EQ("tag:example.com,2000:app/int", doc.Tag());
+ EXPECT_EQ("1 - 3", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_20_TagHandles) {
+ Node doc = Load(ex6_20);
+ EXPECT_EQ("tag:example.com,2000:app/foo", doc.Tag());
+ EXPECT_EQ("bar", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_21_LocalTagPrefix) {
+ std::vector<Node> docs = LoadAll(ex6_21);
+ EXPECT_EQ(2, docs.size());
+
+ {
+ Node doc = docs[0];
+ EXPECT_EQ("!my-light", doc.Tag());
+ EXPECT_EQ("fluorescent", doc.as<std::string>());
+ }
+
+ {
+ Node doc = docs[1];
+ EXPECT_EQ("!my-light", doc.Tag());
+ EXPECT_EQ("green", doc.as<std::string>());
+ }
+}
+
+TEST(NodeSpecTest, Ex6_22_GlobalTagPrefix) {
+ Node doc = Load(ex6_22);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ("tag:example.com,2000:app/foo", doc[0].Tag());
+ EXPECT_EQ("bar", doc[0].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_23_NodeProperties) {
+ Node doc = Load(ex6_23);
+ EXPECT_EQ(2, doc.size());
+ for (const_iterator it = doc.begin(); it != doc.end(); ++it) {
+ if (it->first.as<std::string>() == "foo") {
+ EXPECT_EQ("tag:yaml.org,2002:str", it->first.Tag());
+ EXPECT_EQ("tag:yaml.org,2002:str", it->second.Tag());
+ EXPECT_EQ("bar", it->second.as<std::string>());
+ } else if (it->first.as<std::string>() == "baz") {
+ EXPECT_EQ("foo", it->second.as<std::string>());
+ } else
+ FAIL() << "unknown key";
+ }
+}
+
+TEST(NodeSpecTest, Ex6_24_VerbatimTags) {
+ Node doc = Load(ex6_24);
+ EXPECT_EQ(1, doc.size());
+ for (const_iterator it = doc.begin(); it != doc.end(); ++it) {
+ EXPECT_EQ("tag:yaml.org,2002:str", it->first.Tag());
+ EXPECT_EQ("foo", it->first.as<std::string>());
+ EXPECT_EQ("!bar", it->second.Tag());
+ EXPECT_EQ("baz", it->second.as<std::string>());
+ }
+}
+
+TEST(NodeSpecTest, DISABLED_Ex6_25_InvalidVerbatimTags) {
+ Node doc = Load(ex6_25);
+ // TODO: check tags (but we probably will say these are valid, I think)
+ FAIL() << "not implemented yet";
+}
+
+TEST(NodeSpecTest, Ex6_26_TagShorthands) {
+ Node doc = Load(ex6_26);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("!local", doc[0].Tag());
+ EXPECT_EQ("foo", doc[0].as<std::string>());
+ EXPECT_EQ("tag:yaml.org,2002:str", doc[1].Tag());
+ EXPECT_EQ("bar", doc[1].as<std::string>());
+ EXPECT_EQ("tag:example.com,2000:app/tag%21", doc[2].Tag());
+ EXPECT_EQ("baz", doc[2].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_27a_InvalidTagShorthands) {
+ EXPECT_THROW_PARSER_EXCEPTION(Load(ex6_27a), ErrorMsg::TAG_WITH_NO_SUFFIX);
+}
+
+// TODO: should we reject this one (since !h! is not declared)?
+TEST(NodeSpecTest, DISABLED_Ex6_27b_InvalidTagShorthands) {
+ Load(ex6_27b);
+ FAIL() << "not implemented yet";
+}
+
+TEST(NodeSpecTest, Ex6_28_NonSpecificTags) {
+ Node doc = Load(ex6_28);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("12", doc[0].as<std::string>()); // TODO: check tags. How?
+ EXPECT_EQ(12, doc[1].as<int>());
+ EXPECT_EQ("12", doc[2].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex6_29_NodeAnchors) {
+ Node doc = Load(ex6_29);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ("Value", doc["First occurrence"].as<std::string>());
+ EXPECT_EQ("Value", doc["Second occurrence"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_1_AliasNodes) {
+ Node doc = Load(ex7_1);
+ EXPECT_EQ(4, doc.size());
+ EXPECT_EQ("Foo", doc["First occurrence"].as<std::string>());
+ EXPECT_EQ("Foo", doc["Second occurrence"].as<std::string>());
+ EXPECT_EQ("Bar", doc["Override anchor"].as<std::string>());
+ EXPECT_EQ("Bar", doc["Reuse anchor"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_2_EmptyNodes) {
+ Node doc = Load(ex7_2);
+ EXPECT_EQ(2, doc.size());
+ for (const_iterator it = doc.begin(); it != doc.end(); ++it) {
+ if (it->first.as<std::string>() == "foo") {
+ EXPECT_EQ("tag:yaml.org,2002:str", it->second.Tag());
+ EXPECT_EQ("", it->second.as<std::string>());
+ } else if (it->first.as<std::string>() == "") {
+ EXPECT_EQ("tag:yaml.org,2002:str", it->first.Tag());
+ EXPECT_EQ("bar", it->second.as<std::string>());
+ } else
+ FAIL() << "unexpected key";
+ }
+}
+
+TEST(NodeSpecTest, Ex7_3_CompletelyEmptyNodes) {
+ Node doc = Load(ex7_3);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_TRUE(doc["foo"].IsNull());
+ EXPECT_EQ("bar", doc[Null].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_4_DoubleQuotedImplicitKeys) {
+ Node doc = Load(ex7_4);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ(1, doc["implicit block key"].size());
+ EXPECT_EQ(1, doc["implicit block key"][0].size());
+ EXPECT_EQ(
+ "value",
+ doc["implicit block key"][0]["implicit flow key"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_5_DoubleQuotedLineBreaks) {
+ Node doc = Load(ex7_5);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ "folded to a space,\nto a line feed, or \t \tnon-content");
+}
+
+TEST(NodeSpecTest, Ex7_6_DoubleQuotedLines) {
+ Node doc = Load(ex7_6);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ " 1st non-empty\n2nd non-empty 3rd non-empty ");
+}
+
+TEST(NodeSpecTest, Ex7_7_SingleQuotedCharacters) {
+ Node doc = Load(ex7_7);
+ EXPECT_EQ("here's to \"quotes\"", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_8_SingleQuotedImplicitKeys) {
+ Node doc = Load(ex7_8);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ(1, doc["implicit block key"].size());
+ EXPECT_EQ(1, doc["implicit block key"][0].size());
+ EXPECT_EQ(
+ "value",
+ doc["implicit block key"][0]["implicit flow key"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_9_SingleQuotedLines) {
+ Node doc = Load(ex7_9);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ " 1st non-empty\n2nd non-empty 3rd non-empty ");
+}
+
+TEST(NodeSpecTest, Ex7_10_PlainCharacters) {
+ Node doc = Load(ex7_10);
+ EXPECT_EQ(6, doc.size());
+ EXPECT_EQ("::vector", doc[0].as<std::string>());
+ EXPECT_EQ(": - ()", doc[1].as<std::string>());
+ EXPECT_EQ("Up, up, and away!", doc[2].as<std::string>());
+ EXPECT_EQ(-123, doc[3].as<int>());
+ EXPECT_EQ("http://example.com/foo#bar", doc[4].as<std::string>());
+ EXPECT_EQ(5, doc[5].size());
+ EXPECT_EQ("::vector", doc[5][0].as<std::string>());
+ EXPECT_EQ(": - ()", doc[5][1].as<std::string>());
+ EXPECT_EQ("Up, up, and away!", doc[5][2].as<std::string>());
+ EXPECT_EQ(-123, doc[5][3].as<int>());
+ EXPECT_EQ("http://example.com/foo#bar", doc[5][4].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_11_PlainImplicitKeys) {
+ Node doc = Load(ex7_11);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ(1, doc["implicit block key"].size());
+ EXPECT_EQ(1, doc["implicit block key"][0].size());
+ EXPECT_EQ(
+ "value",
+ doc["implicit block key"][0]["implicit flow key"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_12_PlainLines) {
+ Node doc = Load(ex7_12);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ "1st non-empty\n2nd non-empty 3rd non-empty");
+}
+
+TEST(NodeSpecTest, Ex7_13_FlowSequence) {
+ Node doc = Load(ex7_13);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(2, doc[0].size());
+ EXPECT_EQ("one", doc[0][0].as<std::string>());
+ EXPECT_EQ("two", doc[0][1].as<std::string>());
+ EXPECT_EQ(2, doc[1].size());
+ EXPECT_EQ("three", doc[1][0].as<std::string>());
+ EXPECT_EQ("four", doc[1][1].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_14_FlowSequenceEntries) {
+ Node doc = Load(ex7_14);
+ EXPECT_EQ(5, doc.size());
+ EXPECT_EQ("double quoted", doc[0].as<std::string>());
+ EXPECT_EQ("single quoted", doc[1].as<std::string>());
+ EXPECT_EQ("plain text", doc[2].as<std::string>());
+ EXPECT_EQ(1, doc[3].size());
+ EXPECT_EQ("nested", doc[3][0].as<std::string>());
+ EXPECT_EQ(1, doc[4].size());
+ EXPECT_EQ("pair", doc[4]["single"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_15_FlowMappings) {
+ Node doc = Load(ex7_15);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(2, doc[0].size());
+ EXPECT_EQ("two", doc[0]["one"].as<std::string>());
+ EXPECT_EQ("four", doc[0]["three"].as<std::string>());
+ EXPECT_EQ(2, doc[1].size());
+ EXPECT_EQ("six", doc[1]["five"].as<std::string>());
+ EXPECT_EQ("eight", doc[1]["seven"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_16_FlowMappingEntries) {
+ Node doc = Load(ex7_16);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("entry", doc["explicit"].as<std::string>());
+ EXPECT_EQ("entry", doc["implicit"].as<std::string>());
+ EXPECT_TRUE(doc[Null].IsNull());
+}
+
+TEST(NodeSpecTest, Ex7_17_FlowMappingSeparateValues) {
+ Node doc = Load(ex7_17);
+ EXPECT_EQ(4, doc.size());
+ EXPECT_EQ("separate", doc["unquoted"].as<std::string>());
+ EXPECT_TRUE(doc["http://foo.com"].IsNull());
+ EXPECT_TRUE(doc["omitted value"].IsNull());
+ EXPECT_EQ("omitted key", doc[Null].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_18_FlowMappingAdjacentValues) {
+ Node doc = Load(ex7_18);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("value", doc["adjacent"].as<std::string>());
+ EXPECT_EQ("value", doc["readable"].as<std::string>());
+ EXPECT_TRUE(doc["empty"].IsNull());
+}
+
+TEST(NodeSpecTest, Ex7_19_SinglePairFlowMappings) {
+ Node doc = Load(ex7_19);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ(1, doc[0].size());
+ EXPECT_EQ("bar", doc[0]["foo"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_20_SinglePairExplicitEntry) {
+ Node doc = Load(ex7_20);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ(1, doc[0].size());
+ EXPECT_EQ("baz", doc[0]["foo bar"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_21_SinglePairImplicitEntries) {
+ Node doc = Load(ex7_21);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ(1, doc[0].size());
+ EXPECT_EQ(1, doc[0][0].size());
+ EXPECT_EQ("separate", doc[0][0]["YAML"].as<std::string>());
+ EXPECT_EQ(1, doc[1].size());
+ EXPECT_EQ(1, doc[1][0].size());
+ EXPECT_EQ("empty key entry", doc[1][0][Null].as<std::string>());
+ EXPECT_EQ(1, doc[2].size());
+ EXPECT_EQ(1, doc[2][0].size());
+
+ std::map<std::string, std::string> key;
+ key["JSON"] = "like";
+ EXPECT_EQ("adjacent", doc[2][0][key].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_22_InvalidImplicitKeys) {
+ EXPECT_THROW_PARSER_EXCEPTION(Load(ex7_22), ErrorMsg::END_OF_SEQ_FLOW);
+}
+
+TEST(NodeSpecTest, Ex7_23_FlowContent) {
+ Node doc = Load(ex7_23);
+ EXPECT_EQ(5, doc.size());
+ EXPECT_EQ(2, doc[0].size());
+ EXPECT_EQ("a", doc[0][0].as<std::string>());
+ EXPECT_EQ("b", doc[0][1].as<std::string>());
+ EXPECT_EQ(1, doc[1].size());
+ EXPECT_EQ("b", doc[1]["a"].as<std::string>());
+ EXPECT_EQ("a", doc[2].as<std::string>());
+ EXPECT_EQ('b', doc[3].as<char>());
+ EXPECT_EQ("c", doc[4].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex7_24_FlowNodes) {
+ Node doc = Load(ex7_24);
+ EXPECT_EQ(5, doc.size());
+ EXPECT_EQ("tag:yaml.org,2002:str", doc[0].Tag());
+ EXPECT_EQ("a", doc[0].as<std::string>());
+ EXPECT_EQ('b', doc[1].as<char>());
+ EXPECT_EQ("c", doc[2].as<std::string>());
+ EXPECT_EQ("c", doc[3].as<std::string>());
+ EXPECT_EQ("tag:yaml.org,2002:str", doc[4].Tag());
+ EXPECT_EQ("", doc[4].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_1_BlockScalarHeader) {
+ Node doc = Load(ex8_1);
+ EXPECT_EQ(4, doc.size());
+ EXPECT_EQ("literal\n", doc[0].as<std::string>());
+ EXPECT_EQ(" folded\n", doc[1].as<std::string>());
+ EXPECT_EQ("keep\n\n", doc[2].as<std::string>());
+ EXPECT_EQ(" strip", doc[3].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_2_BlockIndentationHeader) {
+ Node doc = Load(ex8_2);
+ EXPECT_EQ(4, doc.size());
+ EXPECT_EQ("detected\n", doc[0].as<std::string>());
+ EXPECT_EQ("\n\n# detected\n", doc[1].as<std::string>());
+ EXPECT_EQ(" explicit\n", doc[2].as<std::string>());
+ EXPECT_EQ("\t\ndetected\n", doc[3].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_3a_InvalidBlockScalarIndentationIndicators) {
+ EXPECT_THROW_PARSER_EXCEPTION(Load(ex8_3a), ErrorMsg::END_OF_SEQ);
+}
+
+TEST(NodeSpecTest, Ex8_3b_InvalidBlockScalarIndentationIndicators) {
+ EXPECT_THROW_PARSER_EXCEPTION(Load(ex8_3b), ErrorMsg::END_OF_SEQ);
+}
+
+TEST(NodeSpecTest, Ex8_3c_InvalidBlockScalarIndentationIndicators) {
+ EXPECT_THROW_PARSER_EXCEPTION(Load(ex8_3c), ErrorMsg::END_OF_SEQ);
+}
+
+TEST(NodeSpecTest, Ex8_4_ChompingFinalLineBreak) {
+ Node doc = Load(ex8_4);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("text", doc["strip"].as<std::string>());
+ EXPECT_EQ("text\n", doc["clip"].as<std::string>());
+ EXPECT_EQ("text\n", doc["keep"].as<std::string>());
+}
+
+TEST(NodeSpecTest, DISABLED_Ex8_5_ChompingTrailingLines) {
+ Node doc = Load(ex8_5);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("# text", doc["strip"].as<std::string>());
+ EXPECT_EQ("# text\n", doc["clip"].as<std::string>());
+ // NOTE: I believe this is a bug in the YAML spec -
+ // it should be "# text\n\n"
+ EXPECT_EQ("# text\n", doc["keep"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_6_EmptyScalarChomping) {
+ Node doc = Load(ex8_6);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("", doc["strip"].as<std::string>());
+ EXPECT_EQ("", doc["clip"].as<std::string>());
+ EXPECT_EQ("\n", doc["keep"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_7_LiteralScalar) {
+ Node doc = Load(ex8_7);
+ EXPECT_EQ("literal\n\ttext\n", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_8_LiteralContent) {
+ Node doc = Load(ex8_8);
+ EXPECT_EQ("\n\nliteral\n \n\ntext\n", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_9_FoldedScalar) {
+ Node doc = Load(ex8_9);
+ EXPECT_EQ("folded text\n", doc.as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_10_FoldedLines) {
+ Node doc = Load(ex8_10);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ "\nfolded line\nnext line\n * bullet\n\n * list\n * "
+ "lines\n\nlast line\n");
+}
+
+TEST(NodeSpecTest, Ex8_11_MoreIndentedLines) {
+ Node doc = Load(ex8_11);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ "\nfolded line\nnext line\n * bullet\n\n * list\n * "
+ "lines\n\nlast line\n");
+}
+
+TEST(NodeSpecTest, Ex8_12_EmptySeparationLines) {
+ Node doc = Load(ex8_12);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ "\nfolded line\nnext line\n * bullet\n\n * list\n * "
+ "lines\n\nlast line\n");
+}
+
+TEST(NodeSpecTest, Ex8_13_FinalEmptyLines) {
+ Node doc = Load(ex8_13);
+ EXPECT_TRUE(doc.as<std::string>() ==
+ "\nfolded line\nnext line\n * bullet\n\n * list\n * "
+ "lines\n\nlast line\n");
+}
+
+TEST(NodeSpecTest, Ex8_14_BlockSequence) {
+ Node doc = Load(ex8_14);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ(2, doc["block sequence"].size());
+ EXPECT_EQ("one", doc["block sequence"][0].as<std::string>());
+ EXPECT_EQ(1, doc["block sequence"][1].size());
+ EXPECT_EQ("three", doc["block sequence"][1]["two"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_15_BlockSequenceEntryTypes) {
+ Node doc = Load(ex8_15);
+ EXPECT_EQ(4, doc.size());
+ EXPECT_TRUE(doc[0].IsNull());
+ EXPECT_EQ("block node\n", doc[1].as<std::string>());
+ EXPECT_EQ(2, doc[2].size());
+ EXPECT_EQ("one", doc[2][0].as<std::string>());
+ EXPECT_EQ("two", doc[2][1].as<std::string>());
+ EXPECT_EQ(1, doc[3].size());
+ EXPECT_EQ("two", doc[3]["one"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_16_BlockMappings) {
+ Node doc = Load(ex8_16);
+ EXPECT_EQ(1, doc.size());
+ EXPECT_EQ(1, doc["block mapping"].size());
+ EXPECT_EQ("value", doc["block mapping"]["key"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_17_ExplicitBlockMappingEntries) {
+ Node doc = Load(ex8_17);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_TRUE(doc["explicit key"].IsNull());
+ EXPECT_EQ(2, doc["block key\n"].size());
+ EXPECT_EQ("one", doc["block key\n"][0].as<std::string>());
+ EXPECT_EQ("two", doc["block key\n"][1].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_18_ImplicitBlockMappingEntries) {
+ Node doc = Load(ex8_18);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("in-line value", doc["plain key"].as<std::string>());
+ EXPECT_TRUE(doc[Null].IsNull());
+ EXPECT_EQ(1, doc["quoted key"].size());
+ EXPECT_EQ("entry", doc["quoted key"][0].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_19_CompactBlockMappings) {
+ Node doc = Load(ex8_19);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(1, doc[0].size());
+ EXPECT_EQ("yellow", doc[0]["sun"].as<std::string>());
+ EXPECT_EQ(1, doc[1].size());
+ std::map<std::string, std::string> key;
+ key["earth"] = "blue";
+ EXPECT_EQ(1, doc[1][key].size());
+ EXPECT_EQ("white", doc[1][key]["moon"].as<std::string>());
+}
+
+TEST(NodeSpecTest, Ex8_20_BlockNodeTypes) {
+ Node doc = Load(ex8_20);
+ EXPECT_EQ(3, doc.size());
+ EXPECT_EQ("flow in block", doc[0].as<std::string>());
+ EXPECT_EQ("Block scalar\n", doc[1].as<std::string>());
+ EXPECT_EQ(1, doc[2].size());
+ EXPECT_EQ("bar", doc[2]["foo"].as<std::string>());
+}
+
+TEST(NodeSpecTest, DISABLED_Ex8_21_BlockScalarNodes) {
+ Node doc = Load(ex8_21);
+ EXPECT_EQ(2, doc.size());
+ // NOTE: I believe this is a bug in the YAML spec -
+ // it should be "value\n"
+ EXPECT_EQ("value", doc["literal"].as<std::string>());
+ EXPECT_EQ("value", doc["folded"].as<std::string>());
+ EXPECT_EQ("!foo", doc["folded"].Tag());
+}
+
+TEST(NodeSpecTest, Ex8_22_BlockCollectionNodes) {
+ Node doc = Load(ex8_22);
+ EXPECT_EQ(2, doc.size());
+ EXPECT_EQ(2, doc["sequence"].size());
+ EXPECT_EQ("entry", doc["sequence"][0].as<std::string>());
+ EXPECT_EQ(1, doc["sequence"][1].size());
+ EXPECT_EQ("nested", doc["sequence"][1][0].as<std::string>());
+ EXPECT_EQ(1, doc["mapping"].size());
+ EXPECT_EQ("bar", doc["mapping"]["foo"].as<std::string>());
+}
+
+TEST(NodeSpecTest, FlowMapNotClosed) {
+ EXPECT_THROW_PARSER_EXCEPTION(Load("{x:"), ErrorMsg::UNKNOWN_TOKEN);
+}
+
+}
+}
--- /dev/null
+#include "gtest/gtest.h"
+
+int main(int argc, char** argv) {
+ ::testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+}
--- /dev/null
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/mark.h"
+
+#include "gmock/gmock.h"
+
+#include <string>
+
+namespace YAML {
+
+class MockEventHandler : public EventHandler {
+ public:
+ MOCK_METHOD1(OnDocumentStart, void(const Mark&));
+ MOCK_METHOD0(OnDocumentEnd, void());
+
+ MOCK_METHOD2(OnNull, void(const Mark&, anchor_t));
+ MOCK_METHOD2(OnAlias, void(const Mark&, anchor_t));
+ MOCK_METHOD4(OnScalar, void(const Mark&, const std::string&, anchor_t,
+ const std::string&));
+
+ MOCK_METHOD4(OnSequenceStart, void(const Mark&, const std::string&, anchor_t,
+ EmitterStyle::value));
+ MOCK_METHOD0(OnSequenceEnd, void());
+
+ MOCK_METHOD4(OnMapStart, void(const Mark&, const std::string&, anchor_t,
+ EmitterStyle::value));
+ MOCK_METHOD0(OnMapEnd, void());
+ MOCK_METHOD2(OnAnchor, void(const Mark&, const std::string&));
+};
+} // namespace YAML
--- /dev/null
+#include "yaml-cpp/node/node.h"
+#include "yaml-cpp/emitter.h"
+#include "yaml-cpp/node/convert.h"
+#include "yaml-cpp/node/detail/impl.h"
+#include "yaml-cpp/node/emit.h"
+#include "yaml-cpp/node/impl.h"
+#include "yaml-cpp/node/iterator.h"
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include <sstream>
+
+namespace {
+
+// malloc/free based allocator just for testing custom allocators on stl containers
+template <class T>
+class CustomAllocator : public std::allocator<T> {
+ public:
+ typedef std::size_t size_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef T* pointer;
+ typedef const T* const_pointer;
+ typedef T& reference;
+ typedef const T& const_reference;
+ typedef T value_type;
+ template<class U> struct rebind { typedef CustomAllocator<U> other; };
+ CustomAllocator() : std::allocator<T>() {}
+ CustomAllocator(const CustomAllocator& other) : std::allocator<T>(other) {}
+ template<class U> CustomAllocator(const CustomAllocator<U>& other) : std::allocator<T>(other) {}
+ ~CustomAllocator() {}
+ size_type max_size() const { return (std::numeric_limits<std::ptrdiff_t>::max)()/sizeof(T); }
+ pointer allocate(size_type num, const void* /*hint*/ = 0) {
+ if (num > std::size_t(-1) / sizeof(T)) throw std::bad_alloc();
+ return static_cast<pointer>(malloc(num * sizeof(T)));
+ }
+ void deallocate(pointer p, size_type /*num*/) { free(p); }
+};
+
+template <class T> using CustomVector = std::vector<T,CustomAllocator<T>>;
+template <class T> using CustomList = std::list<T,CustomAllocator<T>>;
+template <class K, class V, class C=std::less<K>> using CustomMap = std::map<K,V,C,CustomAllocator<std::pair<const K,V>>>;
+template <class K, class V, class H=std::hash<K>, class P=std::equal_to<K>> using CustomUnorderedMap = std::unordered_map<K,V,H,P,CustomAllocator<std::pair<const K,V>>>;
+
+} // anonymous namespace
+
+using ::testing::AnyOf;
+using ::testing::Eq;
+
+#define EXPECT_THROW_REPRESENTATION_EXCEPTION(statement, message) \
+ ASSERT_THROW(statement, RepresentationException); \
+ try { \
+ statement; \
+ } catch (const RepresentationException& e) { \
+ EXPECT_EQ(e.msg, message); \
+ }
+
+namespace YAML {
+namespace {
+TEST(NodeTest, SimpleScalar) {
+ Node node = Node("Hello, World!");
+ EXPECT_TRUE(node.IsScalar());
+ EXPECT_EQ("Hello, World!", node.as<std::string>());
+}
+
+TEST(NodeTest, IntScalar) {
+ Node node = Node(15);
+ EXPECT_TRUE(node.IsScalar());
+ EXPECT_EQ(15, node.as<int>());
+}
+
+TEST(NodeTest, SimpleAppendSequence) {
+ Node node;
+ node.push_back(10);
+ node.push_back("foo");
+ node.push_back("monkey");
+ EXPECT_TRUE(node.IsSequence());
+ EXPECT_EQ(3, node.size());
+ EXPECT_EQ(10, node[0].as<int>());
+ EXPECT_EQ("foo", node[1].as<std::string>());
+ EXPECT_EQ("monkey", node[2].as<std::string>());
+ EXPECT_TRUE(node.IsSequence());
+}
+
+TEST(NodeTest, SequenceElementRemoval) {
+ Node node;
+ node[0] = "a";
+ node[1] = "b";
+ node[2] = "c";
+ node.remove(1);
+ EXPECT_TRUE(node.IsSequence());
+ EXPECT_EQ(2, node.size());
+ EXPECT_EQ("a", node[0].as<std::string>());
+ EXPECT_EQ("c", node[1].as<std::string>());
+}
+
+TEST(NodeTest, SequenceElementRemovalSizeCheck) {
+ Node node;
+ node[0] = "a";
+ node[1] = "b";
+ node[2] = "c";
+ EXPECT_EQ(3, node.size());
+ node.remove(1);
+ EXPECT_TRUE(node.IsSequence());
+ EXPECT_EQ(2, node.size());
+ EXPECT_EQ("a", node[0].as<std::string>());
+ EXPECT_EQ("c", node[1].as<std::string>());
+}
+
+TEST(NodeTest, SequenceFirstElementRemoval) {
+ Node node;
+ node[0] = "a";
+ node[1] = "b";
+ node[2] = "c";
+ node.remove(0);
+ EXPECT_TRUE(node.IsSequence());
+ EXPECT_EQ(2, node.size());
+ EXPECT_EQ("b", node[0].as<std::string>());
+ EXPECT_EQ("c", node[1].as<std::string>());
+}
+
+TEST(NodeTest, SequenceFirstElementRemovalSizeCheck) {
+ Node node;
+ node[0] = "a";
+ node[1] = "b";
+ node[2] = "c";
+ EXPECT_EQ(3, node.size());
+ node.remove(0);
+ EXPECT_TRUE(node.IsSequence());
+ EXPECT_EQ(2, node.size());
+ EXPECT_EQ("b", node[0].as<std::string>());
+ EXPECT_EQ("c", node[1].as<std::string>());
+}
+
+TEST(NodeTest, SequenceLastElementRemoval) {
+ Node node;
+ node[0] = "a";
+ node[1] = "b";
+ node[2] = "c";
+ node.remove(2);
+ EXPECT_TRUE(node.IsSequence());
+ EXPECT_EQ(2, node.size());
+ EXPECT_EQ("a", node[0].as<std::string>());
+ EXPECT_EQ("b", node[1].as<std::string>());
+}
+
+TEST(NodeTest, SequenceLastElementRemovalSizeCheck) {
+ Node node;
+ node[0] = "a";
+ node[1] = "b";
+ node[2] = "c";
+ EXPECT_EQ(3, node.size());
+ node.remove(2);
+ EXPECT_TRUE(node.IsSequence());
+ EXPECT_EQ(2, node.size());
+ EXPECT_EQ("a", node[0].as<std::string>());
+ EXPECT_EQ("b", node[1].as<std::string>());
+}
+
+TEST(NodeTest, NodeAssignment) {
+ Node node1;
+ Node node2;
+ node1[1] = 1;
+ node1[2] = 2;
+ node1[3] = 3;
+ node2 = node1;
+ EXPECT_EQ(node1, node2);
+ EXPECT_EQ(node1[1], node2[1]);
+ EXPECT_EQ(node1[2], node2[2]);
+ EXPECT_EQ(node1[3], node2[3]);
+}
+
+TEST(NodeTest, EqualRepresentationAfterMoveAssignment) {
+ Node node1;
+ Node node2;
+ std::ostringstream ss1, ss2;
+ node1["foo"] = "bar";
+ ss1 << node1;
+ node2["hello"] = "world";
+ node2 = std::move(node1);
+ ss2 << node2;
+ EXPECT_FALSE(node2["hello"]);
+ EXPECT_EQ("bar", node2["foo"].as<std::string>());
+ EXPECT_EQ(ss1.str(), ss2.str());
+}
+
+TEST(NodeTest, MapElementRemoval) {
+ Node node;
+ node["foo"] = "bar";
+ node.remove("foo");
+ EXPECT_TRUE(!node["foo"]);
+}
+
+TEST(NodeTest, MapIntegerElementRemoval) {
+ Node node;
+ node[1] = "hello";
+ node[2] = 'c';
+ node["foo"] = "bar";
+ EXPECT_TRUE(node.IsMap());
+ node.remove(1);
+ EXPECT_TRUE(node.IsMap());
+}
+
+TEST(NodeTest, SimpleAssignSequence) {
+ Node node;
+ node[0] = 10;
+ node[1] = "foo";
+ node[2] = "monkey";
+ EXPECT_TRUE(node.IsSequence());
+ EXPECT_EQ(3, node.size());
+ EXPECT_EQ(10, node[0].as<int>());
+ EXPECT_EQ("foo", node[1].as<std::string>());
+ EXPECT_EQ("monkey", node[2].as<std::string>());
+ EXPECT_TRUE(node.IsSequence());
+}
+
+TEST(NodeTest, SimpleMap) {
+ Node node;
+ node["key"] = "value";
+ EXPECT_TRUE(node.IsMap());
+ EXPECT_EQ("value", node["key"].as<std::string>());
+ EXPECT_EQ(1, node.size());
+}
+
+TEST(NodeTest, MapWithUndefinedValues) {
+ Node node;
+ node["key"] = "value";
+ node["undefined"];
+ EXPECT_TRUE(node.IsMap());
+ EXPECT_EQ("value", node["key"].as<std::string>());
+ EXPECT_EQ(1, node.size());
+
+ node["undefined"] = "monkey";
+ EXPECT_EQ("monkey", node["undefined"].as<std::string>());
+ EXPECT_EQ(2, node.size());
+}
+
+TEST(NodeTest, SeqIntoMap) {
+ Node node;
+ node[0] = "test";
+ node[1];
+ node[2] = "value";
+ EXPECT_TRUE(node.IsMap());
+ EXPECT_EQ("test", node[0].as<std::string>());
+ EXPECT_EQ("value", node[2].as<std::string>());
+ EXPECT_EQ(2, node.size());
+}
+
+TEST(NodeTest, RemoveUnassignedNode) {
+ Node node(NodeType::Map);
+ node["key"];
+ node.remove("key");
+ EXPECT_EQ(0, node.size());
+}
+
+TEST(NodeTest, RemoveUnassignedNodeFromMap) {
+ Node node(NodeType::Map);
+ Node n;
+ node[n];
+ node.remove(n);
+ EXPECT_EQ(0, node.size());
+}
+
+TEST(NodeTest, MapForceInsert) {
+ Node node;
+ Node k1("k1");
+ Node k2("k2");
+ Node v1("v1");
+ Node v2("v2");
+ node[k1] = v1;
+ node[k2] = v1;
+ EXPECT_TRUE(node.IsMap());
+ EXPECT_EQ("v1", node["k1"].as<std::string>());
+ EXPECT_EQ("v1", node["k2"].as<std::string>());
+ EXPECT_EQ(2, node.size());
+
+ node.force_insert(k2, v2);
+ EXPECT_EQ("v1", node["k1"].as<std::string>());
+ EXPECT_EQ("v1", node["k2"].as<std::string>());
+ EXPECT_EQ(3, node.size());
+}
+
+TEST(NodeTest, UndefinedConstNodeWithFallback) {
+ Node node;
+ const Node& cn = node;
+ EXPECT_EQ(cn["undefined"].as<int>(3), 3);
+}
+
+TEST(NodeTest, MapIteratorWithUndefinedValues) {
+ Node node;
+ node["key"] = "value";
+ node["undefined"];
+
+ std::size_t count = 0;
+ for (const_iterator it = node.begin(); it != node.end(); ++it)
+ count++;
+ EXPECT_EQ(1, count);
+}
+
+TEST(NodeTest, ConstIteratorOnConstUndefinedNode) {
+ Node node;
+ const Node& cn = node;
+ const Node& undefinedCn = cn["undefined"];
+
+ std::size_t count = 0;
+ for (const_iterator it = undefinedCn.begin(); it != undefinedCn.end(); ++it) {
+ count++;
+ }
+ EXPECT_EQ(0, count);
+}
+
+TEST(NodeTest, IteratorOnConstUndefinedNode) {
+ Node node;
+ const Node& cn = node;
+ const Node& undefinedCn = cn["undefined"];
+
+ Node& nonConstUndefinedNode = const_cast<Node&>(undefinedCn);
+
+ std::size_t count = 0;
+ for (iterator it = nonConstUndefinedNode.begin();
+ it != nonConstUndefinedNode.end(); ++it) {
+ count++;
+ }
+ EXPECT_EQ(0, count);
+}
+
+TEST(NodeTest, InteratorOnSequence) {
+ Node node;
+ node[0] = "a";
+ node[1] = "b";
+ node[2] = "c";
+ EXPECT_TRUE(node.IsSequence());
+
+ std::size_t count = 0;
+ for (iterator it = node.begin(); it != node.end(); ++it)
+ {
+ EXPECT_FALSE(it->IsNull());
+ count++;
+ }
+ EXPECT_EQ(3, count);
+}
+
+TEST(NodeTest, ConstInteratorOnSequence) {
+ Node node;
+ node[0] = "a";
+ node[1] = "b";
+ node[2] = "c";
+ EXPECT_TRUE(node.IsSequence());
+
+ std::size_t count = 0;
+ for (const_iterator it = node.begin(); it != node.end(); ++it)
+ {
+ EXPECT_FALSE(it->IsNull());
+ count++;
+ }
+ EXPECT_EQ(3, count);
+}
+
+#if __cplusplus >= 201703L
+TEST(NodeTest, StdStringViewAsKey) {
+ Node node;
+ std::string_view key = "username";
+ node[key] = "monkey";
+ EXPECT_EQ("monkey", node[key].as<std::string>());
+}
+#endif
+
+TEST(NodeTest, SimpleSubkeys) {
+ Node node;
+ node["device"]["udid"] = "12345";
+ node["device"]["name"] = "iPhone";
+ node["device"]["os"] = "4.0";
+ node["username"] = "monkey";
+ EXPECT_EQ("12345", node["device"]["udid"].as<std::string>());
+ EXPECT_EQ("iPhone", node["device"]["name"].as<std::string>());
+ EXPECT_EQ("4.0", node["device"]["os"].as<std::string>());
+ EXPECT_EQ("monkey", node["username"].as<std::string>());
+}
+
+TEST(NodeTest, StdArray) {
+ std::array<int, 5> evens{{2, 4, 6, 8, 10}};
+ Node node;
+ node["evens"] = evens;
+ std::array<int, 5> actualEvens = node["evens"].as<std::array<int, 5>>();
+ EXPECT_EQ(evens, actualEvens);
+}
+
+TEST(NodeTest, StdArrayWrongSize) {
+ std::array<int, 3> evens{{2, 4, 6}};
+ Node node;
+ node["evens"] = evens;
+ EXPECT_THROW_REPRESENTATION_EXCEPTION(
+ (node["evens"].as<std::array<int, 5>>()), ErrorMsg::BAD_CONVERSION);
+}
+
+TEST(NodeTest, StdValrray) {
+ std::valarray<int> evens{{2, 4, 6, 8, 10}};
+ Node node;
+ node["evens"] = evens;
+ std::valarray<int> actualEvens = node["evens"].as<std::valarray<int>>();
+ for (int i = 0; i < evens.size(); ++i) {
+ EXPECT_EQ(evens[i], actualEvens[i]);
+ }
+}
+
+TEST(NodeTest, StdVector) {
+ std::vector<int> primes;
+ primes.push_back(2);
+ primes.push_back(3);
+ primes.push_back(5);
+ primes.push_back(7);
+ primes.push_back(11);
+ primes.push_back(13);
+
+ Node node;
+ node["primes"] = primes;
+ EXPECT_EQ(primes, node["primes"].as<std::vector<int>>());
+}
+
+TEST(NodeTest, StdVectorWithCustomAllocator) {
+ CustomVector<int> primes;
+ primes.push_back(2);
+ primes.push_back(3);
+ primes.push_back(5);
+ primes.push_back(7);
+ primes.push_back(11);
+ primes.push_back(13);
+
+ Node node;
+ node["primes"] = primes;
+ EXPECT_EQ(primes, node["primes"].as<CustomVector<int>>());
+}
+
+TEST(NodeTest, StdList) {
+ std::list<int> primes;
+ primes.push_back(2);
+ primes.push_back(3);
+ primes.push_back(5);
+ primes.push_back(7);
+ primes.push_back(11);
+ primes.push_back(13);
+
+ Node node;
+ node["primes"] = primes;
+ EXPECT_EQ(primes, node["primes"].as<std::list<int>>());
+}
+
+TEST(NodeTest, StdListWithCustomAllocator) {
+ CustomList<int> primes;
+ primes.push_back(2);
+ primes.push_back(3);
+ primes.push_back(5);
+ primes.push_back(7);
+ primes.push_back(11);
+ primes.push_back(13);
+
+ Node node;
+ node["primes"] = primes;
+ EXPECT_EQ(primes, node["primes"].as<CustomList<int>>());
+}
+
+TEST(NodeTest, StdMap) {
+ std::map<int, int> squares;
+ squares[0] = 0;
+ squares[1] = 1;
+ squares[2] = 4;
+ squares[3] = 9;
+ squares[4] = 16;
+
+ Node node;
+ node["squares"] = squares;
+ std::map<int, int> actualSquares = node["squares"].as<std::map<int, int>>();
+ EXPECT_EQ(squares, actualSquares);
+}
+
+TEST(NodeTest, StdMapWithCustomAllocator) {
+ CustomMap<int,int> squares;
+ squares[0] = 0;
+ squares[1] = 1;
+ squares[2] = 4;
+ squares[3] = 9;
+ squares[4] = 16;
+
+ Node node;
+ node["squares"] = squares;
+ CustomMap<int,int> actualSquares = node["squares"].as<CustomMap<int,int>>();
+ EXPECT_EQ(squares, actualSquares);
+}
+
+TEST(NodeTest, StdUnorderedMap) {
+ std::unordered_map<int, int> squares;
+ squares[0] = 0;
+ squares[1] = 1;
+ squares[2] = 4;
+ squares[3] = 9;
+ squares[4] = 16;
+
+ Node node;
+ node["squares"] = squares;
+ std::unordered_map<int, int> actualSquares = node["squares"].as<std::unordered_map<int, int>>();
+ EXPECT_EQ(squares, actualSquares);
+}
+
+TEST(NodeTest, StdUnorderedMapWithCustomAllocator) {
+ CustomUnorderedMap<int,int> squares;
+ squares[0] = 0;
+ squares[1] = 1;
+ squares[2] = 4;
+ squares[3] = 9;
+ squares[4] = 16;
+
+ Node node;
+ node["squares"] = squares;
+ CustomUnorderedMap<int,int> actualSquares = node["squares"].as<CustomUnorderedMap<int,int>>();
+ EXPECT_EQ(squares, actualSquares);
+}
+
+TEST(NodeTest, StdPair) {
+ std::pair<int, std::string> p;
+ p.first = 5;
+ p.second = "five";
+
+ Node node;
+ node["pair"] = p;
+ std::pair<int, std::string> actualP =
+ node["pair"].as<std::pair<int, std::string>>();
+ EXPECT_EQ(p, actualP);
+}
+
+TEST(NodeTest, SimpleAlias) {
+ Node node;
+ node["foo"] = "value";
+ node["bar"] = node["foo"];
+ EXPECT_EQ("value", node["foo"].as<std::string>());
+ EXPECT_EQ("value", node["bar"].as<std::string>());
+ EXPECT_EQ(node["bar"], node["foo"]);
+ EXPECT_EQ(2, node.size());
+}
+
+TEST(NodeTest, AliasAsKey) {
+ Node node;
+ node["foo"] = "value";
+ Node value = node["foo"];
+ node[value] = "foo";
+ EXPECT_EQ("value", node["foo"].as<std::string>());
+ EXPECT_EQ("foo", node[value].as<std::string>());
+ EXPECT_EQ("foo", node["value"].as<std::string>());
+ EXPECT_EQ(2, node.size());
+}
+
+TEST(NodeTest, SelfReferenceSequence) {
+ Node node;
+ node[0] = node;
+ EXPECT_TRUE(node.IsSequence());
+ EXPECT_EQ(1, node.size());
+ EXPECT_EQ(node, node[0]);
+ EXPECT_EQ(node, node[0][0]);
+ EXPECT_EQ(node[0], node[0][0]);
+}
+
+TEST(NodeTest, ValueSelfReferenceMap) {
+ Node node;
+ node["key"] = node;
+ EXPECT_TRUE(node.IsMap());
+ EXPECT_EQ(1, node.size());
+ EXPECT_EQ(node, node["key"]);
+ EXPECT_EQ(node, node["key"]["key"]);
+ EXPECT_EQ(node["key"], node["key"]["key"]);
+}
+
+TEST(NodeTest, KeySelfReferenceMap) {
+ Node node;
+ node[node] = "value";
+ EXPECT_TRUE(node.IsMap());
+ EXPECT_EQ(1, node.size());
+ EXPECT_EQ("value", node[node].as<std::string>());
+}
+
+TEST(NodeTest, SelfReferenceMap) {
+ Node node;
+ node[node] = node;
+ EXPECT_TRUE(node.IsMap());
+ EXPECT_EQ(1, node.size());
+ EXPECT_EQ(node, node[node]);
+ EXPECT_EQ(node, node[node][node]);
+ EXPECT_EQ(node[node], node[node][node]);
+}
+
+TEST(NodeTest, TempMapVariable) {
+ Node node;
+ Node tmp = node["key"];
+ tmp = "value";
+ EXPECT_TRUE(node.IsMap());
+ EXPECT_EQ(1, node.size());
+ EXPECT_EQ("value", node["key"].as<std::string>());
+}
+
+TEST(NodeTest, TempMapVariableAlias) {
+ Node node;
+ Node tmp = node["key"];
+ tmp = node["other"];
+ node["other"] = "value";
+ EXPECT_TRUE(node.IsMap());
+ EXPECT_EQ(2, node.size());
+ EXPECT_EQ("value", node["key"].as<std::string>());
+ EXPECT_EQ("value", node["other"].as<std::string>());
+ EXPECT_EQ(node["key"], node["other"]);
+}
+
+TEST(NodeTest, Bool) {
+ Node node;
+ node[true] = false;
+ EXPECT_TRUE(node.IsMap());
+ EXPECT_EQ(false, node[true].as<bool>());
+}
+
+TEST(NodeTest, AutoBoolConversion) {
+#ifdef _MSC_VER
+#pragma warning(disable : 4800)
+#endif
+ Node node;
+ node["foo"] = "bar";
+ EXPECT_TRUE(static_cast<bool>(node["foo"]));
+ EXPECT_TRUE(!node["monkey"]);
+ EXPECT_TRUE(!!node["foo"]);
+}
+
+TEST(NodeTest, FloatingPrecisionFloat) {
+ const float x = 0.123456789;
+ Node node = Node(x);
+ EXPECT_EQ(x, node.as<float>());
+}
+
+TEST(NodeTest, FloatingPrecisionPositiveInfinityFloat) {
+ if (!std::numeric_limits<float>::has_infinity) {
+ return;
+ }
+ const float x = std::numeric_limits<float>::infinity();
+ Node node = Node(x);
+ EXPECT_EQ(x, node.as<float>());
+}
+
+TEST(NodeTest, FloatingPrecisionNegativeInfinityFloat) {
+ if (!std::numeric_limits<float>::has_infinity) {
+ return;
+ }
+ const float x = -std::numeric_limits<float>::infinity();
+ Node node = Node(x);
+ EXPECT_EQ(x, node.as<float>());
+}
+
+TEST(NodeTest, FloatingPrecisionNanFloat) {
+ if (!std::numeric_limits<float>::has_quiet_NaN) {
+ return;
+ }
+ const float x = std::numeric_limits<float>::quiet_NaN();
+ Node node = Node(x);
+ EXPECT_TRUE(std::isnan(node.as<float>()));
+}
+
+TEST(NodeTest, FloatingPrecisionDouble) {
+ const double x = 0.123456789;
+ Node node = Node(x);
+ EXPECT_EQ(x, node.as<double>());
+}
+
+TEST(NodeTest, FloatingPrecisionPositiveInfinityDouble) {
+ if (!std::numeric_limits<double>::has_infinity) {
+ return;
+ }
+ const double x = std::numeric_limits<double>::infinity();
+ Node node = Node(x);
+ EXPECT_EQ(x, node.as<float>());
+}
+
+TEST(NodeTest, FloatingPrecisionNegativeInfinityDouble) {
+ if (!std::numeric_limits<double>::has_infinity) {
+ return;
+ }
+ const double x = -std::numeric_limits<double>::infinity();
+ Node node = Node(x);
+ EXPECT_EQ(x, node.as<double>());
+}
+
+TEST(NodeTest, FloatingPrecisionNanDouble) {
+ if (!std::numeric_limits<double>::has_quiet_NaN) {
+ return;
+ }
+ const double x = std::numeric_limits<double>::quiet_NaN();
+ Node node = Node(x);
+ EXPECT_TRUE(std::isnan(node.as<double>()));
+}
+
+TEST(NodeTest, SpaceChar) {
+ Node node = Node(' ');
+ EXPECT_EQ(' ', node.as<char>());
+}
+
+TEST(NodeTest, CloneNull) {
+ Node node;
+ Node clone = Clone(node);
+ EXPECT_EQ(NodeType::Null, clone.Type());
+}
+
+TEST(NodeTest, KeyNodeExitsScope) {
+ Node node;
+ {
+ Node temp("Hello, world");
+ node[temp] = 0;
+ }
+ for (Node::const_iterator it = node.begin(); it != node.end(); ++it) {
+ (void)it;
+ }
+}
+
+TEST(NodeTest, DefaultNodeStyle) {
+ Node node;
+ EXPECT_EQ(EmitterStyle::Default, node.Style());
+}
+
+TEST(NodeTest, AccessNonexistentKeyOnConstNode) {
+ YAML::Node node;
+ node["3"] = "4";
+ const YAML::Node& other = node;
+ ASSERT_FALSE(other["5"]);
+}
+
+class NodeEmitterTest : public ::testing::Test {
+ protected:
+ void ExpectOutput(const std::string& output, const Node& node) {
+ Emitter emitter;
+ emitter << node;
+ ASSERT_TRUE(emitter.good());
+ EXPECT_EQ(output, emitter.c_str());
+ }
+
+ void ExpectAnyOutput(const Node& node, const std::string& output1,
+ const std::string& output2) {
+ Emitter emitter;
+ emitter << node;
+ ASSERT_TRUE(emitter.good());
+ EXPECT_THAT(emitter.c_str(), AnyOf(Eq(output1), Eq(output2)));
+ }
+};
+
+TEST_F(NodeEmitterTest, SimpleFlowSeqNode) {
+ Node node;
+ node.SetStyle(EmitterStyle::Flow);
+ node.push_back(1.5);
+ node.push_back(2.25);
+ node.push_back(3.125);
+
+ ExpectOutput("[1.5, 2.25, 3.125]", node);
+}
+
+TEST_F(NodeEmitterTest, NestFlowSeqNode) {
+ Node node, cell0, cell1;
+
+ cell0.push_back(1.5);
+ cell0.push_back(2.25);
+ cell0.push_back(3.125);
+
+ cell1.push_back(4.5);
+ cell1.push_back(5.25);
+ cell1.push_back(6.125);
+
+ node.SetStyle(EmitterStyle::Flow);
+ node.push_back(cell0);
+ node.push_back(cell1);
+
+ ExpectOutput("[[1.5, 2.25, 3.125], [4.5, 5.25, 6.125]]", node);
+}
+
+TEST_F(NodeEmitterTest, MixBlockFlowSeqNode) {
+ Node node, cell0, cell1;
+
+ cell0.SetStyle(EmitterStyle::Flow);
+ cell0.push_back(1.5);
+ cell0.push_back(2.25);
+ cell0.push_back(3.125);
+
+ cell1.push_back(4.5);
+ cell1.push_back(5.25);
+ cell1.push_back(6.125);
+
+ node.SetStyle(EmitterStyle::Block);
+ node.push_back(cell0);
+ node.push_back(cell1);
+
+ ExpectOutput("- [1.5, 2.25, 3.125]\n-\n - 4.5\n - 5.25\n - 6.125", node);
+}
+
+TEST_F(NodeEmitterTest, NestBlockFlowMapListNode) {
+ Node node, mapNode, blockNode;
+
+ node.push_back(1.5);
+ node.push_back(2.25);
+ node.push_back(3.125);
+
+ mapNode.SetStyle(EmitterStyle::Flow);
+ mapNode["position"] = node;
+
+ blockNode.push_back(1.0625);
+ blockNode.push_back(mapNode);
+
+ ExpectOutput("- 1.0625\n- {position: [1.5, 2.25, 3.125]}", blockNode);
+}
+
+TEST_F(NodeEmitterTest, NestBlockMixMapListNode) {
+ Node node, mapNode, blockNode;
+
+ node.push_back(1.5);
+ node.push_back(2.25);
+ node.push_back(3.125);
+
+ mapNode.SetStyle(EmitterStyle::Flow);
+ mapNode["position"] = node;
+
+ blockNode["scalar"] = 1.0625;
+ blockNode["object"] = mapNode;
+
+ ExpectAnyOutput(blockNode,
+ "scalar: 1.0625\nobject: {position: [1.5, 2.25, 3.125]}",
+ "object: {position: [1.5, 2.25, 3.125]}\nscalar: 1.5");
+}
+
+TEST_F(NodeEmitterTest, NestBlockMapListNode) {
+ Node node, mapNode;
+
+ node.push_back(1.5);
+ node.push_back(2.25);
+ node.push_back(3.125);
+
+ mapNode.SetStyle(EmitterStyle::Block);
+ mapNode["position"] = node;
+
+ ExpectOutput("position:\n - 1.5\n - 2.25\n - 3.125", mapNode);
+}
+
+TEST_F(NodeEmitterTest, NestFlowMapListNode) {
+ Node node, mapNode;
+
+ node.push_back(1.5);
+ node.push_back(2.25);
+ node.push_back(3.125);
+
+ mapNode.SetStyle(EmitterStyle::Flow);
+ mapNode["position"] = node;
+
+ ExpectOutput("{position: [1.5, 2.25, 3.125]}", mapNode);
+}
+}
+}
--- /dev/null
+#include <sstream>
+#include <cstddef>
+
+#include "gtest/gtest.h"
+#include "yaml-cpp/ostream_wrapper.h"
+
+namespace {
+TEST(OstreamWrapperTest, BufferNoWrite) {
+ YAML::ostream_wrapper wrapper;
+ EXPECT_STREQ("", wrapper.str());
+}
+
+TEST(OstreamWrapperTest, BufferWriteStr) {
+ YAML::ostream_wrapper wrapper;
+ wrapper.write(std::string("Hello, world"));
+ EXPECT_STREQ("Hello, world", wrapper.str());
+}
+
+TEST(OstreamWrapperTest, BufferWriteCStr) {
+ YAML::ostream_wrapper wrapper;
+ wrapper.write("Hello, world");
+ EXPECT_STREQ("Hello, world", wrapper.str());
+}
+
+TEST(OstreamWrapperTest, StreamNoWrite) {
+ std::stringstream stream;
+ YAML::ostream_wrapper wrapper(stream);
+ EXPECT_STREQ(NULL, wrapper.str());
+ EXPECT_EQ("", stream.str());
+}
+
+TEST(OstreamWrapperTest, StreamWriteStr) {
+ std::stringstream stream;
+ YAML::ostream_wrapper wrapper(stream);
+ wrapper.write(std::string("Hello, world"));
+ EXPECT_STREQ(NULL, wrapper.str());
+ EXPECT_EQ("Hello, world", stream.str());
+}
+
+TEST(OstreamWrapperTest, StreamWriteCStr) {
+ std::stringstream stream;
+ YAML::ostream_wrapper wrapper(stream);
+ wrapper.write("Hello, world");
+ EXPECT_STREQ(NULL, wrapper.str());
+ EXPECT_EQ("Hello, world", stream.str());
+}
+
+TEST(OstreamWrapperTest, Position) {
+ YAML::ostream_wrapper wrapper;
+ wrapper.write("Hello, world\n");
+ EXPECT_EQ(1, wrapper.row());
+ EXPECT_EQ(0, wrapper.col());
+ EXPECT_EQ(13, wrapper.pos());
+}
+
+TEST(OstreamWrapperTest, Comment) {
+ YAML::ostream_wrapper wrapper;
+ wrapper.write("Hello, world ");
+ wrapper.set_comment();
+ EXPECT_TRUE(wrapper.comment());
+ wrapper.write("foo");
+ EXPECT_TRUE(wrapper.comment());
+ wrapper.write("\n");
+ EXPECT_FALSE(wrapper.comment());
+}
+}
--- /dev/null
+#include <yaml-cpp/depthguard.h>
+#include "yaml-cpp/parser.h"
+#include "yaml-cpp/exceptions.h"
+#include "mock_event_handler.h"
+#include "gtest/gtest.h"
+
+using YAML::Parser;
+using YAML::MockEventHandler;
+using ::testing::NiceMock;
+using ::testing::StrictMock;
+
+TEST(ParserTest, Empty) {
+ Parser parser;
+
+ EXPECT_FALSE(parser);
+
+ StrictMock<MockEventHandler> handler;
+ EXPECT_FALSE(parser.HandleNextDocument(handler));
+}
+
+TEST(ParserTest, CVE_2017_5950) {
+ std::string excessive_recursion;
+ for (auto i = 0; i != 16384; ++i)
+ excessive_recursion.push_back('[');
+ std::istringstream input{excessive_recursion};
+ Parser parser{input};
+
+ NiceMock<MockEventHandler> handler;
+ EXPECT_THROW(parser.HandleNextDocument(handler), YAML::DeepRecursion);
+}
+
+TEST(ParserTest, CVE_2018_20573) {
+ std::string excessive_recursion;
+ for (auto i = 0; i != 20535; ++i)
+ excessive_recursion.push_back('{');
+ std::istringstream input{excessive_recursion};
+ Parser parser{input};
+
+ NiceMock<MockEventHandler> handler;
+ EXPECT_THROW(parser.HandleNextDocument(handler), YAML::DeepRecursion);
+}
+
+TEST(ParserTest, CVE_2018_20574) {
+ std::string excessive_recursion;
+ for (auto i = 0; i != 21989; ++i)
+ excessive_recursion.push_back('{');
+ std::istringstream input{excessive_recursion};
+ Parser parser{input};
+
+ NiceMock<MockEventHandler> handler;
+ EXPECT_THROW(parser.HandleNextDocument(handler), YAML::DeepRecursion);
+}
+
+TEST(ParserTest, CVE_2019_6285) {
+ std::string excessive_recursion;
+ for (auto i = 0; i != 23100; ++i)
+ excessive_recursion.push_back('[');
+ excessive_recursion.push_back('f');
+ std::istringstream input{excessive_recursion};
+ Parser parser{input};
+
+ NiceMock<MockEventHandler> handler;
+ EXPECT_THROW(parser.HandleNextDocument(handler), YAML::DeepRecursion);
+}
--- /dev/null
+#include "regex_yaml.h"
+#include "stream.h"
+#include "gtest/gtest.h"
+
+using YAML::RegEx;
+using YAML::Stream;
+
+namespace {
+const auto MIN_CHAR = Stream::eof() + 1;
+
+TEST(RegExTest, Empty) {
+ RegEx empty;
+ EXPECT_TRUE(empty.Matches(std::string()));
+ EXPECT_EQ(0, empty.Match(std::string()));
+ for (int i = MIN_CHAR; i < 128; ++i) {
+ auto str = std::string(1, char(i));
+ EXPECT_FALSE(empty.Matches(str));
+ EXPECT_EQ(-1, empty.Match(str));
+ }
+}
+
+TEST(RegExTest, Range) {
+ for (int i = MIN_CHAR; i < 128; ++i) {
+ for (int j = MIN_CHAR; j < 128; ++j) {
+ RegEx ex((char)i, (char)j);
+ for (int k = MIN_CHAR; k < 128; ++k) {
+ auto str = std::string(1, char(k));
+ if (i <= k && k <= j) {
+ EXPECT_TRUE(ex.Matches(str));
+ EXPECT_EQ(1, ex.Match(str));
+ } else {
+ EXPECT_FALSE(ex.Matches(str));
+ EXPECT_EQ(-1, ex.Match(str));
+ }
+ }
+ }
+ }
+}
+
+TEST(RegExTest, EmptyString) {
+ RegEx ex = RegEx(std::string());
+ EXPECT_TRUE(ex.Matches(std::string()));
+ EXPECT_EQ(0, ex.Match(std::string()));
+
+ // Matches anything, unlike RegEx()!
+ EXPECT_TRUE(ex.Matches(std::string("hello")));
+ EXPECT_EQ(0, ex.Match(std::string("hello")));
+}
+
+TEST(RegExTest, SingleCharacterString) {
+ for (int i = MIN_CHAR; i < 128; ++i) {
+ RegEx ex(std::string(1, (char)i));
+ for (int j = MIN_CHAR; j < 128; ++j) {
+ auto str = std::string(1, char(j));
+ if (j == i) {
+ EXPECT_TRUE(ex.Matches(str));
+ EXPECT_EQ(1, ex.Match(str));
+ // Match at start of string only!
+ std::string prefixed =
+ std::string(1, i + 1) + std::string("prefix: ") + str;
+ EXPECT_FALSE(ex.Matches(prefixed));
+ EXPECT_EQ(-1, ex.Match(prefixed));
+ } else {
+ EXPECT_FALSE(ex.Matches(str));
+ EXPECT_EQ(-1, ex.Match(str));
+ }
+ }
+ }
+}
+
+TEST(RegExTest, MultiCharacterString) {
+ RegEx ex(std::string("ab"));
+
+ EXPECT_FALSE(ex.Matches(std::string("a")));
+ EXPECT_EQ(-1, ex.Match(std::string("a")));
+
+ EXPECT_TRUE(ex.Matches(std::string("ab")));
+ EXPECT_EQ(2, ex.Match(std::string("ab")));
+ EXPECT_TRUE(ex.Matches(std::string("abba")));
+ EXPECT_EQ(2, ex.Match(std::string("abba")));
+
+ // match at start of string only!
+ EXPECT_FALSE(ex.Matches(std::string("baab")));
+ EXPECT_EQ(-1, ex.Match(std::string("baab")));
+}
+
+TEST(RegExTest, OperatorNot) {
+ RegEx ex = !RegEx(std::string("ab"));
+
+ EXPECT_TRUE(ex.Matches(std::string("a")));
+ EXPECT_EQ(1, ex.Match(std::string("a")));
+
+ EXPECT_FALSE(ex.Matches(std::string("ab")));
+ EXPECT_EQ(-1, ex.Match(std::string("ab")));
+ EXPECT_FALSE(ex.Matches(std::string("abba")));
+ EXPECT_EQ(-1, ex.Match(std::string("abba")));
+
+ // match at start of string only!
+ EXPECT_TRUE(ex.Matches(std::string("baab")));
+ // Operator not causes only one character to be matched.
+ EXPECT_EQ(1, ex.Match(std::string("baab")));
+}
+
+TEST(RegExTest, OperatorOr) {
+ for (int i = MIN_CHAR; i < 127; ++i) {
+ for (int j = i + 1; j < 128; ++j) {
+ auto iStr = std::string(1, char(i));
+ auto jStr = std::string(1, char(j));
+ RegEx ex1 = RegEx(iStr) | RegEx(jStr);
+ RegEx ex2 = RegEx(jStr) | RegEx(iStr);
+
+ for (int k = MIN_CHAR; k < 128; ++k) {
+ auto str = std::string(1, char(k));
+ if (i == k || j == k) {
+ EXPECT_TRUE(ex1.Matches(str));
+ EXPECT_TRUE(ex2.Matches(str));
+ EXPECT_EQ(1, ex1.Match(str));
+ EXPECT_EQ(1, ex2.Match(str));
+ } else {
+ EXPECT_FALSE(ex1.Matches(str));
+ EXPECT_FALSE(ex2.Matches(str));
+ EXPECT_EQ(-1, ex1.Match(str));
+ EXPECT_EQ(-1, ex2.Match(str));
+ }
+ }
+ }
+ }
+}
+
+TEST(RegExTest, OperatorOrShortCircuits) {
+ RegEx ex1 = RegEx(std::string("aaaa")) | RegEx(std::string("aa"));
+ RegEx ex2 = RegEx(std::string("aa")) | RegEx(std::string("aaaa"));
+
+ EXPECT_TRUE(ex1.Matches(std::string("aaaaa")));
+ EXPECT_EQ(4, ex1.Match(std::string("aaaaa")));
+
+ EXPECT_TRUE(ex2.Matches(std::string("aaaaa")));
+ EXPECT_EQ(2, ex2.Match(std::string("aaaaa")));
+}
+
+TEST(RegExTest, OperatorAnd) {
+ RegEx emptySet = RegEx('a') & RegEx();
+ EXPECT_FALSE(emptySet.Matches(std::string("a")));
+}
+
+TEST(RegExTest, OperatorAndShortCircuits) {
+ RegEx ex1 = RegEx(std::string("aaaa")) & RegEx(std::string("aa"));
+ RegEx ex2 = RegEx(std::string("aa")) & RegEx(std::string("aaaa"));
+
+ EXPECT_TRUE(ex1.Matches(std::string("aaaaa")));
+ EXPECT_EQ(4, ex1.Match(std::string("aaaaa")));
+
+ EXPECT_TRUE(ex2.Matches(std::string("aaaaa")));
+ EXPECT_EQ(2, ex2.Match(std::string("aaaaa")));
+}
+
+TEST(RegExTest, OperatorPlus) {
+ RegEx ex = RegEx(std::string("hello ")) + RegEx(std::string("there"));
+
+ EXPECT_TRUE(ex.Matches(std::string("hello there")));
+ EXPECT_FALSE(ex.Matches(std::string("hello ")));
+ EXPECT_FALSE(ex.Matches(std::string("there")));
+ EXPECT_EQ(11, ex.Match(std::string("hello there")));
+}
+
+TEST(RegExTest, StringOr) {
+ std::string str = "abcde";
+ RegEx ex = RegEx(str, YAML::REGEX_OR);
+
+ for (size_t i = 0; i < str.size(); ++i) {
+ EXPECT_TRUE(ex.Matches(str.substr(i, 1)));
+ EXPECT_EQ(1, ex.Match(str.substr(i, 1)));
+ }
+
+ EXPECT_EQ(1, ex.Match(str));
+}
+} // namespace
--- /dev/null
+namespace {
+const char *ex2_1 =
+ "- Mark McGwire\n"
+ "- Sammy Sosa\n"
+ "- Ken Griffey";
+
+const char *ex2_2 =
+ "hr: 65 # Home runs\n"
+ "avg: 0.278 # Batting average\n"
+ "rbi: 147 # Runs Batted In";
+
+const char *ex2_3 =
+ "american:\n"
+ "- Boston Red Sox\n"
+ "- Detroit Tigers\n"
+ "- New York Yankees\n"
+ "national:\n"
+ "- New York Mets\n"
+ "- Chicago Cubs\n"
+ "- Atlanta Braves";
+
+const char *ex2_4 =
+ "-\n"
+ " name: Mark McGwire\n"
+ " hr: 65\n"
+ " avg: 0.278\n"
+ "-\n"
+ " name: Sammy Sosa\n"
+ " hr: 63\n"
+ " avg: 0.288";
+
+const char *ex2_5 =
+ "- [name , hr, avg ]\n"
+ "- [Mark McGwire, 65, 0.278]\n"
+ "- [Sammy Sosa , 63, 0.288]";
+
+const char *ex2_6 =
+ "Mark McGwire: {hr: 65, avg: 0.278}\n"
+ "Sammy Sosa: {\n"
+ " hr: 63,\n"
+ " avg: 0.288\n"
+ " }";
+
+const char *ex2_7 =
+ "# Ranking of 1998 home runs\n"
+ "---\n"
+ "- Mark McGwire\n"
+ "- Sammy Sosa\n"
+ "- Ken Griffey\n"
+ "\n"
+ "# Team ranking\n"
+ "---\n"
+ "- Chicago Cubs\n"
+ "- St Louis Cardinals";
+
+const char *ex2_8 =
+ "---\n"
+ "time: 20:03:20\n"
+ "player: Sammy Sosa\n"
+ "action: strike (miss)\n"
+ "...\n"
+ "---\n"
+ "time: 20:03:47\n"
+ "player: Sammy Sosa\n"
+ "action: grand slam\n"
+ "...";
+
+const char *ex2_9 =
+ "---\n"
+ "hr: # 1998 hr ranking\n"
+ " - Mark McGwire\n"
+ " - Sammy Sosa\n"
+ "rbi:\n"
+ " # 1998 rbi ranking\n"
+ " - Sammy Sosa\n"
+ " - Ken Griffey";
+
+const char *ex2_10 =
+ "---\n"
+ "hr:\n"
+ " - Mark McGwire\n"
+ " # Following node labeled SS\n"
+ " - &SS Sammy Sosa\n"
+ "rbi:\n"
+ " - *SS # Subsequent occurrence\n"
+ " - Ken Griffey";
+
+const char *ex2_11 =
+ "? - Detroit Tigers\n"
+ " - Chicago cubs\n"
+ ":\n"
+ " - 2001-07-23\n"
+ "\n"
+ "? [ New York Yankees,\n"
+ " Atlanta Braves ]\n"
+ ": [ 2001-07-02, 2001-08-12,\n"
+ " 2001-08-14 ]";
+
+const char *ex2_12 =
+ "---\n"
+ "# Products purchased\n"
+ "- item : Super Hoop\n"
+ " quantity: 1\n"
+ "- item : Basketball\n"
+ " quantity: 4\n"
+ "- item : Big Shoes\n"
+ " quantity: 1";
+
+const char *ex2_13 =
+ "# ASCII Art\n"
+ "--- |\n"
+ " \\//||\\/||\n"
+ " // || ||__";
+
+const char *ex2_14 =
+ "--- >\n"
+ " Mark McGwire's\n"
+ " year was crippled\n"
+ " by a knee injury.";
+
+const char *ex2_15 =
+ ">\n"
+ " Sammy Sosa completed another\n"
+ " fine season with great stats.\n"
+ " \n"
+ " 63 Home Runs\n"
+ " 0.288 Batting Average\n"
+ " \n"
+ " What a year!";
+
+const char *ex2_16 =
+ "name: Mark McGwire\n"
+ "accomplishment: >\n"
+ " Mark set a major league\n"
+ " home run record in 1998.\n"
+ "stats: |\n"
+ " 65 Home Runs\n"
+ " 0.278 Batting Average\n";
+
+const char *ex2_17 =
+ "unicode: \"Sosa did fine.\\u263A\"\n"
+ "control: \"\\b1998\\t1999\\t2000\\n\"\n"
+ "hex esc: \"\\x0d\\x0a is \\r\\n\"\n"
+ "\n"
+ "single: '\"Howdy!\" he cried.'\n"
+ "quoted: ' # Not a ''comment''.'\n"
+ "tie-fighter: '|\\-*-/|'";
+
+const char *ex2_18 =
+ "plain:\n"
+ " This unquoted scalar\n"
+ " spans many lines.\n"
+ "\n"
+ "quoted: \"So does this\n"
+ " quoted scalar.\\n\"";
+
+const char *ex2_19 =
+ "canonical: 12345\n"
+ "decimal: +12345\n"
+ "octal: 0o14\n"
+ "hexadecimal: 0xC\n";
+
+const char *ex2_20 =
+ "canonical: 1.23015e+3\n"
+ "exponential: 12.3015e+02\n"
+ "fixed: 1230.15\n"
+ "negative infinity: -.inf\n"
+ "not a number: .NaN\n";
+
+const char *ex2_21 =
+ "null:\n"
+ "booleans: [ true, false ]\n"
+ "string: '012345'\n";
+
+const char *ex2_22 =
+ "canonical: 2001-12-15T02:59:43.1Z\n"
+ "iso8601: 2001-12-14t21:59:43.10-05:00\n"
+ "spaced: 2001-12-14 21:59:43.10 -5\n"
+ "date: 2002-12-14\n";
+
+const char *ex2_23 =
+ "---\n"
+ "not-date: !!str 2002-04-28\n"
+ "\n"
+ "picture: !!binary |\n"
+ " R0lGODlhDAAMAIQAAP//9/X\n"
+ " 17unp5WZmZgAAAOfn515eXv\n"
+ " Pz7Y6OjuDg4J+fn5OTk6enp\n"
+ " 56enmleECcgggoBADs=\n"
+ "\n"
+ "application specific tag: !something |\n"
+ " The semantics of the tag\n"
+ " above may be different for\n"
+ " different documents.";
+
+const char *ex2_24 =
+ "%TAG ! tag:clarkevans.com,2002:\n"
+ "--- !shape\n"
+ " # Use the ! handle for presenting\n"
+ " # tag:clarkevans.com,2002:circle\n"
+ "- !circle\n"
+ " center: &ORIGIN {x: 73, y: 129}\n"
+ " radius: 7\n"
+ "- !line\n"
+ " start: *ORIGIN\n"
+ " finish: { x: 89, y: 102 }\n"
+ "- !label\n"
+ " start: *ORIGIN\n"
+ " color: 0xFFEEBB\n"
+ " text: Pretty vector drawing.";
+
+const char *ex2_25 =
+ "# Sets are represented as a\n"
+ "# Mapping where each key is\n"
+ "# associated with a null value\n"
+ "--- !!set\n"
+ "? Mark McGwire\n"
+ "? Sammy Sosa\n"
+ "? Ken Griffey";
+
+const char *ex2_26 =
+ "# Ordered maps are represented as\n"
+ "# A sequence of mappings, with\n"
+ "# each mapping having one key\n"
+ "--- !!omap\n"
+ "- Mark McGwire: 65\n"
+ "- Sammy Sosa: 63\n"
+ "- Ken Griffey: 58";
+
+const char *ex2_27 =
+ "--- !<tag:clarkevans.com,2002:invoice>\n"
+ "invoice: 34843\n"
+ "date : 2001-01-23\n"
+ "bill-to: &id001\n"
+ " given : Chris\n"
+ " family : Dumars\n"
+ " address:\n"
+ " lines: |\n"
+ " 458 Walkman Dr.\n"
+ " Suite #292\n"
+ " city : Royal Oak\n"
+ " state : MI\n"
+ " postal : 48046\n"
+ "ship-to: *id001\n"
+ "product:\n"
+ " - sku : BL394D\n"
+ " quantity : 4\n"
+ " description : Basketball\n"
+ " price : 450.00\n"
+ " - sku : BL4438H\n"
+ " quantity : 1\n"
+ " description : Super Hoop\n"
+ " price : 2392.00\n"
+ "tax : 251.42\n"
+ "total: 4443.52\n"
+ "comments:\n"
+ " Late afternoon is best.\n"
+ " Backup contact is Nancy\n"
+ " Billsmer @ 338-4338.";
+
+const char *ex2_28 =
+ "---\n"
+ "Time: 2001-11-23 15:01:42 -5\n"
+ "User: ed\n"
+ "Warning:\n"
+ " This is an error message\n"
+ " for the log file\n"
+ "---\n"
+ "Time: 2001-11-23 15:02:31 -5\n"
+ "User: ed\n"
+ "Warning:\n"
+ " A slightly different error\n"
+ " message.\n"
+ "---\n"
+ "Date: 2001-11-23 15:03:17 -5\n"
+ "User: ed\n"
+ "Fatal:\n"
+ " Unknown variable \"bar\"\n"
+ "Stack:\n"
+ " - file: TopClass.py\n"
+ " line: 23\n"
+ " code: |\n"
+ " x = MoreObject(\"345\\n\")\n"
+ " - file: MoreClass.py\n"
+ " line: 58\n"
+ " code: |-\n"
+ " foo = bar";
+
+// TODO: 5.1 - 5.2 BOM
+
+const char *ex5_3 =
+ "sequence:\n"
+ "- one\n"
+ "- two\n"
+ "mapping:\n"
+ " ? sky\n"
+ " : blue\n"
+ " sea : green";
+
+const char *ex5_4 =
+ "sequence: [ one, two, ]\n"
+ "mapping: { sky: blue, sea: green }";
+
+const char *ex5_5 = "# Comment only.";
+
+const char *ex5_6 =
+ "anchored: !local &anchor value\n"
+ "alias: *anchor";
+
+const char *ex5_7 =
+ "literal: |\n"
+ " some\n"
+ " text\n"
+ "folded: >\n"
+ " some\n"
+ " text\n";
+
+const char *ex5_8 =
+ "single: 'text'\n"
+ "double: \"text\"";
+
+// TODO: 5.9 directive
+// TODO: 5.10 reserved indicator
+
+const char *ex5_11 =
+ "|\n"
+ " Line break (no glyph)\n"
+ " Line break (glyphed)\n";
+
+const char *ex5_12 =
+ "# Tabs and spaces\n"
+ "quoted: \"Quoted\t\"\n"
+ "block: |\n"
+ " void main() {\n"
+ " \tprintf(\"Hello, world!\\n\");\n"
+ " }";
+
+const char *ex5_13 =
+ "\"Fun with \\\\\n"
+ "\\\" \\a \\b \\e \\f \\\n"
+ "\\n \\r \\t \\v \\0 \\\n"
+ "\\ \\_ \\N \\L \\P \\\n"
+ "\\x41 \\u0041 \\U00000041\"";
+
+const char *ex5_14 =
+ "Bad escapes:\n"
+ " \"\\c\n"
+ " \\xq-\"";
+
+const char *ex6_1 =
+ " # Leading comment line spaces are\n"
+ " # neither content nor indentation.\n"
+ " \n"
+ "Not indented:\n"
+ " By one space: |\n"
+ " By four\n"
+ " spaces\n"
+ " Flow style: [ # Leading spaces\n"
+ " By two, # in flow style\n"
+ " Also by two, # are neither\n"
+ " \tStill by two # content nor\n"
+ " ] # indentation.";
+
+const char *ex6_2 =
+ "? a\n"
+ ": -\tb\n"
+ " - -\tc\n"
+ " - d";
+
+const char *ex6_3 =
+ "- foo:\t bar\n"
+ "- - baz\n"
+ " -\tbaz";
+
+const char *ex6_4 =
+ "plain: text\n"
+ " lines\n"
+ "quoted: \"text\n"
+ " \tlines\"\n"
+ "block: |\n"
+ " text\n"
+ " \tlines\n";
+
+const char *ex6_5 =
+ "Folding:\n"
+ " \"Empty line\n"
+ " \t\n"
+ " as a line feed\"\n"
+ "Chomping: |\n"
+ " Clipped empty lines\n"
+ " ";
+
+const char *ex6_6 =
+ ">-\n"
+ " trimmed\n"
+ " \n"
+ " \n"
+ "\n"
+ " as\n"
+ " space";
+
+const char *ex6_7 =
+ ">\n"
+ " foo \n"
+ " \n"
+ " \t bar\n"
+ "\n"
+ " baz\n";
+
+const char *ex6_8 =
+ "\"\n"
+ " foo \n"
+ " \n"
+ " \t bar\n"
+ "\n"
+ " baz\n"
+ "\"";
+
+const char *ex6_9 =
+ "key: # Comment\n"
+ " value";
+
+const char *ex6_10 =
+ " # Comment\n"
+ " \n"
+ "\n";
+
+const char *ex6_11 =
+ "key: # Comment\n"
+ " # lines\n"
+ " value\n"
+ "\n";
+
+const char *ex6_12 =
+ "{ first: Sammy, last: Sosa }:\n"
+ "# Statistics:\n"
+ " hr: # Home runs\n"
+ " 65\n"
+ " avg: # Average\n"
+ " 0.278";
+
+const char *ex6_13 =
+ "%FOO bar baz # Should be ignored\n"
+ " # with a warning.\n"
+ "--- \"foo\"";
+
+const char *ex6_14 =
+ "%YAML 1.3 # Attempt parsing\n"
+ " # with a warning\n"
+ "---\n"
+ "\"foo\"";
+
+const char *ex6_15 =
+ "%YAML 1.2\n"
+ "%YAML 1.1\n"
+ "foo";
+
+const char *ex6_16 =
+ "%TAG !yaml! tag:yaml.org,2002:\n"
+ "---\n"
+ "!yaml!str \"foo\"";
+
+const char *ex6_17 =
+ "%TAG ! !foo\n"
+ "%TAG ! !foo\n"
+ "bar";
+
+const char *ex6_18 =
+ "# Private\n"
+ "!foo \"bar\"\n"
+ "...\n"
+ "# Global\n"
+ "%TAG ! tag:example.com,2000:app/\n"
+ "---\n"
+ "!foo \"bar\"";
+
+const char *ex6_19 =
+ "%TAG !! tag:example.com,2000:app/\n"
+ "---\n"
+ "!!int 1 - 3 # Interval, not integer";
+
+const char *ex6_20 =
+ "%TAG !e! tag:example.com,2000:app/\n"
+ "---\n"
+ "!e!foo \"bar\"";
+
+const char *ex6_21 =
+ "%TAG !m! !my-\n"
+ "--- # Bulb here\n"
+ "!m!light fluorescent\n"
+ "...\n"
+ "%TAG !m! !my-\n"
+ "--- # Color here\n"
+ "!m!light green";
+
+const char *ex6_22 =
+ "%TAG !e! tag:example.com,2000:app/\n"
+ "---\n"
+ "- !e!foo \"bar\"";
+
+const char *ex6_23 =
+ "!!str &a1 \"foo\":\n"
+ " !!str bar\n"
+ "&a2 baz : *a1";
+
+const char *ex6_24 =
+ "!<tag:yaml.org,2002:str> foo :\n"
+ " !<!bar> baz";
+
+const char *ex6_25 =
+ "- !<!> foo\n"
+ "- !<$:?> bar\n";
+
+const char *ex6_26 =
+ "%TAG !e! tag:example.com,2000:app/\n"
+ "---\n"
+ "- !local foo\n"
+ "- !!str bar\n"
+ "- !e!tag%21 baz\n";
+
+const char *ex6_27a =
+ "%TAG !e! tag:example,2000:app/\n"
+ "---\n"
+ "- !e! foo";
+
+const char *ex6_27b =
+ "%TAG !e! tag:example,2000:app/\n"
+ "---\n"
+ "- !h!bar baz";
+
+const char *ex6_28 =
+ "# Assuming conventional resolution:\n"
+ "- \"12\"\n"
+ "- 12\n"
+ "- ! 12";
+
+const char *ex6_29 =
+ "First occurrence: &anchor Value\n"
+ "Second occurrence: *anchor";
+
+const char *ex7_1 =
+ "First occurrence: &anchor Foo\n"
+ "Second occurrence: *anchor\n"
+ "Override anchor: &anchor Bar\n"
+ "Reuse anchor: *anchor";
+
+const char *ex7_2 =
+ "{\n"
+ " foo : !!str,\n"
+ " !!str : bar,\n"
+ "}";
+
+const char *ex7_3 =
+ "{\n"
+ " ? foo :,\n"
+ " : bar,\n"
+ "}\n";
+
+const char *ex7_4 =
+ "\"implicit block key\" : [\n"
+ " \"implicit flow key\" : value,\n"
+ " ]";
+
+const char *ex7_5 =
+ "\"folded \n"
+ "to a space,\t\n"
+ " \n"
+ "to a line feed, or \t\\\n"
+ " \\ \tnon-content\"";
+
+const char *ex7_6 =
+ "\" 1st non-empty\n"
+ "\n"
+ " 2nd non-empty \n"
+ "\t3rd non-empty \"";
+
+const char *ex7_7 = " 'here''s to \"quotes\"'";
+
+const char *ex7_8 =
+ "'implicit block key' : [\n"
+ " 'implicit flow key' : value,\n"
+ " ]";
+
+const char *ex7_9 =
+ "' 1st non-empty\n"
+ "\n"
+ " 2nd non-empty \n"
+ "\t3rd non-empty '";
+
+const char *ex7_10 =
+ "# Outside flow collection:\n"
+ "- ::vector\n"
+ "- \": - ()\"\n"
+ "- Up, up, and away!\n"
+ "- -123\n"
+ "- http://example.com/foo#bar\n"
+ "# Inside flow collection:\n"
+ "- [ ::vector,\n"
+ " \": - ()\",\n"
+ " \"Up, up, and away!\",\n"
+ " -123,\n"
+ " http://example.com/foo#bar ]";
+
+const char *ex7_11 =
+ "implicit block key : [\n"
+ " implicit flow key : value,\n"
+ " ]";
+
+const char *ex7_12 =
+ "1st non-empty\n"
+ "\n"
+ " 2nd non-empty \n"
+ "\t3rd non-empty";
+
+const char *ex7_13 =
+ "- [ one, two, ]\n"
+ "- [three ,four]";
+
+const char *ex7_14 =
+ "[\n"
+ "\"double\n"
+ " quoted\", 'single\n"
+ " quoted',\n"
+ "plain\n"
+ " text, [ nested ],\n"
+ "single: pair,\n"
+ "]";
+
+const char *ex7_15 =
+ "- { one : two , three: four , }\n"
+ "- {five: six,seven : eight}";
+
+const char *ex7_16 =
+ "{\n"
+ "? explicit: entry,\n"
+ "implicit: entry,\n"
+ "?\n"
+ "}";
+
+const char *ex7_17 =
+ "{\n"
+ "unquoted : \"separate\",\n"
+ "http://foo.com,\n"
+ "omitted value:,\n"
+ ": omitted key,\n"
+ "}";
+
+const char *ex7_18 =
+ "{\n"
+ "\"adjacent\":value,\n"
+ "\"readable\":value,\n"
+ "\"empty\":\n"
+ "}";
+
+const char *ex7_19 =
+ "[\n"
+ "foo: bar\n"
+ "]";
+
+const char *ex7_20 =
+ "[\n"
+ "? foo\n"
+ " bar : baz\n"
+ "]";
+
+const char *ex7_21 =
+ "- [ YAML : separate ]\n"
+ "- [ : empty key entry ]\n"
+ "- [ {JSON: like}:adjacent ]";
+
+const char *ex7_22 =
+ "[ foo\n"
+ " bar: invalid,"; // Note: we don't check (on purpose) the >1K chars for an
+ // implicit key
+
+const char *ex7_23 =
+ "- [ a, b ]\n"
+ "- { a: b }\n"
+ "- \"a\"\n"
+ "- 'b'\n"
+ "- c";
+
+const char *ex7_24 =
+ "- !!str \"a\"\n"
+ "- 'b'\n"
+ "- &anchor \"c\"\n"
+ "- *anchor\n"
+ "- !!str";
+
+const char *ex8_1 =
+ "- | # Empty header\n"
+ " literal\n"
+ "- >1 # Indentation indicator\n"
+ " folded\n"
+ "- |+ # Chomping indicator\n"
+ " keep\n"
+ "\n"
+ "- >1- # Both indicators\n"
+ " strip\n";
+
+const char *ex8_2 =
+ "- |\n"
+ " detected\n"
+ "- >\n"
+ " \n"
+ " \n"
+ " # detected\n"
+ "- |1\n"
+ " explicit\n"
+ "- >\n"
+ " \t\n"
+ " detected\n";
+
+const char *ex8_3a =
+ "- |\n"
+ " \n"
+ " text";
+
+const char *ex8_3b =
+ "- >\n"
+ " text\n"
+ " text";
+
+const char *ex8_3c =
+ "- |2\n"
+ " text";
+
+const char *ex8_4 =
+ "strip: |-\n"
+ " text\n"
+ "clip: |\n"
+ " text\n"
+ "keep: |+\n"
+ " text\n";
+
+const char *ex8_5 =
+ " # Strip\n"
+ " # Comments:\n"
+ "strip: |-\n"
+ " # text\n"
+ " \n"
+ " # Clip\n"
+ " # comments:\n"
+ "\n"
+ "clip: |\n"
+ " # text\n"
+ " \n"
+ " # Keep\n"
+ " # comments:\n"
+ "\n"
+ "keep: |+\n"
+ " # text\n"
+ "\n"
+ " # Trail\n"
+ " # Comments\n";
+
+const char *ex8_6 =
+ "strip: >-\n"
+ "\n"
+ "clip: >\n"
+ "\n"
+ "keep: |+\n"
+ "\n";
+
+const char *ex8_7 =
+ "|\n"
+ " literal\n"
+ " \ttext\n"
+ "\n";
+
+const char *ex8_8 =
+ "|\n"
+ " \n"
+ " \n"
+ " literal\n"
+ " \n"
+ " \n"
+ " text\n"
+ "\n"
+ " # Comment\n";
+
+const char *ex8_9 =
+ ">\n"
+ " folded\n"
+ " text\n"
+ "\n";
+
+const char *ex8_10 =
+ ">\n"
+ "\n"
+ " folded\n"
+ " line\n"
+ "\n"
+ " next\n"
+ " line\n"
+ " * bullet\n"
+ "\n"
+ " * list\n"
+ " * lines\n"
+ "\n"
+ " last\n"
+ " line\n"
+ "\n"
+ "# Comment\n";
+
+const char *ex8_11 = ex8_10;
+const char *ex8_12 = ex8_10;
+const char *ex8_13 = ex8_10;
+
+const char *ex8_14 =
+ "block sequence:\n"
+ " - one\n"
+ " - two : three\n";
+
+const char *ex8_15 =
+ "- # Empty\n"
+ "- |\n"
+ " block node\n"
+ "- - one # Compact\n"
+ " - two # sequence\n"
+ "- one: two # Compact mapping\n";
+
+const char *ex8_16 =
+ "block mapping:\n"
+ " key: value\n";
+
+const char *ex8_17 =
+ "? explicit key # Empty value\n"
+ "? |\n"
+ " block key\n"
+ ": - one # Explicit compact\n"
+ " - two # block value\n";
+
+const char *ex8_18 =
+ "plain key: in-line value\n"
+ ": # Both empty\n"
+ "\"quoted key\":\n"
+ "- entry\n";
+
+const char *ex8_19 =
+ "- sun: yellow\n"
+ "- ? earth: blue\n"
+ " : moon: white\n";
+
+const char *ex8_20 =
+ "-\n"
+ " \"flow in block\"\n"
+ "- >\n"
+ " Block scalar\n"
+ "- !!map # Block collection\n"
+ " foo : bar\n";
+
+const char *ex8_21 =
+ "literal: |2\n"
+ " value\n"
+ "folded:\n"
+ " !foo\n"
+ " >1\n"
+ " value\n";
+
+const char *ex8_22 =
+ "sequence: !!seq\n"
+ "- entry\n"
+ "- !!seq\n"
+ " - nested\n"
+ "mapping: !!map\n"
+ " foo: bar\n";
+}
--- /dev/null
+add_executable(yaml-cpp-sandbox sandbox.cpp)
+add_executable(yaml-cpp-parse parse.cpp)
+add_executable(yaml-cpp-read read.cpp)
+
+target_link_libraries(yaml-cpp-sandbox PRIVATE yaml-cpp)
+target_link_libraries(yaml-cpp-parse PRIVATE yaml-cpp)
+target_link_libraries(yaml-cpp-read PRIVATE yaml-cpp)
+
+set_property(TARGET yaml-cpp-sandbox PROPERTY OUTPUT_NAME sandbox)
+set_property(TARGET yaml-cpp-parse PROPERTY OUTPUT_NAME parse)
+set_property(TARGET yaml-cpp-read PROPERTY OUTPUT_NAME read)
+
+set_target_properties(yaml-cpp-sandbox
+ PROPERTIES
+ CXX_STANDARD_REQUIRED ON
+ OUTPUT_NAME sandbox)
+
+set_target_properties(yaml-cpp-parse
+ PROPERTIES
+ CXX_STANDARD_REQUIRED ON
+ OUTPUT_NAME parse)
+
+set_target_properties(yaml-cpp-read
+ PROPERTIES
+ CXX_STANDARD_REQUIRED ON
+ OUTPUT_NAME read)
+
+if (NOT DEFINED CMAKE_CXX_STANDARD)
+ set_target_properties(yaml-cpp-sandbox yaml-cpp-parse yaml-cpp-read
+ PROPERTIES
+ CXX_STANDARD 11)
+endif()
--- /dev/null
+// a sketch of what the new API might look like
+
+#include "yaml-cpp/yaml.h"
+#include <iostream>
+
+int main() {
+ {
+ // test.yaml
+ // - foo
+ // - primes: [2, 3, 5, 7, 11]
+ // odds: [1, 3, 5, 7, 9, 11]
+ // - [x, y]
+
+ // move-like semantics
+ YAML::Value root = YAML::Parse("test.yaml");
+
+ std::cout << root[0].as<std::string>(); // "foo"
+ std::cout << str(root[0]); // "foo", shorthand?
+ std::cout << root[1]["primes"][3].as<int>(); // "7"
+ std::cout << root[1]["odds"][6].as<int>(); // throws?
+
+ root[2].push_back(5);
+ root[3] = "Hello, World";
+ root[0].reset();
+ root[0]["key"] = "value";
+
+ std::cout << root;
+ // # not sure about formatting
+ // - {key: value}
+ // - primes: [2, 3, 5, 7, 11]
+ // odds: [1, 3, 5, 7, 9, 11]
+ // - [x, y, 5]
+ // - Hello, World
+ }
+
+ {
+ // for all copy-like commands, think of python's "name/value" semantics
+ YAML::Value root = "Hello"; // Hello
+ root = YAML::Sequence(); // []
+ root[0] = 0; // [0]
+ root[2] = "two"; // [0, ~, two] # forces root[1] to be initialized to null
+
+ YAML::Value other = root; // both point to the same thing
+ other[0] = 5; // now root[0] is 0 also
+ other.push_back(root); // &1 [5, ~, two, *1]
+ other[3][0] = 0; // &1 [0, ~, two, *1] # since it's a true alias
+ other.push_back(Copy(root)); // &1 [0, ~, two, *1, &2 [0, ~, two, *2]]
+ other[4][0] = 5; // &1 [0, ~, two, *1, &2 [5, ~, two, *2]] # they're
+ // really different
+ }
+
+ {
+ YAML::Value node; // ~
+ node[0] = 1; // [1] # auto-construct a sequence
+ node["key"] = 5; // {0: 1, key: 5} # auto-turn it into a map
+ node.push_back(10); // error, can't turn a map into a sequence
+ node.erase("key"); // {0: 1} # still a map, even if we remove the key that
+ // caused the problem
+ node = "Hello"; // Hello # assignment overwrites everything, so it's now
+ // just a plain scalar
+ }
+
+ {
+ YAML::Value map; // ~
+ map[3] = 1; // {3: 1} # auto-constructs a map, *not* a sequence
+
+ YAML::Value seq; // ~
+ seq = YAML::Sequence(); // []
+ seq[3] = 1; // [~, ~, ~, 1]
+ }
+
+ {
+ YAML::Value node; // ~
+ node[0] = node; // &1 [*1] # fun stuff
+ }
+
+ {
+ YAML::Value node;
+ YAML::Value subnode =
+ node["key"]; // 'subnode' is not instantiated ('node' is still null)
+ subnode = "value"; // {key: value} # now it is
+ YAML::Value subnode2 = node["key2"];
+ node["key3"] = subnode2; // subnode2 is still not instantiated, but
+ // node["key3"] is "pseudo" aliased to it
+ subnode2 = "monkey"; // {key: value, key2: &1 monkey, key3: *1} # bam! it
+ // instantiates both
+ }
+
+ {
+ YAML::Value seq = YAML::Sequence();
+ seq[0] = "zero"; // [zero]
+ seq[1] = seq[0]; // [&1 zero, *1]
+ seq[0] = seq[1]; // [&1 zero, *1] # no-op (they both alias the same thing,
+ // so setting them equal is nothing)
+ Is(seq[0], seq[1]); // true
+ seq[1] = "one"; // [&1 one, *1]
+ UnAlias(seq[1]); // [one, one]
+ Is(seq[0], seq[1]); // false
+ }
+
+ {
+ YAML::Value root;
+ root.push_back("zero");
+ root.push_back("one");
+ root.push_back("two");
+ YAML::Value two = root[2];
+ root = "scalar"; // 'two' is still "two", even though 'root' is "scalar"
+ // (the sequence effectively no longer exists)
+
+ // Note: in all likelihood, the memory for nodes "zero" and "one" is still
+ // allocated. How can it go away? Weak pointers?
+ }
+
+ {
+ YAML::Value root; // ~
+ root[0] = root; // &1 [*1]
+ root[0] = 5; // [5]
+ }
+
+ {
+ YAML::Value root;
+ YAML::Value key;
+ key["key"] = "value";
+ root[key] = key; // &1 {key: value}: *1
+ }
+
+ {
+ YAML::Value root;
+ root[0] = "hi";
+ root[1][0] = "bye";
+ root[1][1] = root; // &1 [hi, [bye, *1]] # root
+ YAML::Value sub = root[1]; // &1 [bye, [hi, *1]] # sub
+ root = "gone"; // [bye, gone] # sub
+ }
+
+ return 0;
+}
--- /dev/null
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+
+class NullEventHandler : public YAML::EventHandler {
+ public:
+ void OnDocumentStart(const YAML::Mark&) override {}
+ void OnDocumentEnd() override {}
+
+ void OnNull(const YAML::Mark&, YAML::anchor_t) override {}
+ void OnAlias(const YAML::Mark&, YAML::anchor_t) override {}
+ void OnScalar(const YAML::Mark&, const std::string&, YAML::anchor_t,
+ const std::string&) override {}
+
+ void OnSequenceStart(const YAML::Mark&, const std::string&, YAML::anchor_t,
+ YAML::EmitterStyle::value) override {}
+ void OnSequenceEnd() override {}
+
+ void OnMapStart(const YAML::Mark&, const std::string&, YAML::anchor_t,
+ YAML::EmitterStyle::value) override {}
+ void OnMapEnd() override {}
+};
+
+void parse(std::istream& input) {
+ try {
+ YAML::Node doc = YAML::Load(input);
+ std::cout << doc << "\n";
+ } catch (const YAML::Exception& e) {
+ std::cerr << e.what() << "\n";
+ }
+}
+
+int main(int argc, char** argv) {
+ if (argc > 1) {
+ std::ifstream fin;
+ fin.open(argv[1]);
+ parse(fin);
+ } else {
+ parse(std::cin);
+ }
+
+ return 0;
+}
--- /dev/null
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+
+class NullEventHandler : public YAML::EventHandler {
+ public:
+ using Mark = YAML::Mark;
+ using anchor_t = YAML::anchor_t;
+
+ NullEventHandler() = default;
+
+ void OnDocumentStart(const Mark&) override {}
+ void OnDocumentEnd() override {}
+ void OnNull(const Mark&, anchor_t) override {}
+ void OnAlias(const Mark&, anchor_t) override {}
+ void OnScalar(const Mark&, const std::string&, anchor_t,
+ const std::string&) override {}
+ void OnSequenceStart(const Mark&, const std::string&, anchor_t,
+ YAML::EmitterStyle::value style) override {}
+ void OnSequenceEnd() override {}
+ void OnMapStart(const Mark&, const std::string&, anchor_t,
+ YAML::EmitterStyle::value style) override {}
+ void OnMapEnd() override {}
+};
+
+void run(std::istream& in) {
+ YAML::Parser parser(in);
+ NullEventHandler handler;
+ parser.HandleNextDocument(handler);
+}
+
+void usage() { std::cerr << "Usage: read [-n N] [-c, --cache] [filename]\n"; }
+
+std::string read_stream(std::istream& in) {
+ return std::string((std::istreambuf_iterator<char>(in)),
+ std::istreambuf_iterator<char>());
+}
+
+int main(int argc, char** argv) {
+ int N = 1;
+ bool cache = false;
+ std::string filename;
+ for (int i = 1; i < argc; i++) {
+ std::string arg = argv[i];
+ if (arg == "-n") {
+ i++;
+ if (i >= argc) {
+ usage();
+ return -1;
+ }
+ N = std::atoi(argv[i]);
+ if (N <= 0) {
+ usage();
+ return -1;
+ }
+ } else if (arg == "-c" || arg == "--cache") {
+ cache = true;
+ } else {
+ filename = argv[i];
+ if (i + 1 != argc) {
+ usage();
+ return -1;
+ }
+ }
+ }
+
+ if (N > 1 && !cache && filename.empty()) {
+ usage();
+ return -1;
+ }
+
+ if (cache) {
+ std::string input;
+ if (!filename.empty()) {
+ std::ifstream in(filename);
+ input = read_stream(in);
+ } else {
+ input = read_stream(std::cin);
+ }
+ std::istringstream in(input);
+ for (int i = 0; i < N; i++) {
+ in.seekg(std::ios_base::beg);
+ run(in);
+ }
+ } else {
+ if (!filename.empty()) {
+ std::ifstream in(filename);
+ for (int i = 0; i < N; i++) {
+ in.seekg(std::ios_base::beg);
+ run(in);
+ }
+ } else {
+ for (int i = 0; i < N; i++) {
+ run(std::cin);
+ }
+ }
+ }
+ return 0;
+}
--- /dev/null
+#include <iostream>
+
+#include "yaml-cpp/emitterstyle.h"
+#include "yaml-cpp/eventhandler.h"
+#include "yaml-cpp/yaml.h" // IWYU pragma: keep
+
+class NullEventHandler : public YAML::EventHandler {
+ public:
+ using Mark = YAML::Mark;
+ using anchor_t = YAML::anchor_t;
+
+ NullEventHandler() = default;
+
+ void OnDocumentStart(const Mark&) override {}
+ void OnDocumentEnd() override {}
+ void OnNull(const Mark&, anchor_t) override {}
+ void OnAlias(const Mark&, anchor_t) override {}
+ void OnScalar(const Mark&, const std::string&, anchor_t,
+ const std::string&) override {}
+ void OnSequenceStart(const Mark&, const std::string&, anchor_t,
+ YAML::EmitterStyle::value style) override {}
+ void OnSequenceEnd() override {}
+ void OnMapStart(const Mark&, const std::string&, anchor_t,
+ YAML::EmitterStyle::value style) override {}
+ void OnMapEnd() override {}
+};
+
+int main() {
+ YAML::Node root;
+
+ for (;;) {
+ YAML::Node node;
+ root = node;
+ }
+ return 0;
+}
--- /dev/null
+# - Config file for the yaml-cpp package
+# It defines the following variables
+# YAML_CPP_INCLUDE_DIR - include directory
+# YAML_CPP_LIBRARY_DIR - directory containing libraries
+# YAML_CPP_SHARED_LIBS_BUILT - whether we have built shared libraries or not
+# YAML_CPP_LIBRARIES - libraries to link against
+
+@PACKAGE_INIT@
+
+set_and_check(YAML_CPP_INCLUDE_DIR "@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@")
+set_and_check(YAML_CPP_LIBRARY_DIR "@PACKAGE_CMAKE_INSTALL_LIBDIR@")
+
+# Are we building shared libraries?
+set(YAML_CPP_SHARED_LIBS_BUILT "@PACKAGE_YAML_BUILD_SHARED_LIBS@")
+
+# Our library dependencies (contains definitions for IMPORTED targets)
+include(@PACKAGE_CONFIG_EXPORT_DIR@/yaml-cpp-targets.cmake)
+
+# These are IMPORTED targets created by yaml-cpp-targets.cmake
+set(YAML_CPP_LIBRARIES "@EXPORT_TARGETS@")
+
+check_required_components(@EXPORT_TARGETS@)
--- /dev/null
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=${prefix}
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+
+Name: Yaml-cpp
+Description: A YAML parser and emitter for C++
+Version: @YAML_CPP_VERSION@
+Requires:
+Libs: -L${libdir} -lyaml-cpp
+Cflags: -I${includedir}
projects / yaml-cpp.git / commitdiff