diff --git a/include/yaml-cpp/emitter.h b/include/yaml-cpp/emitter.h index 1d7edf2..43101da 100644 --- a/include/yaml-cpp/emitter.h +++ b/include/yaml-cpp/emitter.h @@ -8,6 +8,7 @@ #include "yaml-cpp/dll.h" #include "yaml-cpp/binary.h" +#include "yaml-cpp/emitterdef.h" #include "yaml-cpp/emittermanip.h" #include "yaml-cpp/ostream.h" #include "yaml-cpp/noncopyable.h" @@ -70,33 +71,45 @@ namespace YAML Emitter& WriteStreamable(T value); private: - void PreWriteIntegralType(std::stringstream& str); - void PreWriteStreamable(std::stringstream& str); - void PostWriteIntegralType(const std::stringstream& str); - void PostWriteStreamable(const std::stringstream& str); - template void SetStreamablePrecision(std::stringstream&) {} unsigned GetFloatPrecision() const; unsigned GetDoublePrecision() const; + + void PrepareIntegralStream(std::stringstream& stream) const; + void StartedScalar(); private: - void PreAtomicWrite(); - bool GotoNextPreAtomicState(); - void PostAtomicWrite(); - void EmitSeparationIfNecessary(); - void EmitBeginDoc(); void EmitEndDoc(); void EmitBeginSeq(); void EmitEndSeq(); void EmitBeginMap(); void EmitEndMap(); - void EmitKey(); - void EmitValue(); 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, unsigned indent); + const char *ComputeFullBoolName(bool b) const; bool CanEmitNewline() const; @@ -111,10 +124,15 @@ namespace YAML if(!good()) return *this; - std::stringstream str; - PreWriteIntegralType(str); - str << value; - PostWriteIntegralType(str); + PrepareNode(EmitterNodeType::Scalar); + + std::stringstream stream; + PrepareIntegralStream(stream); + stream << value; + m_stream << stream.str(); + + StartedScalar(); + return *this; } @@ -124,24 +142,28 @@ namespace YAML if(!good()) return *this; - std::stringstream str; - PreWriteStreamable(str); - SetStreamablePrecision(str); - str << value; - PostWriteStreamable(str); + PrepareNode(EmitterNodeType::Scalar); + + std::stringstream stream; + SetStreamablePrecision(stream); + stream << value; + m_stream << stream.str(); + + StartedScalar(); + return *this; } template<> - inline void Emitter::SetStreamablePrecision(std::stringstream& str) + inline void Emitter::SetStreamablePrecision(std::stringstream& stream) { - str.precision(GetFloatPrecision()); + stream.precision(GetFloatPrecision()); } template<> - inline void Emitter::SetStreamablePrecision(std::stringstream& str) + inline void Emitter::SetStreamablePrecision(std::stringstream& stream) { - str.precision(GetDoublePrecision()); + stream.precision(GetDoublePrecision()); } // overloads of insertion diff --git a/include/yaml-cpp/emitterdef.h b/include/yaml-cpp/emitterdef.h new file mode 100644 index 0000000..c5ca00b --- /dev/null +++ b/include/yaml-cpp/emitterdef.h @@ -0,0 +1,13 @@ +#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 { None, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap }; }; +} + +#endif // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/include/yaml-cpp/exceptions.h b/include/yaml-cpp/exceptions.h index 04babd7..9624303 100644 --- a/include/yaml-cpp/exceptions.h +++ b/include/yaml-cpp/exceptions.h @@ -69,10 +69,6 @@ namespace YAML const char * const INVALID_ANCHOR = "invalid anchor"; const char * const INVALID_ALIAS = "invalid alias"; const char * const INVALID_TAG = "invalid tag"; - const char * const EXPECTED_KEY_TOKEN = "expected key token"; - const char * const EXPECTED_VALUE_TOKEN = "expected value token"; - const char * const UNEXPECTED_KEY_TOKEN = "unexpected key token"; - const char * const UNEXPECTED_VALUE_TOKEN = "unexpected value token"; template inline const std::string KEY_NOT_FOUND_WITH_KEY(const T&, typename disable_if >::type * = 0) { diff --git a/include/yaml-cpp/ostream.h b/include/yaml-cpp/ostream.h index 65839b1..5f11ce6 100644 --- a/include/yaml-cpp/ostream.h +++ b/include/yaml-cpp/ostream.h @@ -18,11 +18,13 @@ namespace YAML void reserve(unsigned size); void put(char ch); + void set_comment() { m_comment = true; } const char *str() const { return m_buffer; } unsigned row() const { return m_row; } unsigned col() const { return m_col; } unsigned pos() const { return m_pos; } + bool comment() const { return m_comment; } private: char *m_buffer; @@ -30,6 +32,7 @@ namespace YAML unsigned m_size; unsigned m_row, m_col; + bool m_comment; }; ostream& operator << (ostream& out, const char *str); diff --git a/src/emitter.cpp b/src/emitter.cpp index 91f48da..ed5993a 100644 --- a/src/emitter.cpp +++ b/src/emitter.cpp @@ -39,69 +39,69 @@ namespace YAML // global setters bool Emitter::SetOutputCharset(EMITTER_MANIP value) { - return m_pState->SetOutputCharset(value, GLOBAL); + return m_pState->SetOutputCharset(value, FmtScope::Global); } bool Emitter::SetStringFormat(EMITTER_MANIP value) { - return m_pState->SetStringFormat(value, GLOBAL); + return m_pState->SetStringFormat(value, FmtScope::Global); } bool Emitter::SetBoolFormat(EMITTER_MANIP value) { bool ok = false; - if(m_pState->SetBoolFormat(value, GLOBAL)) + if(m_pState->SetBoolFormat(value, FmtScope::Global)) ok = true; - if(m_pState->SetBoolCaseFormat(value, GLOBAL)) + if(m_pState->SetBoolCaseFormat(value, FmtScope::Global)) ok = true; - if(m_pState->SetBoolLengthFormat(value, GLOBAL)) + if(m_pState->SetBoolLengthFormat(value, FmtScope::Global)) ok = true; return ok; } bool Emitter::SetIntBase(EMITTER_MANIP value) { - return m_pState->SetIntFormat(value, GLOBAL); + return m_pState->SetIntFormat(value, FmtScope::Global); } bool Emitter::SetSeqFormat(EMITTER_MANIP value) { - return m_pState->SetFlowType(GT_SEQ, value, GLOBAL); + return m_pState->SetFlowType(GroupType::Seq, value, FmtScope::Global); } bool Emitter::SetMapFormat(EMITTER_MANIP value) { bool ok = false; - if(m_pState->SetFlowType(GT_MAP, value, GLOBAL)) + if(m_pState->SetFlowType(GroupType::Map, value, FmtScope::Global)) ok = true; - if(m_pState->SetMapKeyFormat(value, GLOBAL)) + if(m_pState->SetMapKeyFormat(value, FmtScope::Global)) ok = true; return ok; } bool Emitter::SetIndent(unsigned n) { - return m_pState->SetIndent(n, GLOBAL); + return m_pState->SetIndent(n, FmtScope::Global); } bool Emitter::SetPreCommentIndent(unsigned n) { - return m_pState->SetPreCommentIndent(n, GLOBAL); + return m_pState->SetPreCommentIndent(n, FmtScope::Global); } bool Emitter::SetPostCommentIndent(unsigned n) { - return m_pState->SetPostCommentIndent(n, GLOBAL); + return m_pState->SetPostCommentIndent(n, FmtScope::Global); } bool Emitter::SetFloatPrecision(unsigned n) { - return m_pState->SetFloatPrecision(n, GLOBAL); + return m_pState->SetFloatPrecision(n, FmtScope::Global); } bool Emitter::SetDoublePrecision(unsigned n) { - return m_pState->SetDoublePrecision(n, GLOBAL); + return m_pState->SetDoublePrecision(n, FmtScope::Global); } // SetLocalValue @@ -131,10 +131,8 @@ namespace YAML EmitEndMap(); break; case Key: - EmitKey(); - break; case Value: - EmitValue(); + // deprecated (these can be deduced by the parity of nodes in a map) break; case TagByKind: EmitKindTag(); @@ -151,220 +149,40 @@ namespace YAML Emitter& Emitter::SetLocalIndent(const _Indent& indent) { - m_pState->SetIndent(indent.value, LOCAL); + m_pState->SetIndent(indent.value, FmtScope::Local); return *this; } Emitter& Emitter::SetLocalPrecision(const _Precision& precision) { if(precision.floatPrecision >= 0) - m_pState->SetFloatPrecision(precision.floatPrecision, LOCAL); + m_pState->SetFloatPrecision(precision.floatPrecision, FmtScope::Local); if(precision.doublePrecision >= 0) - m_pState->SetDoublePrecision(precision.doublePrecision, LOCAL); + m_pState->SetDoublePrecision(precision.doublePrecision, FmtScope::Local); return *this; } - // GotoNextPreAtomicState - // . Runs the state machine, emitting if necessary, and returns 'true' if done (i.e., ready to emit an atom) - bool Emitter::GotoNextPreAtomicState() - { - if(!good()) - return true; - - unsigned curIndent = m_pState->GetCurIndent(); - - EMITTER_STATE curState = m_pState->GetCurState(); - switch(curState) { - // document-level - case ES_WAITING_FOR_DOC: - m_pState->SwitchState(ES_WRITING_DOC); - return true; - case ES_WRITING_DOC: - return true; - case ES_DONE_WITH_DOC: - EmitBeginDoc(); - return false; - - // block sequence - case ES_WAITING_FOR_BLOCK_SEQ_ENTRY: - m_stream << IndentTo(curIndent) << "-"; - m_pState->RequireSoftSeparation(); - m_pState->SwitchState(ES_WRITING_BLOCK_SEQ_ENTRY); - return true; - case ES_WRITING_BLOCK_SEQ_ENTRY: - return true; - case ES_DONE_WITH_BLOCK_SEQ_ENTRY: - m_stream << '\n'; - m_pState->SwitchState(ES_WAITING_FOR_BLOCK_SEQ_ENTRY); - return false; - - // flow sequence - case ES_WAITING_FOR_FLOW_SEQ_ENTRY: - m_pState->SwitchState(ES_WRITING_FLOW_SEQ_ENTRY); - return true; - case ES_WRITING_FLOW_SEQ_ENTRY: - return true; - case ES_DONE_WITH_FLOW_SEQ_ENTRY: - EmitSeparationIfNecessary(); - m_stream << ','; - m_pState->RequireSoftSeparation(); - m_pState->SwitchState(ES_WAITING_FOR_FLOW_SEQ_ENTRY); - return false; - - // block map - case ES_WAITING_FOR_BLOCK_MAP_ENTRY: - m_pState->SetError(ErrorMsg::EXPECTED_KEY_TOKEN); - return true; - case ES_WAITING_FOR_BLOCK_MAP_KEY: - if(m_pState->CurrentlyInLongKey()) { - m_stream << IndentTo(curIndent) << '?'; - m_pState->RequireSoftSeparation(); - } - m_pState->SwitchState(ES_WRITING_BLOCK_MAP_KEY); - return true; - case ES_WRITING_BLOCK_MAP_KEY: - return true; - case ES_DONE_WITH_BLOCK_MAP_KEY: - m_pState->SetError(ErrorMsg::EXPECTED_VALUE_TOKEN); - return true; - case ES_WAITING_FOR_BLOCK_MAP_VALUE: - m_pState->SwitchState(ES_WRITING_BLOCK_MAP_VALUE); - return true; - case ES_WRITING_BLOCK_MAP_VALUE: - return true; - case ES_DONE_WITH_BLOCK_MAP_VALUE: - m_pState->SetError(ErrorMsg::EXPECTED_KEY_TOKEN); - return true; - - // flow map - case ES_WAITING_FOR_FLOW_MAP_ENTRY: - m_pState->SetError(ErrorMsg::EXPECTED_KEY_TOKEN); - return true; - case ES_WAITING_FOR_FLOW_MAP_KEY: - EmitSeparationIfNecessary(); - m_pState->SwitchState(ES_WRITING_FLOW_MAP_KEY); - if(m_pState->CurrentlyInLongKey()) { - m_stream << '?'; - m_pState->RequireSoftSeparation(); - } - return true; - case ES_WRITING_FLOW_MAP_KEY: - return true; - case ES_DONE_WITH_FLOW_MAP_KEY: - m_pState->SetError(ErrorMsg::EXPECTED_VALUE_TOKEN); - return true; - case ES_WAITING_FOR_FLOW_MAP_VALUE: - EmitSeparationIfNecessary(); - m_stream << ':'; - m_pState->RequireSoftSeparation(); - m_pState->SwitchState(ES_WRITING_FLOW_MAP_VALUE); - return true; - case ES_WRITING_FLOW_MAP_VALUE: - return true; - case ES_DONE_WITH_FLOW_MAP_VALUE: - m_pState->SetError(ErrorMsg::EXPECTED_KEY_TOKEN); - return true; - default: - assert(false); - } - - assert(false); - return true; - } - - // PreAtomicWrite - // . Depending on the emitter state, write to the stream to get it - // in position to do an atomic write (e.g., scalar, sequence, or map) - void Emitter::PreAtomicWrite() - { - if(!good()) - return; - - while(!GotoNextPreAtomicState()) - ; - } - - // PostAtomicWrite - // . Clean up - void Emitter::PostAtomicWrite() - { - if(!good()) - return; - - EMITTER_STATE curState = m_pState->GetCurState(); - switch(curState) { - // document-level - case ES_WRITING_DOC: - m_pState->SwitchState(ES_DONE_WITH_DOC); - break; - - // block seq - case ES_WRITING_BLOCK_SEQ_ENTRY: - m_pState->SwitchState(ES_DONE_WITH_BLOCK_SEQ_ENTRY); - break; - - // flow seq - case ES_WRITING_FLOW_SEQ_ENTRY: - m_pState->SwitchState(ES_DONE_WITH_FLOW_SEQ_ENTRY); - break; - - // block map - case ES_WRITING_BLOCK_MAP_KEY: - if(!m_pState->CurrentlyInLongKey()) { - m_stream << ':'; - m_pState->RequireSoftSeparation(); - } - m_pState->SwitchState(ES_DONE_WITH_BLOCK_MAP_KEY); - break; - case ES_WRITING_BLOCK_MAP_VALUE: - m_pState->SwitchState(ES_DONE_WITH_BLOCK_MAP_VALUE); - break; - - // flow map - case ES_WRITING_FLOW_MAP_KEY: - m_pState->SwitchState(ES_DONE_WITH_FLOW_MAP_KEY); - break; - case ES_WRITING_FLOW_MAP_VALUE: - m_pState->SwitchState(ES_DONE_WITH_FLOW_MAP_VALUE); - break; - default: - assert(false); - }; - - m_pState->ClearModifiedSettings(); - } - - // EmitSeparationIfNecessary - void Emitter::EmitSeparationIfNecessary() - { - if(!good()) - return; - - if(m_pState->RequiresSoftSeparation()) - m_stream << ' '; - else if(m_pState->RequiresHardSeparation()) - m_stream << '\n'; - m_pState->UnsetSeparation(); - } - // EmitBeginDoc void Emitter::EmitBeginDoc() { if(!good()) return; - - EMITTER_STATE curState = m_pState->GetCurState(); - if(curState != ES_WAITING_FOR_DOC && curState != ES_WRITING_DOC && curState != ES_DONE_WITH_DOC) { + + if(m_pState->CurGroupType() != GroupType::None) { m_pState->SetError("Unexpected begin document"); return; - } - - if(curState == ES_WRITING_DOC || curState == ES_DONE_WITH_DOC) - m_stream << '\n'; - m_stream << "---\n"; - - m_pState->UnsetSeparation(); - m_pState->SwitchState(ES_WAITING_FOR_DOC); + } + + 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 @@ -372,20 +190,20 @@ namespace YAML { if(!good()) return; - - - EMITTER_STATE curState = m_pState->GetCurState(); - if(curState != ES_WAITING_FOR_DOC && curState != ES_WRITING_DOC && curState != ES_DONE_WITH_DOC) { - m_pState->SetError("Unexpected end document"); + + if(m_pState->CurGroupType() != GroupType::None) { + m_pState->SetError("Unexpected begin document"); return; - } - - if(curState == ES_WRITING_DOC || curState == ES_DONE_WITH_DOC) - m_stream << '\n'; - m_stream << "...\n"; - - m_pState->UnsetSeparation(); - m_pState->SwitchState(ES_WAITING_FOR_DOC); + } + + 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 @@ -393,33 +211,10 @@ namespace YAML { if(!good()) return; - - // must have a long key if we're emitting a sequence - m_pState->StartLongKey(); - - PreAtomicWrite(); - - EMITTER_STATE curState = m_pState->GetCurState(); - EMITTER_MANIP flowType = m_pState->GetFlowType(GT_SEQ); - if(flowType == Block) { - if(curState == ES_WRITING_BLOCK_SEQ_ENTRY || - curState == ES_WRITING_BLOCK_MAP_KEY || curState == ES_WRITING_BLOCK_MAP_VALUE || - curState == ES_WRITING_DOC - ) { - if(m_pState->RequiresHardSeparation() || curState != ES_WRITING_DOC) { - m_stream << "\n"; - m_pState->UnsetSeparation(); - } - } - m_pState->PushState(ES_WAITING_FOR_BLOCK_SEQ_ENTRY); - } else if(flowType == Flow) { - EmitSeparationIfNecessary(); - m_stream << "["; - m_pState->PushState(ES_WAITING_FOR_FLOW_SEQ_ENTRY); - } else - assert(false); - - m_pState->BeginGroup(GT_SEQ); + + PrepareNode(m_pState->NextGroupType(GroupType::Seq)); + + m_pState->StartedGroup(GroupType::Seq); } // EmitEndSeq @@ -427,35 +222,20 @@ namespace YAML { if(!good()) return; - - if(m_pState->GetCurGroupType() != GT_SEQ) - return m_pState->SetError(ErrorMsg::UNEXPECTED_END_SEQ); - - EMITTER_STATE curState = m_pState->GetCurState(); - FLOW_TYPE flowType = m_pState->GetCurGroupFlowType(); - if(flowType == FT_BLOCK) { - // Note: block sequences are *not* allowed to be empty, but we convert it - // to a flow sequence if it is - assert(curState == ES_DONE_WITH_BLOCK_SEQ_ENTRY || curState == ES_WAITING_FOR_BLOCK_SEQ_ENTRY); - if(curState == ES_WAITING_FOR_BLOCK_SEQ_ENTRY) { - // Note: only one of these will actually output anything for a given situation - EmitSeparationIfNecessary(); - unsigned curIndent = m_pState->GetCurIndent(); - m_stream << IndentTo(curIndent); - - m_stream << "[]"; - } - } else if(flowType == FT_FLOW) { - // Note: flow sequences are allowed to be empty - assert(curState == ES_DONE_WITH_FLOW_SEQ_ENTRY || curState == ES_WAITING_FOR_FLOW_SEQ_ENTRY); - m_stream << "]"; - } else - assert(false); - - m_pState->PopState(); - m_pState->EndGroup(GT_SEQ); - - PostAtomicWrite(); + + 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(m_pState->CurGroupChildCount() == 0) + m_stream << "["; + m_stream << "]"; + } + + m_pState->EndedGroup(GroupType::Seq); } // EmitBeginMap @@ -463,33 +243,10 @@ namespace YAML { if(!good()) return; - - // must have a long key if we're emitting a map - m_pState->StartLongKey(); - PreAtomicWrite(); - - EMITTER_STATE curState = m_pState->GetCurState(); - EMITTER_MANIP flowType = m_pState->GetFlowType(GT_MAP); - if(flowType == Block) { - if(curState == ES_WRITING_BLOCK_SEQ_ENTRY || - curState == ES_WRITING_BLOCK_MAP_KEY || curState == ES_WRITING_BLOCK_MAP_VALUE || - curState == ES_WRITING_DOC - ) { - if(m_pState->RequiresHardSeparation() || (curState != ES_WRITING_DOC && curState != ES_WRITING_BLOCK_SEQ_ENTRY)) { - m_stream << "\n"; - m_pState->UnsetSeparation(); - } - } - m_pState->PushState(ES_WAITING_FOR_BLOCK_MAP_ENTRY); - } else if(flowType == Flow) { - EmitSeparationIfNecessary(); - m_stream << "{"; - m_pState->PushState(ES_WAITING_FOR_FLOW_MAP_ENTRY); - } else - assert(false); - - m_pState->BeginGroup(GT_MAP); + PrepareNode(m_pState->NextGroupType(GroupType::Map)); + + m_pState->StartedGroup(GroupType::Map); } // EmitEndMap @@ -497,121 +254,462 @@ namespace YAML { if(!good()) return; - - if(m_pState->GetCurGroupType() != GT_MAP) - return m_pState->SetError(ErrorMsg::UNEXPECTED_END_MAP); - EMITTER_STATE curState = m_pState->GetCurState(); - FLOW_TYPE flowType = m_pState->GetCurGroupFlowType(); - if(flowType == FT_BLOCK) { - // Note: block sequences are *not* allowed to be empty, but we convert it - // to a flow sequence if it is - assert(curState == ES_DONE_WITH_BLOCK_MAP_VALUE || curState == ES_WAITING_FOR_BLOCK_MAP_ENTRY); - if(curState == ES_WAITING_FOR_BLOCK_MAP_ENTRY) { - // Note: only one of these will actually output anything for a given situation - EmitSeparationIfNecessary(); - unsigned curIndent = m_pState->GetCurIndent(); - m_stream << IndentTo(curIndent); - m_stream << "{}"; - } - } else if(flowType == FT_FLOW) { - // Note: flow maps are allowed to be empty - assert(curState == ES_DONE_WITH_FLOW_MAP_VALUE || curState == ES_WAITING_FOR_FLOW_MAP_ENTRY); - EmitSeparationIfNecessary(); - m_stream << "}"; - } else - assert(false); - - m_pState->PopState(); - m_pState->EndGroup(GT_MAP); - - PostAtomicWrite(); - } - - // EmitKey - void Emitter::EmitKey() - { - if(!good()) - return; - - EMITTER_STATE curState = m_pState->GetCurState(); - FLOW_TYPE flowType = m_pState->GetCurGroupFlowType(); - if(curState != ES_WAITING_FOR_BLOCK_MAP_ENTRY && curState != ES_DONE_WITH_BLOCK_MAP_VALUE - && curState != ES_WAITING_FOR_FLOW_MAP_ENTRY && curState != ES_DONE_WITH_FLOW_MAP_VALUE) - return m_pState->SetError(ErrorMsg::UNEXPECTED_KEY_TOKEN); + 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(m_pState->CurGroupChildCount() == 0) + m_stream << "{"; + m_stream << "}"; + } - if(flowType == FT_BLOCK) { - if(curState == ES_DONE_WITH_BLOCK_MAP_VALUE) - m_stream << '\n'; - unsigned curIndent = m_pState->GetCurIndent(); - m_stream << IndentTo(curIndent); - m_pState->UnsetSeparation(); - m_pState->SwitchState(ES_WAITING_FOR_BLOCK_MAP_KEY); - } else if(flowType == FT_FLOW) { - EmitSeparationIfNecessary(); - if(curState == ES_DONE_WITH_FLOW_MAP_VALUE) { - m_stream << ','; - m_pState->RequireSoftSeparation(); - } - m_pState->SwitchState(ES_WAITING_FOR_FLOW_MAP_KEY); - } else - assert(false); - - if(m_pState->GetMapKeyFormat() == LongKey) - m_pState->StartLongKey(); - else if(m_pState->GetMapKeyFormat() == Auto) - m_pState->StartSimpleKey(); - else - assert(false); - } - - // EmitValue - void Emitter::EmitValue() - { - if(!good()) - return; - - EMITTER_STATE curState = m_pState->GetCurState(); - FLOW_TYPE flowType = m_pState->GetCurGroupFlowType(); - if(curState != ES_DONE_WITH_BLOCK_MAP_KEY && curState != ES_DONE_WITH_FLOW_MAP_KEY) - return m_pState->SetError(ErrorMsg::UNEXPECTED_VALUE_TOKEN); - - if(flowType == FT_BLOCK) { - if(m_pState->CurrentlyInLongKey()) { - m_stream << '\n'; - m_stream << IndentTo(m_pState->GetCurIndent()); - m_stream << ':'; - m_pState->RequireSoftSeparation(); - } - m_pState->SwitchState(ES_WAITING_FOR_BLOCK_MAP_VALUE); - } else if(flowType == FT_FLOW) { - m_pState->SwitchState(ES_WAITING_FOR_FLOW_MAP_VALUE); - } else - assert(false); - } + m_pState->EndedGroup(GroupType::Map); + } // EmitNewline void Emitter::EmitNewline() { if(!good()) return; - - if(CanEmitNewline()) { - m_stream << '\n'; - m_pState->UnsetSeparation(); - } + + PrepareNode(EmitterNodeType::None); + m_stream << "\n"; + m_pState->SetNonContent(); } bool Emitter::CanEmitNewline() const { - FLOW_TYPE flowType = m_pState->GetCurGroupFlowType(); - if(flowType == FT_BLOCK && m_pState->CurrentlyInLongKey()) - return true; - - EMITTER_STATE curState = m_pState->GetCurState(); - return curState != ES_DONE_WITH_BLOCK_MAP_KEY && curState != ES_WAITING_FOR_BLOCK_MAP_VALUE && curState != ES_WRITING_BLOCK_MAP_VALUE; + 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::None: + 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::None) + return; + + if(m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0) { + if(child != EmitterNodeType::None) + EmitBeginDoc(); + } + + switch(child) { + case EmitterNodeType::None: + 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 unsigned 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::None: + 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 unsigned curIndent = m_pState->CurIndent(); + const unsigned nextIndent = curIndent + m_pState->CurGroupIndent(); + + if(child == EmitterNodeType::None) + 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::None: + 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 unsigned 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::None: + 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 unsigned 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::None: + 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 unsigned 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::None: + 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 unsigned 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::None: + 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) + 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 unsigned curIndent = m_pState->CurIndent(); + const std::size_t childCount = m_pState->CurGroupChildCount(); + + if(child == EmitterNodeType::None) + 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::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(true, curIndent + 1); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + break; + } + } + + void Emitter::BlockMapPrepareLongKeyValue(EmitterNodeType::value child) + { + const unsigned curIndent = m_pState->CurIndent(); + + if(child == EmitterNodeType::None) + return; + + if(!m_pState->HasBegunContent()) { + m_stream << "\n"; + m_stream << IndentTo(curIndent); + m_stream << ":"; + } + + switch(child) { + case EmitterNodeType::None: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + SpaceOrIndentTo(true, curIndent + 1); + break; + } + } + + void Emitter::BlockMapPrepareSimpleKey(EmitterNodeType::value child) + { + const unsigned curIndent = m_pState->CurIndent(); + const std::size_t childCount = m_pState->CurGroupChildCount(); + + if(child == EmitterNodeType::None) + return; + + if(!m_pState->HasBegunNode()) { + if(childCount > 0) { + m_stream << "\n"; + } + } + + switch(child) { + case EmitterNodeType::None: + 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 unsigned curIndent = m_pState->CurIndent(); + const unsigned nextIndent = curIndent + m_pState->CurGroupIndent(); + + if(!m_pState->HasBegunNode()) { + m_stream << ":"; + } + + switch(child) { + case EmitterNodeType::None: + 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, unsigned 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 @@ -619,75 +717,35 @@ namespace YAML { if(!good()) return *this; - - // literal scalars must use long keys - if(m_pState->GetStringFormat() == Literal && m_pState->GetCurGroupFlowType() != FT_FLOW) - m_pState->StartLongKey(); - - PreAtomicWrite(); - EmitSeparationIfNecessary(); - - bool escapeNonAscii = m_pState->GetOutputCharset() == EscapeNonAscii; - EMITTER_MANIP strFmt = m_pState->GetStringFormat(); - FLOW_TYPE flowType = m_pState->GetCurGroupFlowType(); - unsigned curIndent = m_pState->GetCurIndent(); + + const bool escapeNonAscii = m_pState->GetOutputCharset() == EscapeNonAscii; + const StringFormat::value strFormat = Utils::ComputeStringFormat(str, m_pState->GetStringFormat(), m_pState->CurGroupFlowType(), escapeNonAscii); + + if(strFormat == StringFormat::Literal) + 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, escapeNonAscii); + break; + case StringFormat::Literal: + Utils::WriteLiteralString(m_stream, str, m_pState->CurIndent() + m_pState->GetIndent()); + break; + } - switch(strFmt) { - case Auto: - Utils::WriteString(m_stream, str, flowType == FT_FLOW, escapeNonAscii); - break; - case SingleQuoted: - if(!Utils::WriteSingleQuotedString(m_stream, str)) { - m_pState->SetError(ErrorMsg::SINGLE_QUOTED_CHAR); - return *this; - } - break; - case DoubleQuoted: - Utils::WriteDoubleQuotedString(m_stream, str, escapeNonAscii); - break; - case Literal: - if(flowType == FT_FLOW) - Utils::WriteString(m_stream, str, flowType == FT_FLOW, escapeNonAscii); - else - Utils::WriteLiteralString(m_stream, str, curIndent + m_pState->GetIndent()); - break; - default: - assert(false); - } - - PostAtomicWrite(); + StartedScalar(); + return *this; } - void Emitter::PreWriteIntegralType(std::stringstream& str) - { - PreAtomicWrite(); - EmitSeparationIfNecessary(); - - EMITTER_MANIP intFmt = m_pState->GetIntFormat(); - switch(intFmt) { - case Dec: - str << std::dec; - break; - case Hex: - str << "0x"; - str << std::hex; - break; - case Oct: - str << "0"; - str << std::oct; - break; - default: - assert(false); - } - } - - void Emitter::PreWriteStreamable(std::stringstream&) - { - PreAtomicWrite(); - EmitSeparationIfNecessary(); - } - unsigned Emitter::GetFloatPrecision() const { return m_pState->GetFloatPrecision(); @@ -698,18 +756,6 @@ namespace YAML return m_pState->GetDoublePrecision(); } - void Emitter::PostWriteIntegralType(const std::stringstream& str) - { - m_stream << str.str(); - PostAtomicWrite(); - } - - void Emitter::PostWriteStreamable(const std::stringstream& str) - { - m_stream << str.str(); - PostAtomicWrite(); - } - const char *Emitter::ComputeFullBoolName(bool b) const { const EMITTER_MANIP mainFmt = (m_pState->GetBoolLengthFormat() == ShortBool ? YesNoBool : m_pState->GetBoolFormat()); @@ -749,17 +795,17 @@ namespace YAML { if(!good()) return *this; - - PreAtomicWrite(); - EmitSeparationIfNecessary(); - + + PrepareNode(EmitterNodeType::Scalar); + const char *name = ComputeFullBoolName(b); if(m_pState->GetBoolLengthFormat() == ShortBool) m_stream << name[0]; else m_stream << name; - PostAtomicWrite(); + StartedScalar(); + return *this; } @@ -767,13 +813,11 @@ namespace YAML { if(!good()) return *this; - - PreAtomicWrite(); - EmitSeparationIfNecessary(); - - Utils::WriteChar(m_stream, ch); - - PostAtomicWrite(); + + PrepareNode(EmitterNodeType::Scalar); + Utils::WriteChar(m_stream, ch); + StartedScalar(); + return *this; } @@ -781,14 +825,21 @@ namespace YAML { if(!good()) return *this; - - PreAtomicWrite(); - EmitSeparationIfNecessary(); + + 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; } - PostAtomicWrite(); + + StartedScalar(); + return *this; } @@ -796,15 +847,21 @@ namespace YAML { if(!good()) return *this; - - PreAtomicWrite(); - EmitSeparationIfNecessary(); + + 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->RequireHardSeparation(); - // Note: no PostAtomicWrite() because we need another value for this node + + m_pState->SetAnchor(); + return *this; } @@ -812,10 +869,14 @@ namespace YAML { if(!good()) return *this; - - PreAtomicWrite(); - EmitSeparationIfNecessary(); - + + 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); @@ -828,9 +889,9 @@ namespace YAML m_pState->SetError(ErrorMsg::INVALID_TAG); return *this; } - - m_pState->RequireHardSeparation(); - // Note: no PostAtomicWrite() because we need another value for this node + + m_pState->SetTag(); + return *this; } @@ -843,13 +904,15 @@ namespace YAML { if(!good()) return *this; - + + PrepareNode(EmitterNodeType::None); + if(m_stream.col() > 0) m_stream << Indentation(m_pState->GetPreCommentIndent()); Utils::WriteComment(m_stream, comment.content, m_pState->GetPostCommentIndent()); - m_pState->RequireHardSeparation(); - m_pState->ForceHardSeparation(); - + + m_pState->SetNonContent(); + return *this; } @@ -857,11 +920,13 @@ namespace YAML { if(!good()) return *this; - - PreAtomicWrite(); - EmitSeparationIfNecessary(); - m_stream << "~"; - PostAtomicWrite(); + + PrepareNode(EmitterNodeType::Scalar); + + m_stream << "~"; + + StartedScalar(); + return *this; } @@ -871,11 +936,11 @@ namespace YAML if(!good()) return *this; - - PreAtomicWrite(); - EmitSeparationIfNecessary(); + + PrepareNode(EmitterNodeType::Scalar); Utils::WriteBinary(m_stream, binary); - PostAtomicWrite(); + StartedScalar(); + return *this; } } diff --git a/src/emitterstate.cpp b/src/emitterstate.cpp index 562e82c..08d2c15 100644 --- a/src/emitterstate.cpp +++ b/src/emitterstate.cpp @@ -4,11 +4,8 @@ namespace YAML { - EmitterState::EmitterState(): m_isGood(true), m_curIndent(0), m_requiresSoftSeparation(false), m_requiresHardSeparation(false) + EmitterState::EmitterState(): m_isGood(true), m_curIndent(0), m_hasAnchor(false), m_hasTag(false), m_hasNonContent(false), m_docCount(0) { - // start up - m_stateStack.push(ES_WAITING_FOR_DOC); - // set default global manipulators m_charset.set(EmitNonAscii); m_strFmt.set(Auto); @@ -35,21 +32,111 @@ namespace YAML // . Only the ones that make sense will be accepted void EmitterState::SetLocalValue(EMITTER_MANIP value) { - SetOutputCharset(value, LOCAL); - SetStringFormat(value, LOCAL); - SetBoolFormat(value, LOCAL); - SetBoolCaseFormat(value, LOCAL); - SetBoolLengthFormat(value, LOCAL); - SetIntFormat(value, LOCAL); - SetFlowType(GT_SEQ, value, LOCAL); - SetFlowType(GT_MAP, value, LOCAL); - SetMapKeyFormat(value, LOCAL); + SetOutputCharset(value, FmtScope::Local); + SetStringFormat(value, FmtScope::Local); + SetBoolFormat(value, FmtScope::Local); + SetBoolCaseFormat(value, FmtScope::Local); + SetBoolLengthFormat(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::BeginGroup(GROUP_TYPE type) + void EmitterState::SetAnchor() + { + m_hasAnchor = 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.top().type == GroupType::Map); + m_groups.top().longKey = true; + } + + void EmitterState::ForceFlow() + { + assert(!m_groups.empty()); + if(m_groups.empty()) + return; + + m_groups.top().flowType = FlowType::Flow; + } + + void EmitterState::StartedNode() + { + if(m_groups.empty()) { + m_docCount++; + } else { + m_groups.top().childCount++; + if(m_groups.top().childCount % 2 == 0) + m_groups.top().longKey = false; + } + + m_hasAnchor = 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; + else + return EmitterNodeType::FlowSeq; + } else { + if(GetFlowType(type) == Block) + return EmitterNodeType::BlockMap; + else + return EmitterNodeType::FlowMap; + } + + // can't happen + assert(false); + return EmitterNodeType::None; + } + + 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) { - unsigned lastIndent = (m_groups.empty() ? 0 : m_groups.top().indent); - m_curIndent += lastIndent; + StartedNode(); + + const int lastGroupIndent = (m_groups.empty() ? 0 : m_groups.top().indent); + m_curIndent += lastGroupIndent; std::auto_ptr pGroup(new Group(type)); @@ -57,17 +144,23 @@ namespace YAML pGroup->modifiedSettings = m_modifiedSettings; // set up group - pGroup->flow = GetFlowType(type); + if(GetFlowType(type) == Block) + pGroup->flowType = FlowType::Block; + else + pGroup->flowType = FlowType::Flow; pGroup->indent = GetIndent(); - pGroup->usingLongKey = (GetMapKeyFormat() == LongKey ? true : false); m_groups.push(pGroup); } - void EmitterState::EndGroup(GROUP_TYPE type) + void EmitterState::EndedGroup(GroupType::value type) { - if(m_groups.empty()) - return SetError(ErrorMsg::UNMATCHED_GROUP_TAG); + if(m_groups.empty()) { + if(type == GroupType::Seq) + return SetError(ErrorMsg::UNEXPECTED_END_SEQ); + else + return SetError(ErrorMsg::UNEXPECTED_END_MAP); + } // get rid of the current group { @@ -84,49 +177,57 @@ namespace YAML // 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(); } - - GROUP_TYPE EmitterState::GetCurGroupType() const + + EmitterNodeType::value EmitterState::CurGroupNodeType() const + { + if(m_groups.empty()) + return EmitterNodeType::None; + + return m_groups.top().NodeType(); + } + + GroupType::value EmitterState::CurGroupType() const { - if(m_groups.empty()) - return GT_NONE; - - return m_groups.top().type; + return m_groups.empty() ? GroupType::None : m_groups.top().type; } - FLOW_TYPE EmitterState::GetCurGroupFlowType() const + FlowType::value EmitterState::CurGroupFlowType() const { - if(m_groups.empty()) - return FT_NONE; - - return (m_groups.top().flow == Flow ? FT_FLOW : FT_BLOCK); - } - - bool EmitterState::CurrentlyInLongKey() - { - if(m_groups.empty()) - return false; - return m_groups.top().usingLongKey; - } - - void EmitterState::StartLongKey() - { - if(!m_groups.empty()) - m_groups.top().usingLongKey = true; - } - - void EmitterState::StartSimpleKey() - { - if(!m_groups.empty()) - m_groups.top().usingLongKey = false; + return m_groups.empty() ? FlowType::None : m_groups.top().flowType; } + int EmitterState::CurGroupIndent() const + { + return m_groups.empty() ? 0 : m_groups.top().indent; + } + + std::size_t EmitterState::CurGroupChildCount() const + { + return m_groups.empty() ? m_docCount : m_groups.top().childCount; + } + + bool EmitterState::CurGroupLongKey() const + { + return m_groups.empty() ? false : m_groups.top().longKey; + } + + int EmitterState::LastIndent() const + { + if(m_groups.size() <= 1) + return 0; + + return m_curIndent - m_groups.top(-1).indent; + } + void EmitterState::ClearModifiedSettings() { m_modifiedSettings.clear(); } - bool EmitterState::SetOutputCharset(EMITTER_MANIP value, FMT_SCOPE scope) + bool EmitterState::SetOutputCharset(EMITTER_MANIP value, FmtScope::value scope) { switch(value) { case EmitNonAscii: @@ -138,7 +239,7 @@ namespace YAML } } - bool EmitterState::SetStringFormat(EMITTER_MANIP value, FMT_SCOPE scope) + bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScope::value scope) { switch(value) { case Auto: @@ -152,7 +253,7 @@ namespace YAML } } - bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FMT_SCOPE scope) + bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope) { switch(value) { case OnOffBool: @@ -165,7 +266,7 @@ namespace YAML } } - bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value, FMT_SCOPE scope) + bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope) { switch(value) { case LongBool: @@ -177,7 +278,7 @@ namespace YAML } } - bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value, FMT_SCOPE scope) + bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope) { switch(value) { case UpperCase: @@ -190,7 +291,7 @@ namespace YAML } } - bool EmitterState::SetIntFormat(EMITTER_MANIP value, FMT_SCOPE scope) + bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope::value scope) { switch(value) { case Dec: @@ -203,16 +304,16 @@ namespace YAML } } - bool EmitterState::SetIndent(unsigned value, FMT_SCOPE scope) + bool EmitterState::SetIndent(unsigned value, FmtScope::value scope) { - if(value == 0) + if(value <= 1) return false; _Set(m_indent, value, scope); return true; } - bool EmitterState::SetPreCommentIndent(unsigned value, FMT_SCOPE scope) + bool EmitterState::SetPreCommentIndent(unsigned value, FmtScope::value scope) { if(value == 0) return false; @@ -221,7 +322,7 @@ namespace YAML return true; } - bool EmitterState::SetPostCommentIndent(unsigned value, FMT_SCOPE scope) + bool EmitterState::SetPostCommentIndent(unsigned value, FmtScope::value scope) { if(value == 0) return false; @@ -230,30 +331,29 @@ namespace YAML return true; } - bool EmitterState::SetFlowType(GROUP_TYPE groupType, EMITTER_MANIP value, FMT_SCOPE scope) + bool EmitterState::SetFlowType(GroupType::value groupType, EMITTER_MANIP value, FmtScope::value scope) { switch(value) { case Block: case Flow: - _Set(groupType == GT_SEQ ? m_seqFmt : m_mapFmt, value, scope); + _Set(groupType == GroupType::Seq ? m_seqFmt : m_mapFmt, value, scope); return true; default: return false; } } - EMITTER_MANIP EmitterState::GetFlowType(GROUP_TYPE groupType) const + EMITTER_MANIP EmitterState::GetFlowType(GroupType::value groupType) const { // force flow style if we're currently in a flow - FLOW_TYPE flowType = GetCurGroupFlowType(); - if(flowType == FT_FLOW) + if(CurGroupFlowType() == FlowType::Flow) return Flow; - // otherwise, go with what's asked of use - return (groupType == GT_SEQ ? m_seqFmt.get() : m_mapFmt.get()); + // otherwise, go with what's asked of us + return (groupType == GroupType::Seq ? m_seqFmt.get() : m_mapFmt.get()); } - bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FMT_SCOPE scope) + bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope) { switch(value) { case Auto: @@ -265,7 +365,7 @@ namespace YAML } } - bool EmitterState::SetFloatPrecision(int value, FMT_SCOPE scope) + bool EmitterState::SetFloatPrecision(int value, FmtScope::value scope) { if(value < 0 || value > std::numeric_limits::digits10) return false; @@ -273,7 +373,7 @@ namespace YAML return true; } - bool EmitterState::SetDoublePrecision(int value, FMT_SCOPE scope) + bool EmitterState::SetDoublePrecision(int value, FmtScope::value scope) { if(value < 0 || value > std::numeric_limits::digits10) return false; diff --git a/src/emitterstate.h b/src/emitterstate.h index 5698e32..f43f471 100644 --- a/src/emitterstate.h +++ b/src/emitterstate.h @@ -8,71 +8,20 @@ #include "ptr_stack.h" #include "setting.h" +#include "yaml-cpp/emitterdef.h" #include "yaml-cpp/emittermanip.h" #include #include #include #include +#include namespace YAML { - enum FMT_SCOPE { - LOCAL, - GLOBAL - }; - - enum GROUP_TYPE { - GT_NONE, - GT_SEQ, - GT_MAP - }; - - enum FLOW_TYPE { - FT_NONE, - FT_FLOW, - FT_BLOCK - }; - - enum NODE_STATE { - NS_START, - NS_READY_FOR_ATOM, - NS_END - }; - - enum EMITTER_STATE { - ES_WAITING_FOR_DOC, - ES_WRITING_DOC, - ES_DONE_WITH_DOC, - - // block seq - ES_WAITING_FOR_BLOCK_SEQ_ENTRY, - ES_WRITING_BLOCK_SEQ_ENTRY, - ES_DONE_WITH_BLOCK_SEQ_ENTRY, - - // flow seq - ES_WAITING_FOR_FLOW_SEQ_ENTRY, - ES_WRITING_FLOW_SEQ_ENTRY, - ES_DONE_WITH_FLOW_SEQ_ENTRY, - - // block map - ES_WAITING_FOR_BLOCK_MAP_ENTRY, - ES_WAITING_FOR_BLOCK_MAP_KEY, - ES_WRITING_BLOCK_MAP_KEY, - ES_DONE_WITH_BLOCK_MAP_KEY, - ES_WAITING_FOR_BLOCK_MAP_VALUE, - ES_WRITING_BLOCK_MAP_VALUE, - ES_DONE_WITH_BLOCK_MAP_VALUE, - - // flow map - ES_WAITING_FOR_FLOW_MAP_ENTRY, - ES_WAITING_FOR_FLOW_MAP_KEY, - ES_WRITING_FLOW_MAP_KEY, - ES_DONE_WITH_FLOW_MAP_KEY, - ES_WAITING_FOR_FLOW_MAP_VALUE, - ES_WRITING_FLOW_MAP_VALUE, - ES_DONE_WITH_FLOW_MAP_VALUE - }; - + struct FmtScope { enum value { Local, Global }; }; + struct GroupType { enum value { None, Seq, Map }; }; + struct FlowType { enum value { None, Flow, Block }; }; + class EmitterState { public: @@ -84,76 +33,81 @@ namespace YAML const std::string GetLastError() const { return m_lastError; } void SetError(const std::string& error) { m_isGood = false; m_lastError = error; } - // main state of the machine - EMITTER_STATE GetCurState() const { return m_stateStack.top(); } - void SwitchState(EMITTER_STATE state) { PopState(); PushState(state); } - void PushState(EMITTER_STATE state) { m_stateStack.push(state); } - void PopState() { m_stateStack.pop(); } - - void SetLocalValue(EMITTER_MANIP value); - - // group handling - void BeginGroup(GROUP_TYPE type); - void EndGroup(GROUP_TYPE type); - - GROUP_TYPE GetCurGroupType() const; - FLOW_TYPE GetCurGroupFlowType() const; - int GetCurIndent() const { return m_curIndent; } - - bool CurrentlyInLongKey(); - void StartLongKey(); - void StartSimpleKey(); + // node handling + void SetAnchor(); + void SetTag(); + void SetNonContent(); + void SetLongKey(); + void ForceFlow(); + void StartedDoc(); + void EndedDoc(); + void StartedScalar(); + void StartedGroup(GroupType::value type); + void EndedGroup(GroupType::value type); - bool RequiresSoftSeparation() const { return m_requiresSoftSeparation; } - bool RequiresHardSeparation() const { return m_requiresHardSeparation; } - void RequireSoftSeparation() { m_requiresSoftSeparation = true; } - void RequireHardSeparation() { m_requiresSoftSeparation = true; m_requiresHardSeparation = true; } - void ForceHardSeparation() { m_requiresSoftSeparation = false; } - void UnsetSeparation() { m_requiresSoftSeparation = false; m_requiresHardSeparation = false; } + EmitterNodeType::value NextGroupType(GroupType::value type) const; + EmitterNodeType::value CurGroupNodeType() const; + + GroupType::value CurGroupType() const; + FlowType::value CurGroupFlowType() const; + int CurGroupIndent() const; + std::size_t CurGroupChildCount() const; + bool CurGroupLongKey() const; + + int LastIndent() const; + int CurIndent() const { return m_curIndent; } + bool HasAnchor() const { return m_hasAnchor; } + 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(); // formatters - bool SetOutputCharset(EMITTER_MANIP value, FMT_SCOPE scope); + 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, FMT_SCOPE scope); + bool SetStringFormat(EMITTER_MANIP value, FmtScope::value scope); EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); } - bool SetBoolFormat(EMITTER_MANIP value, FMT_SCOPE scope); + bool SetBoolFormat(EMITTER_MANIP value, FmtScope::value scope); EMITTER_MANIP GetBoolFormat() const { return m_boolFmt.get(); } - bool SetBoolLengthFormat(EMITTER_MANIP value, FMT_SCOPE scope); + bool SetBoolLengthFormat(EMITTER_MANIP value, FmtScope::value scope); EMITTER_MANIP GetBoolLengthFormat() const { return m_boolLengthFmt.get(); } - bool SetBoolCaseFormat(EMITTER_MANIP value, FMT_SCOPE scope); + bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope::value scope); EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); } - bool SetIntFormat(EMITTER_MANIP value, FMT_SCOPE scope); + bool SetIntFormat(EMITTER_MANIP value, FmtScope::value scope); EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); } - bool SetIndent(unsigned value, FMT_SCOPE scope); + bool SetIndent(unsigned value, FmtScope::value scope); int GetIndent() const { return m_indent.get(); } - bool SetPreCommentIndent(unsigned value, FMT_SCOPE scope); + bool SetPreCommentIndent(unsigned value, FmtScope::value scope); int GetPreCommentIndent() const { return m_preCommentIndent.get(); } - bool SetPostCommentIndent(unsigned value, FMT_SCOPE scope); + bool SetPostCommentIndent(unsigned value, FmtScope::value scope); int GetPostCommentIndent() const { return m_postCommentIndent.get(); } - bool SetFlowType(GROUP_TYPE groupType, EMITTER_MANIP value, FMT_SCOPE scope); - EMITTER_MANIP GetFlowType(GROUP_TYPE groupType) const; + bool SetFlowType(GroupType::value groupType, EMITTER_MANIP value, FmtScope::value scope); + EMITTER_MANIP GetFlowType(GroupType::value groupType) const; - bool SetMapKeyFormat(EMITTER_MANIP value, FMT_SCOPE scope); + bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope::value scope); EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); } - bool SetFloatPrecision(int value, FMT_SCOPE scope); + bool SetFloatPrecision(int value, FmtScope::value scope); unsigned GetFloatPrecision() const { return m_floatPrecision.get(); } - bool SetDoublePrecision(int value, FMT_SCOPE scope); + bool SetDoublePrecision(int value, FmtScope::value scope); unsigned GetDoublePrecision() const { return m_doublePrecision.get(); } private: template - void _Set(Setting& fmt, T value, FMT_SCOPE scope); + void _Set(Setting& fmt, T value, FmtScope::value scope); + + void StartedNode(); private: // basic state ok? @@ -161,8 +115,6 @@ namespace YAML std::string m_lastError; // other state - std::stack m_stateStack; - Setting m_charset; Setting m_strFmt; Setting m_boolFmt; @@ -181,29 +133,50 @@ namespace YAML SettingChanges m_globalModifiedSettings; struct Group { - Group(GROUP_TYPE type_): type(type_), usingLongKey(false), indent(0) {} + explicit Group(GroupType::value type_): type(type_), indent(0), childCount(0), longKey(false) {} - GROUP_TYPE type; - EMITTER_MANIP flow; - bool usingLongKey; + GroupType::value type; + FlowType::value flowType; int 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::None; + } }; ptr_stack m_groups; unsigned m_curIndent; - bool m_requiresSoftSeparation; - bool m_requiresHardSeparation; + bool m_hasAnchor; + bool m_hasTag; + bool m_hasNonContent; + std::size_t m_docCount; }; template - void EmitterState::_Set(Setting& fmt, T value, FMT_SCOPE scope) { + void EmitterState::_Set(Setting& fmt, T value, FmtScope::value scope) { switch(scope) { - case LOCAL: + case FmtScope::Local: m_modifiedSettings.push(fmt.set(value)); break; - case GLOBAL: + 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 diff --git a/src/emitterutils.cpp b/src/emitterutils.cpp index 3d184d6..5dfaec9 100644 --- a/src/emitterutils.cpp +++ b/src/emitterutils.cpp @@ -128,12 +128,12 @@ namespace YAML } } - bool IsValidPlainScalar(const std::string& str, bool inFlow, bool allowOnlyAscii) { + bool IsValidPlainScalar(const std::string& str, FlowType::value flowType, bool allowOnlyAscii) { if(str.empty()) return false; // first check the start - const RegEx& start = (inFlow ? Exp::PlainScalarInFlow() : Exp::PlainScalar()); + const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow() : Exp::PlainScalar()); if(!start.Matches(str)) return false; @@ -142,7 +142,7 @@ namespace YAML return false; // then check until something is disallowed - const RegEx& disallowed = (inFlow ? Exp::EndScalarInFlow() : Exp::EndScalar()) + const RegEx& disallowed = (flowType == FlowType::Flow ? Exp::EndScalarInFlow() : Exp::EndScalar()) || (Exp::BlankOrBreak() + Exp::Comment()) || Exp::NotPrintable() || Exp::Utf8_ByteOrderMark() @@ -152,7 +152,7 @@ namespace YAML while(buffer) { if(disallowed.Matches(buffer)) return false; - if(allowOnlyAscii && (0x7F < static_cast(buffer[0]))) + if(allowOnlyAscii && (0x80 <= static_cast(buffer[0]))) return false; ++buffer; } @@ -160,7 +160,32 @@ namespace YAML return true; } - void WriteDoubleQuoteEscapeSequence(ostream& out, int codePoint) { + bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) + { + // TODO: check for non-printable characters? + for(std::size_t i=0;i(str[i]))) + return false; + if(str[i] == '\n') + return false; + } + return true; + } + + bool IsValidLiteralScalar(const std::string& str, FlowType::value flowType, bool escapeNonAscii) + { + if(flowType == FlowType::Flow) + return false; + + // TODO: check for non-printable characters? + for(std::size_t i=0;i(str[i]))) + return false; + } + return true; + } + + void WriteDoubleQuoteEscapeSequence(ostream& out, int codePoint) { static const char hexDigits[] = "0123456789abcdef"; char escSeq[] = "\\U00000000"; @@ -198,15 +223,30 @@ namespace YAML } } - bool WriteString(ostream& out, const std::string& str, bool inFlow, bool escapeNonAscii) - { - if(IsValidPlainScalar(str, inFlow, escapeNonAscii)) { - out << str; - return true; - } else - return WriteDoubleQuotedString(out, str, escapeNonAscii); - } - + 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& out, const std::string& str) { out << "'"; @@ -235,18 +275,23 @@ namespace YAML GetNextCodePointAndAdvance(codePoint, i, str.end()); ) { - if (codePoint == '\"') - out << "\\\""; - else if (codePoint == '\\') - out << "\\\\"; - else if (codePoint < 0x20 || (codePoint >= 0x80 && codePoint <= 0xA0)) // Control characters and non-breaking space - WriteDoubleQuoteEscapeSequence(out, codePoint); - else if (codePoint == 0xFEFF) // Byte order marks (ZWNS) should be escaped (YAML 1.2, sec. 5.2) - WriteDoubleQuoteEscapeSequence(out, codePoint); - else if (escapeNonAscii && codePoint > 0x7E) - WriteDoubleQuoteEscapeSequence(out, codePoint); - else - WriteCodePoint(out, codePoint); + 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; + default: + if(codePoint < 0x20 || (codePoint >= 0x80 && codePoint <= 0xA0)) // Control characters and non-breaking space + WriteDoubleQuoteEscapeSequence(out, codePoint); + else if (codePoint == 0xFEFF) // Byte order marks (ZWNS) should be escaped (YAML 1.2, sec. 5.2) + WriteDoubleQuoteEscapeSequence(out, codePoint); + else if (escapeNonAscii && codePoint > 0x7E) + WriteDoubleQuoteEscapeSequence(out, codePoint); + else + WriteCodePoint(out, codePoint); + } } out << "\""; return true; @@ -293,15 +338,18 @@ namespace YAML { const unsigned 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') + if(codePoint == '\n') { out << "\n" << IndentTo(curIndent) << "#" << Indentation(postCommentIndent); - else + out.set_comment(); + } else { WriteCodePoint(out, codePoint); + } } return true; } diff --git a/src/emitterutils.h b/src/emitterutils.h index 0e270d6..67200f8 100644 --- a/src/emitterutils.h +++ b/src/emitterutils.h @@ -6,6 +6,7 @@ #endif +#include "emitterstate.h" #include "yaml-cpp/ostream.h" #include @@ -13,9 +14,12 @@ namespace YAML { class Binary; + struct StringFormat { enum value { Plain, SingleQuoted, DoubleQuoted, Literal }; }; + namespace Utils { - bool WriteString(ostream& out, const std::string& str, bool inFlow, bool escapeNonAscii); + StringFormat::value ComputeStringFormat(const std::string& str, EMITTER_MANIP strFormat, FlowType::value flowType, bool escapeNonAscii); + bool WriteSingleQuotedString(ostream& out, const std::string& str); bool WriteDoubleQuotedString(ostream& out, const std::string& str, bool escapeNonAscii); bool WriteLiteralString(ostream& out, const std::string& str, int indent); diff --git a/src/ostream.cpp b/src/ostream.cpp index a7f1e14..9bcb5e5 100644 --- a/src/ostream.cpp +++ b/src/ostream.cpp @@ -3,7 +3,7 @@ namespace YAML { - ostream::ostream(): m_buffer(0), m_pos(0), m_size(0), m_row(0), m_col(0) + ostream::ostream(): m_buffer(0), m_pos(0), m_size(0), m_row(0), m_col(0), m_comment(false) { reserve(1024); } @@ -37,6 +37,7 @@ namespace YAML if(ch == '\n') { m_row++; m_col = 0; + m_comment = false; } else m_col++; } diff --git a/src/ptr_stack.h b/src/ptr_stack.h index bf454fb..eec0fb8 100644 --- a/src/ptr_stack.h +++ b/src/ptr_stack.h @@ -38,7 +38,10 @@ public: } T& top() { return *m_data.back(); } const T& top() const { return *m_data.back(); } - + + T& top(std::ptrdiff_t diff) { return **(m_data.end() - 1 + diff); } + const T& top(std::ptrdiff_t diff) const { return **(m_data.end() - 1 + diff); } + private: std::vector m_data; }; diff --git a/test/core/spectests.cpp b/test/core/spectests.cpp index 4c81d35..9d13465 100644 --- a/test/core/spectests.cpp +++ b/test/core/spectests.cpp @@ -1,206 +1,10 @@ #include "spectests.h" +#include "handlermacros.h" #include "specexamples.h" #include "yaml-cpp/yaml.h" -#include "yaml-cpp/eventhandler.h" #include -#define YAML_ASSERT(cond) do { if(!(cond)) return " Assert failed: " #cond; } while(false) - namespace Test { - struct Event { - enum Type { DocStart, DocEnd, Null, Alias, Scalar, SeqStart, SeqEnd, MapStart, MapEnd }; - - typedef YAML::Mark Mark; - typedef YAML::anchor_t anchor_t; - - Event(Type type_, const std::string& tag_, anchor_t anchor_, const std::string& scalar_): type(type_), tag(tag_), anchor(anchor_), scalar(scalar_) {} - - Type type; - std::string tag; - anchor_t anchor; - std::string scalar; - - std::ostream& write(std::ostream& out) const { - switch(type) { - case DocStart: - return out << "DocStart"; - case DocEnd: - return out << "DocEnd"; - case Null: - return out << "Null(" << anchor << ")"; - case Alias: - return out << "Alias(" << anchor << ")"; - case Scalar: - return out << "Scalar(" << tag << ", " << anchor << ", " << scalar << ")"; - case SeqStart: - return out << "SeqStart(" << tag << ", " << anchor << ")"; - case SeqEnd: - return out << "SeqEnd"; - case MapStart: - return out << "MapStart(" << tag << ", " << anchor << ")"; - case MapEnd: - return out << "MapEnd"; - } - assert(false); - return out; - } - }; - - std::ostream& operator << (std::ostream& out, const Event& event) { - return event.write(out); - } - - bool operator == (const Event& a, const Event& b) { - return a.type == b.type && a.tag == b.tag && a.anchor == b.anchor && a.scalar == b.scalar; - } - - bool operator != (const Event& a, const Event& b) { - return !(a == b); - } - - class MockEventHandler: public YAML::EventHandler - { - public: - typedef YAML::Mark Mark; - typedef YAML::anchor_t anchor_t; - - MockEventHandler() {} - - virtual void OnDocumentStart(const Mark&) { - m_actualEvents.push_back(Event(Event::DocStart, "", 0, "")); - } - - virtual void OnDocumentEnd() { - m_actualEvents.push_back(Event(Event::DocEnd, "", 0, "")); - } - - virtual void OnNull(const Mark&, anchor_t anchor) { - m_actualEvents.push_back(Event(Event::Null, "", anchor, "")); - } - - virtual void OnAlias(const Mark&, anchor_t anchor) { - m_actualEvents.push_back(Event(Event::Alias, "", anchor, "")); - } - - virtual void OnScalar(const Mark&, const std::string& tag, anchor_t anchor, const std::string& value) { - m_actualEvents.push_back(Event(Event::Scalar, tag, anchor, value)); - } - - virtual void OnSequenceStart(const Mark&, const std::string& tag, anchor_t anchor) { - m_actualEvents.push_back(Event(Event::SeqStart, tag, anchor, "")); - } - - virtual void OnSequenceEnd() { - m_actualEvents.push_back(Event(Event::SeqEnd, "", 0, "")); - } - - virtual void OnMapStart(const Mark&, const std::string& tag, anchor_t anchor) { - m_actualEvents.push_back(Event(Event::MapStart, tag, anchor, "")); - } - - virtual void OnMapEnd() { - m_actualEvents.push_back(Event(Event::MapEnd, "", 0, "")); - } - - void Expect(const Event& event) { m_expectedEvents.push_back(event); } - - Test::TEST Check() const { - std::size_t N = std::max(m_expectedEvents.size(), m_actualEvents.size()); - for(std::size_t i=0;i= m_expectedEvents.size()) { - std::stringstream out; - for(std::size_t j=0;j= m_actualEvents.size()) { - std::stringstream out; - for(std::size_t j=0;j m_expectedEvents; - std::vector m_actualEvents; - }; - -#define HANDLE(ex)\ - MockEventHandler handler;\ - std::stringstream stream(ex);\ - YAML::Parser parser(stream);\ - while(parser.HandleNextDocument(handler))\ - -#define EXPECT_DOC_START()\ - do {\ - handler.Expect(Event(Event::DocStart, "", 0, ""));\ - } while(false) - -#define EXPECT_DOC_END()\ - do {\ - handler.Expect(Event(Event::DocEnd, "", 0, ""));\ - } while(false) - -#define EXPECT_NULL(anchor)\ - do {\ - handler.Expect(Event(Event::Null, "", anchor, ""));\ - } while(false) - -#define EXPECT_ALIAS(anchor)\ - do {\ - handler.Expect(Event(Event::Alias, "", anchor, ""));\ - } while(false) - -#define EXPECT_SCALAR(tag, anchor, value)\ - do {\ - handler.Expect(Event(Event::Scalar, tag, anchor, value));\ - } while(false) - -#define EXPECT_SEQ_START(tag, anchor)\ - do {\ - handler.Expect(Event(Event::SeqStart, tag, anchor, ""));\ - } while(false) - -#define EXPECT_SEQ_END()\ - do {\ - handler.Expect(Event(Event::SeqEnd, "", 0, ""));\ - } while(false) - -#define EXPECT_MAP_START(tag, anchor)\ - do {\ - handler.Expect(Event(Event::MapStart, tag, anchor, ""));\ - } while(false) - -#define EXPECT_MAP_END()\ - do {\ - handler.Expect(Event(Event::MapEnd, "", 0, ""));\ - } while(false) - -#define DONE()\ - do {\ - return handler.Check();\ - } while(false) - namespace Spec { // 2.1 TEST SeqScalars() diff --git a/test/create-emitter-tests.py b/test/create-emitter-tests.py new file mode 100644 index 0000000..bf17f0a --- /dev/null +++ b/test/create-emitter-tests.py @@ -0,0 +1,184 @@ +import sys +import yaml +import hashlib + +NS = 'Emitter' +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': 'DOC_START()'} + else: + return {'emit': 'YAML::BeginDoc', 'handle': 'DOC_START()'} + +def doc_end(implicit=False): + if implicit: + return {'emit': '', 'handle': 'DOC_END()'} + else: + return {'emit': 'YAML::EndDoc', 'handle': 'DOC_END()'} + +def scalar(value, tag='', anchor='', anchor_id=0): + emit = [] + if tag: + emit += ['YAML::VerbatimTag("%s")' % encode(tag)] + if anchor: + emit += ['YAML::Anchor("%s")' % encode(anchor)] + if tag: + out_tag = encode(tag) + else: + if value == encode(value): + out_tag = '?' + else: + out_tag = '!' + emit += ['"%s"' % encode(value)] + return {'emit': emit, 'handle': 'SCALAR("%s", %s, "%s")' % (out_tag, anchor_id, encode(value))} + +def comment(value): + return {'emit': 'YAML::Comment("%s")' % value, 'handle': ''} + +def seq_start(tag='', anchor='', anchor_id=0): + emit = [] + if tag: + emit += ['YAML::VerbatimTag("%s")' % encode(tag)] + if anchor: + emit += ['YAML::Anchor("%s")' % encode(anchor)] + if tag: + out_tag = encode(tag) + else: + out_tag = '?' + emit += ['YAML::BeginSeq'] + return {'emit': emit, 'handle': 'SEQ_START("%s", %s)' % (out_tag, anchor_id)} + +def seq_end(): + return {'emit': 'YAML::EndSeq', 'handle': 'SEQ_END()'} + +def map_start(tag='', anchor='', anchor_id=0): + emit = [] + if tag: + emit += ['YAML::VerbatimTag("%s")' % encode(tag)] + if anchor: + emit += ['YAML::Anchor("%s")' % encode(anchor)] + if tag: + out_tag = encode(tag) + else: + out_tag = '?' + emit += ['YAML::BeginMap'] + return {'emit': emit, 'handle': 'MAP_START("%s", %s)' % (out_tag, anchor_id)} + +def map_end(): + return {'emit': 'YAML::EndMap', 'handle': 'MAP_END()'} + +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} + + +def create_emitter_tests(out): + out.write('#ifdef %s\n' % DEFINE) + out.write('namespace %s {\n' % NS) + + tests = list(gen_tests()) + + for test in tests: + out.write('TEST %s(YAML::Emitter& out)\n' % test['name']) + out.write('{\n') + for event in test['events']: + emit = event['emit'] + if isinstance(emit, list): + for e in emit: + out.write(' out << %s;\n' % e) + elif emit: + out.write(' out << %s;\n' % emit) + out.write('\n') + out.write(' HANDLE(out.c_str());\n') + for event in test['events']: + handle = event['handle'] + if handle: + out.write(' EXPECT_%s;\n' % handle) + out.write(' DONE();\n') + out.write('}\n') + + out.write('}\n') + out.write('#endif // %s\n\n' % DEFINE) + + out.write('void RunGenEmitterTests(int& passed, int& total)\n') + out.write('{\n') + out.write('#ifdef %s\n' % DEFINE) + for test in tests: + out.write(' RunGenEmitterTest(&Emitter::%s, "%s", passed, total);\n' % (test['name'], encode(test['name']))) + out.write('#else // %s\n' % DEFINE) + out.write(' (void)passed; (void)total;\n') + out.write('#endif // %s\n' % DEFINE) + out.write('}\n') + +if __name__ == '__main__': + create_emitter_tests(sys.stdout) diff --git a/test/emittertests.cpp b/test/emittertests.cpp index f16d25a..cee64f5 100644 --- a/test/emittertests.cpp +++ b/test/emittertests.cpp @@ -1,4 +1,5 @@ #include "tests.h" +#include "handlermacros.h" #include "yaml-cpp/yaml.h" #include @@ -190,7 +191,7 @@ namespace Test out << YAML::Value << "demon"; out << YAML::EndMap; - desiredOutput = "?\n - 1\n - 3\n: monster\n? [2, 0]\n: demon"; + desiredOutput = "? - 1\n - 3\n: monster\n? [2, 0]\n: demon"; } void AutoLongKey(YAML::Emitter& out, std::string& desiredOutput) @@ -204,7 +205,7 @@ namespace Test out << YAML::Value << "angel"; out << YAML::EndMap; - desiredOutput = "?\n - 1\n - 3\n: monster\n? [2, 0]\n: demon\nthe origin: angel"; + desiredOutput = "? - 1\n - 3\n: monster\n[2, 0]: demon\nthe origin: angel"; } void ScalarFormat(YAML::Emitter& out, std::string& desiredOutput) @@ -218,7 +219,7 @@ namespace Test out << YAML::Literal << "literal scalar\nthat may span\nmany, many\nlines and have \"whatever\" crazy\tsymbols that we like"; out << YAML::EndSeq; - desiredOutput = "- simple scalar\n- 'explicit single-quoted scalar'\n- \"explicit double-quoted scalar\"\n- \"auto-detected\\x0adouble-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"; + desiredOutput = "- 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"; } void AutoLongKeyScalar(YAML::Emitter& out, std::string& desiredOutput) @@ -256,7 +257,7 @@ namespace Test out << "total value"; out << YAML::EndMap; - desiredOutput = "?\n key: value\n next key: next value\n: total value"; + desiredOutput = "? key: value\n next key: next value\n: total value"; } void AliasAndAnchor(YAML::Emitter& out, std::string& desiredOutput) @@ -539,7 +540,7 @@ namespace Test { out << YAML::Flow << YAML::BeginSeq << "foo" << YAML::Comment("foo!") << "bar" << YAML::EndSeq; - desiredOutput = "[foo # foo!\n, bar]"; + desiredOutput = "[foo, # foo!\nbar]"; } void CommentInFlowMap(YAML::Emitter& out, std::string& desiredOutput) @@ -550,7 +551,7 @@ namespace Test out << YAML::Key << "baz" << YAML::Value << "baz value" << YAML::Comment("baz!"); out << YAML::EndMap; - desiredOutput = "{foo: foo value, bar: bar value # bar!\n, baz: baz value # baz!\n}"; + desiredOutput = "{foo: foo value, bar: bar value, # bar!\nbaz: baz value, # baz!\n}"; } void Indentation(YAML::Emitter& out, std::string& desiredOutput) @@ -563,7 +564,7 @@ namespace Test out << YAML::EndMap; out << YAML::EndSeq; - desiredOutput = "- key 1: value 1\n key 2:\n - a\n - b\n - c"; + desiredOutput = "- key 1: value 1\n key 2:\n - a\n - b\n - c"; } void SimpleGlobalSettings(YAML::Emitter& out, std::string& desiredOutput) @@ -597,7 +598,7 @@ namespace Test out << YAML::EndMap; out << YAML::EndSeq; - desiredOutput = "- key 1: value 1\n key 2: [a, b, c]\n- ? [1, 2]\n :\n a: b"; + desiredOutput = "- key 1: value 1\n key 2: [a, b, c]\n- [1, 2]:\n a: b"; } void Null(YAML::Emitter& out, std::string& desiredOutput) @@ -720,7 +721,7 @@ namespace Test out << YAML::Flow << YAML::BeginSeq; out << "a" << YAML::Newline << "b" << "c" << YAML::Newline << "d"; out << YAML::EndSeq; - desiredOutput = "[a\n, b, c\n, d]"; + desiredOutput = "[a,\nb, c,\nd]"; } void NewlineInBlockMap(YAML::Emitter& out, std::string& desiredOutput) @@ -730,7 +731,7 @@ namespace Test out << YAML::Key << "b" << YAML::Newline << YAML::Value << "bar"; out << YAML::LongKey << YAML::Key << "c" << YAML::Newline << YAML::Value << "car"; out << YAML::EndMap; - desiredOutput = "a: foo\n\nb: bar\n? c\n\n: car"; + desiredOutput = "a: foo\nb:\n bar\n? c\n\n: car"; } void NewlineInFlowMap(YAML::Emitter& out, std::string& desiredOutput) @@ -739,7 +740,7 @@ namespace Test out << YAML::Key << "a" << YAML::Value << "foo" << YAML::Newline; out << YAML::Key << "b" << YAML::Value << "bar"; out << YAML::EndMap; - desiredOutput = "{a: foo\n, b: bar}"; + desiredOutput = "{a: foo,\nb: bar}"; } void LotsOfNewlines(YAML::Emitter& out, std::string& desiredOutput) @@ -755,7 +756,7 @@ namespace Test out << YAML::LongKey << YAML::Key << "f" << YAML::Newline << YAML::Value << "foo"; out << YAML::EndMap; out << YAML::EndSeq; - desiredOutput = "- a\n\n-\n - b\n - c\n\n\n-\n d: e\n ? f\n\n : foo"; + desiredOutput = "- a\n\n-\n - b\n - c\n\n\n-\n d:\n e\n ? f\n\n : foo"; } void Binary(YAML::Emitter& out, std::string& desiredOutput) @@ -911,7 +912,40 @@ namespace Test desiredOutput = "[31, 0x1f, 037]"; } - //////////////////////////////////////////////////////////////////////////////////////////////////////// + void CompactMapWithNewline(YAML::Emitter& out, std::string& desiredOutput) + { + out << YAML::Comment("Characteristics"); + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << YAML::Key << "color" << YAML::Value << "blue"; + out << YAML::Key << "height" << YAML::Value << 120; + out << YAML::EndMap; + out << YAML::Newline << YAML::Newline; + out << YAML::Comment("Skills"); + out << YAML::BeginMap; + out << YAML::Key << "attack" << YAML::Value << 23; + out << YAML::Key << "intelligence" << YAML::Value << 56; + out << YAML::EndMap; + out << YAML::EndSeq; + + desiredOutput = + "# Characteristics\n" + "- color: blue\n" + " height: 120\n" + "\n" + "# Skills\n" + "- attack: 23\n" + " intelligence: 56"; + } + + void ForceSingleQuotedToDouble(YAML::Emitter& out, std::string& desiredOutput) + { + out << YAML::SingleQuoted << "Hello\nWorld"; + + desiredOutput = "\"Hello\\nWorld\""; + } + + //////////////////////////////////////////////////////////////////////////////// // incorrect emitting void ExtraEndSeq(YAML::Emitter& out, std::string& desiredError) @@ -935,13 +969,6 @@ namespace Test out << YAML::EndMap; } - void BadSingleQuoted(YAML::Emitter& out, std::string& desiredError) - { - desiredError = YAML::ErrorMsg::SINGLE_QUOTED_CHAR; - - out << YAML::SingleQuoted << "Hello\nWorld"; - } - void InvalidAnchor(YAML::Emitter& out, std::string& desiredError) { desiredError = YAML::ErrorMsg::INVALID_ANCHOR; @@ -959,43 +986,6 @@ namespace Test out << YAML::Alias("new\nline"); out << YAML::EndSeq; } - - void MissingKey(YAML::Emitter& out, std::string& desiredError) - { - desiredError = YAML::ErrorMsg::EXPECTED_KEY_TOKEN; - - out << YAML::BeginMap; - out << YAML::Key << "key" << YAML::Value << "value"; - out << "missing key" << YAML::Value << "value"; - out << YAML::EndMap; - } - - void MissingValue(YAML::Emitter& out, std::string& desiredError) - { - desiredError = YAML::ErrorMsg::EXPECTED_VALUE_TOKEN; - - out << YAML::BeginMap; - out << YAML::Key << "key" << "value"; - out << YAML::EndMap; - } - - void UnexpectedKey(YAML::Emitter& out, std::string& desiredError) - { - desiredError = YAML::ErrorMsg::UNEXPECTED_KEY_TOKEN; - - out << YAML::BeginSeq; - out << YAML::Key << "hi"; - out << YAML::EndSeq; - } - - void UnexpectedValue(YAML::Emitter& out, std::string& desiredError) - { - desiredError = YAML::ErrorMsg::UNEXPECTED_VALUE_TOKEN; - - out << YAML::BeginSeq; - out << YAML::Value << "hi"; - out << YAML::EndSeq; - } } namespace { @@ -1043,7 +1033,37 @@ namespace Test } total++; } + + void RunGenEmitterTest(TEST (*test)(YAML::Emitter&), const std::string& name, int& passed, int& total) { + YAML::Emitter out; + TEST ret; + + try { + ret = test(out); + } catch(const YAML::Exception& e) { + ret.ok = false; + ret.error = std::string(" Exception caught: ") + e.what(); + } + + if(!out.good()) { + ret.ok = false; + ret.error = out.GetLastError(); + } + + if(!ret.ok) { + std::cout << "Generated emitter test failed: " << name << "\n"; + std::cout << "Output:\n"; + std::cout << out.c_str() << "<<<\n"; + std::cout << ret.error << "\n"; + } + + if(ret.ok) + passed++; + total++; + } } + +#include "genemittertests.h" bool RunEmitterTests() { @@ -1126,17 +1146,16 @@ namespace Test RunEmitterTest(&Emitter::SetPrecision, "set precision", passed, total); RunEmitterTest(&Emitter::DashInBlockContext, "dash in block context", passed, total); RunEmitterTest(&Emitter::HexAndOct, "hex and oct", passed, total); + RunEmitterTest(&Emitter::CompactMapWithNewline, "compact map with newline", passed, total); + RunEmitterTest(&Emitter::ForceSingleQuotedToDouble, "force single quoted to double", passed, total); RunEmitterErrorTest(&Emitter::ExtraEndSeq, "extra EndSeq", passed, total); RunEmitterErrorTest(&Emitter::ExtraEndMap, "extra EndMap", passed, total); - RunEmitterErrorTest(&Emitter::BadSingleQuoted, "bad single quoted string", passed, total); RunEmitterErrorTest(&Emitter::InvalidAnchor, "invalid anchor", passed, total); RunEmitterErrorTest(&Emitter::InvalidAlias, "invalid alias", passed, total); - RunEmitterErrorTest(&Emitter::MissingKey, "missing key", passed, total); - RunEmitterErrorTest(&Emitter::MissingValue, "missing value", passed, total); - RunEmitterErrorTest(&Emitter::UnexpectedKey, "unexpected key", passed, total); - RunEmitterErrorTest(&Emitter::UnexpectedValue, "unexpected value", passed, total); RunEmitterErrorTest(&Emitter::BadLocalTag, "bad local tag", passed, total); + + RunGenEmitterTests(passed, total); std::cout << "Emitter tests: " << passed << "/" << total << " passed\n"; return passed == total; diff --git a/test/genemittertests.h b/test/genemittertests.h new file mode 100644 index 0000000..d15690a --- /dev/null +++ b/test/genemittertests.h @@ -0,0 +1,10256 @@ +#ifdef YAML_GEN_TESTS +namespace Emitter { +TEST test02571eee35ac0cbd3777(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test71b969ca18898d226320(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testd69e4ea95ce6f221c6e7(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testffbfd295ad9bef4deb00(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << "foo"; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test6a459b2fe1f6e961e1a7(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test869ab95640c9933ed4d6(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test433c0771f40ac3ba853e(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST teste181778974c4003bc5a4(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testf8cb7e3f1b11791f53b8(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << "foo\n"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST test3c48ed06807100f0a111(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << "foo\n"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST testb13f7b031f425b0e383f(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << "foo\n"; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST testb77284234d3fbe8b24a0(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << "foo\n"; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST test9c56fd285b563327a340(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << "foo\n"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST test1c08639d56176e64c885(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << "foo\n"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST test94c8742f8cab3cec1b4a(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << "foo\n"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST test79d1806ceb3ecebfa60b(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << "foo\n"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST test360afe50348ec36569d3(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST teste599b3fc1857f4265d3b(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test88adf7adb474ad063424(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test0978ca6f6358ea06e024(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testd915f57fca4b0f6d77b4(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::VerbatimTag("tag"); + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test1fe1f22496f2a0ffd64e(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test76422a4077d3bdd03579(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test92b168a497cb0c7e3144(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testa93925b3ae311a7f11d4(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test2dd1aaf6a1c1924557d0(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test6ec0585d0f0945ad9dae(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test7e00bca835d55844bbfe(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test70912c7d920a0597bbb2(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::Anchor("anchor"); + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test16eacbf77bccde360e54(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::Anchor("anchor"); + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test556e0c86efb0716d2778(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test71b64326d72fe100e6ad(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test0c7bb03fbd6b52ea3ad6(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testb819efb5742c1176df98(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test1f7b7cd5a13070c723d3(YAML::Emitter& out) +{ + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test32126a88cb2b7311e779(YAML::Emitter& out) +{ + out << "foo"; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testd7f952713bde5ce2f9e7(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test5030b4f2d1efb798f320(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testb9015537b9a9e09b8ec8(YAML::Emitter& out) +{ + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test03229f6d33fa9007a65d(YAML::Emitter& out) +{ + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testf998264dcfd0dba06c0a(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << "foo\n"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST test7defadc52eddfbf766aa(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << "foo\n"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST test55a7c58211689c7815b2(YAML::Emitter& out) +{ + out << "foo\n"; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST testc3873d954433175e0143(YAML::Emitter& out) +{ + out << "foo\n"; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST test81fb6bf1f976e0ad3fba(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << "foo\n"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST test29e7ff04645f56a7ea2f(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << "foo\n"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST testce0089a55f926d311ff4(YAML::Emitter& out) +{ + out << "foo\n"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST testd1d301bbc73ec11cd49b(YAML::Emitter& out) +{ + out << "foo\n"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("!", 0, "foo\n"); + EXPECT_DOC_END(); + DONE(); +} +TEST test4640bfb42711b7209ef9(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test1133d19fc3a4ec9fb3e8(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test4a6d083241180899f7ed(YAML::Emitter& out) +{ + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testbadb5b228a4db78efac0(YAML::Emitter& out) +{ + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test5c6d607ed1ad046568e1(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testac34cde109884bb6876b(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test5c19597d5336d541f990(YAML::Emitter& out) +{ + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test39e174ed33d5508a61ce(YAML::Emitter& out) +{ + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test43e26cf94441cee4a0c4(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test06afa8e5b516630fc8da(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test4d109db0282a7797cdcb(YAML::Emitter& out) +{ + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test0c1c00113c20dfa650a9(YAML::Emitter& out) +{ + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testccd7f2183f06483ee5e0(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::Anchor("anchor"); + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST test52e25e363a17f37c296f(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::Anchor("anchor"); + out << "foo"; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testdd81d16d3bdd8636af16(YAML::Emitter& out) +{ + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST testd76e8eb5043431c3434e(YAML::Emitter& out) +{ + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_DOC_END(); + DONE(); +} +TEST teste03be55aff3dc08f07a1(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test8ba3e94c45f696c5027b(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test90e45bcf67b89e31fd12(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0b7c4e535bfebfa3c85d(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3a1c08f490683d254cda(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test926cd343d3999525d9ce(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1e5dd6b1e4dfb59f0346(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0f064b30c1187ff2dd4b(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test58fd20c1736964e12b53(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testbddd187d973b632dc188(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5bc168e49ab7503fd2e1(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test712e139d81db4e14196d(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test48130bfdef5d192b888e(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test27552de54635da852895(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6529691d17594d5abeb6(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test46b8a7b9d2461d80e0c0(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testbd1cb845de056e97a301(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testfe1f94c842b37340db76(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste3c7fbf8af4d82e891e3(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd6800d90d6d037d02ace(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testdf987230fa431b7a8f1b(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testcd22b774448a8b15345e(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test591a370a1ce302d23688(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5e56c5800a9f2c4591ff(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test72f6d368cc2f52b488bd(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6786da34791cbab71591(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6d53136f35632180e2e8(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test01020a01f84721d7fb07(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testc3ab223703ef17e47ec7(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test033db6218db214ae5ef9(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test38fe09343ac97f51b38f(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test99eb29693d619703a052(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste9e58998a49132e15fb4(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testc1b4fba9280329b30583(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2f8651438d44de183d22(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4c506bf0bc7a972cb62d(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6a42214b8698a0e87f5f(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste0b5020ccbc0cbc7f699(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3fb453ac1de7a2d37a16(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4d3236ecd88c5faa74e8(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test116230234c38c68eb060(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb7c63d73350b11bf4a56(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test26ae0a3b97fb1c7743bf(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testeabf01d5500c4f5c9de5(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf9195cd2fb4c57783870(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test8c7159f70888a6c5548e(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testba96c9cdf5e82c9ebd0f(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6cbb2232cc1e43752958(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2bc126cc8be9e3d0a5bb(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb053b9b6ee7c7eecc798(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testda8339179085c81ac7a9(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf38e7a065a9bda416bf0(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5345180f2a8a65af5b72(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7aee5968853276b78e65(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1c20b15f6680fd1fa304(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3ad355d8aa94a80ed9d0(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test717b89ec9b7b004e5c17(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testc540c8d6d92913953ef8(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test805391f6964c07b1fc51(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testafc978dbd9b5d8005968(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf137897e42e659d45548(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test41c10a5f012922d6d240(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6d46af9b0e1bab6eefd2(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6908c1e71bca5b5a09b6(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test158d6160ee94d7f929c0(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test07186666318de7b13975(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testdcb6011d1dbc47e024b4(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test998e6b11c32e19f91a43(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7b009b420c34f753e2dc(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testba4c5b4eedf23c16ab44(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test022d120061a5c77c6640(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testeb346f4b70732835631f(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testade70114082f144726ee(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf2b68aae6173ab6ad66d(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste9a962c26a72ea4d3f8d(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa9603ff993f8a8d47b5d(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2b70cf1579b37e0fb086(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3790d77103bac72dc302(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testadfa25cb2fd5a9346102(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9764ad298ba1fe9ecfa8(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test22f20fac5e02211edadc(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test8b3b22c8ffd679b15623(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test438d1581dec9088389d7(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0b417297c8e11f038c7c(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa3686f0b87652d4640c2(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd6f021791f2162c85174(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3d34018a42371ab9fbcd(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7a9287f053731d912e63(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa9aa047a659d330a4a8b(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test74e66203a050c2ce6c17(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7338d0bbe29dd57fab54(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testbd4f6be8cdb35c6f251d(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test8f0d1345830b83dfc1b7(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa4e1c63bc2832a9ffb90(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9d5abf8cc60b9bd0d314(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test332175e66c385ed1a97e(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test34238765b14f93c81e57(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test10797ce06190a3866a08(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste92cd495aff9e502a1ca(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf02ffda4a54ad1390ab6(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test252e5030af4f0ab7bf2b(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testfe3d96e64a5db1098e2d(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test94c9f1a9c03f970dde84(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd16f010f550e384c3e59(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9b6529d7a517cd7dbc13(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test706fdc6bcd111cd4de81(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7ce41e86a2afa55d59d7(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test14aebe584c51e7c2a682(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb9987fabfcd184f82c65(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testbe1a5e58793366c0c07a(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1eac7fa4e151174d20c5(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5a372a31cdbea0111962(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testcc1a35b80f0b02e1255e(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb04cc0e338c9b30cffa3(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb0a82e7bf3b5bdebdd9c(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0d883c1652c0b59e6643(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa38bc626fc7e3454333b(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test8bea94aa1202a12d9ae9(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test24a263a0eb80caaaea4b(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb86b045d63884140fd1d(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9d261e666ae24a9cfc70(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test331919d746512b1bd2dd(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test58b5cb1c0a14ca820fa0(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testfcc5a2d53d8b78bff00e(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4e18e90b6551c4af46b7(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testfd0cdd7da5ea80def96c(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test31fa2c218bc9f47d31b5(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test486f1defd8f55e9519a9(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testbd67707be3be50792791(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1a5d67d4591ad4c8d1e7(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd1b42a0d7e5156b00706(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test120e16514220d9f1b114(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf3200a3148254d3357d3(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test291bb8d225b135c1f926(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd89446599f31a400dcec(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test10810f50a49dfe065bfa(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb1f754216d575a8cc3af(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb9d82396ef66bed18aed(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5469f77f98702583e6ea(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testea4d055788f9af327d2e(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test08ac3b6e6f8814cdc77a(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9e8e5ac1687da916f607(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6265b47bba1fd6839697(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa78aad03d3d6c0cd9810(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test050fb21ac4e0ec123acc(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test41e74fd70f88555712db(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testc066eeba93b49bfd475e(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testba918d828779830ff775(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9fc69104bdb595977460(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0dd65e43cc41ad032d71(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test324295b9fb6b58411e30(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test8aebc8d0e0485dfeb252(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd222de940e9a99d43cdd(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9b7e3c531ced5ced7f08(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testcfc4d3d407725683e731(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test76848f10a77db08e038e(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa4c728e62357ca05c45c(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test666ae3bb483cb7d83170(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6ec557a6e48fd6900cb1(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test18a5d0db57d08d737b99(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd974ded8f39d6b77c0a1(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6c6d47297f6ea03c588b(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testfb543650c644777c82ec(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test85cf601a990a9689b6c2(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testae2c05021a270e7e6ce6(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testceebe4a07ec516cb5a7a(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1a2b24646720aa998cbb(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf415efe81b5c2c8112a2(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0f1b297a0cb08c094411(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1b49cc3347751dcb09a9(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testffe72c176661d48910bd(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf3f2d1d0e79f326b3d2f(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testeb66a6725a958bb76923(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0a8fc83bac630f116c86(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6c62ccca61f383967d91(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6ba9e6495bef38087e7f(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test643e77d887ec7390c1c9(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa9725ffe34acd33603c4(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1a65df7ae90ac6ba1f22(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7f982251b9a09ebb1059(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4b2138b3eafc346d6bd3(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa316e26e6b940d585005(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testda2e0d2a6fd2a83cb298(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test54aac276524c0baaecd1(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd1fb3fd39f4a2fda5c6a(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4aaf20817b31a62e905f(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test446f00cbeee81a34d936(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb13663976ee52dac5370(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd245994f89c881efef06(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb6e7c5ee86f3c0559fe3(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testee28e38a088388ee5d9f(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9b40d68cb65d34934b50(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test045fac0048d3cfc15d88(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test85c3ad95991be29b3aff(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2abfed1da9a2ab365c18(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa999e4a9d0199bf463ec(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test8452a26a810950ad47b2(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1e2b3a261f435a0f6316(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1423ee4cd0795e6ef646(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf95070e81f8def8ceec9(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf533a12940040f665761(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test51bd09a609a537b79c8a(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testc10b994394aa86a1789b(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testc5de3511ef8fa1e5841e(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0e957613f266e5693f83(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf36b8fb2ec772e02a48c(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test249b4ee9b0e6936bdfcf(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testdae669b09d29d1d05e81(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa3645755a60c69fe8af4(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5500c0af0cbb6a8efc04(YAML::Emitter& out) +{ + out << YAML::BeginDoc; + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6528fe35c2b993cbd28b(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test072a41bf81e5b4dcd7d2(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3b47e24ba197ca8f686b(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test938c1c274b5ebf36c6b2(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testeea818614d4fbef183a8(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test18533eabe468baceac59(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste239cd01ef68ce26375d(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd3a9b36f8218cd633402(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa899f4512569981104e8(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test230a8fd0d19c5e15963b(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4fa431a3bea1c616f8d0(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testdd05d8f0df4f1ba79b8f(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0cb381d8a384434a2646(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testeadefbe24693d510ac03(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0b43e898410a9da3db1a(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test450ed0f6d19326bab043(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test38b7c3f09ffb6f4e73a5(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testab434195f62ee39997ae(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testdce4c351d6c426d24f14(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2363249f46e86ae9bd64(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6225a910ac0a5ce7304f(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf7898be54854e4587c54(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1ab55f98773e2e58c659(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf116d0bf1446d5e989db(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test90df709c20ab5305b5b0(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test37e041f7726819b98004(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5c13c8d0762eb77abbbe(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3c9ec0009e080492d6a0(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd016b2610a9701c799be(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test12e858bf6ec981811cc8(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndDoc; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0e09fd8b6ac12a309a36(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndDoc; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testca30dc12961feab24a33(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test162ca62af5cdf9d02507(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste3a7658df7a81c1ce8e5(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9dac5e4f0e78f96fcaad(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testaf2e952791b73c6bf78c(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test82b161574e0926b9c854(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test13c3f29be0e6b7bc92b1(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("anchor"); + out << "foo"; + out << YAML::VerbatimTag("tag"); + out << YAML::Anchor("other"); + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("tag", 1, "foo"); + EXPECT_SCALAR("tag", 2, "bar"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste87c7e9ce16fd2ac5f0e(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testeed7f7f244221932d32f(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test31a5563bfa532571339f(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test502ab92aab5195ff4759(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testdbe2ce5bc02435009b2c(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test06b8d2cc9bbb233d55d5(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << "foo"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9adf48ae5d6dff37e89a(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << "foo"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test398282871dcc1c7f8dbe(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2e2b3c35732210898be1(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test155697ae715940b6d804(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb01c87881d846bb10ecd(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test84a9d3d2ae4eaacc9c98(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb836cd5dc876cf6eb204(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4aa81dc715c5e5c53de1(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testfa8ba9d405de1af93537(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3c07c460dae114d3f278(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf513330011b92283e713(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test88667a8fe856748b4dc6(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7cbc7ae88a6b60d3cb54(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test8b126d00ee878273f3e9(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test414dcec883b2fb2668d9(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test41754fe2ab40560f1afe(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test39b7a9ee0ccb5580ef60(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1f4cbfdb2f53d041fb74(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testc20612e8922a8eeba24d(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test693f48133cf726f1e05c(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test12b26bfed7a24736dd8b(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test41d6ec7f045897841e9c(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2bc8d1d6e4ec042ede3e(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test647ff876c844ad7540ff(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test844c1bcb896dde8ea51b(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testbcf04a5174e8505d1891(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testdb6c8ca130035d7a271f(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa0db96f3d93a255f2201(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4fb3eaac714942122715(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test634678f31daa20127d6c(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1dd395a1149e46dcc208(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testebc585cbde90d10a0af1(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd1ecec189e73f8932485(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf8fc72597f0a41b22daa(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd01959c5c228946c8759(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste8236a9672d9244ca486(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test22bd5d24dbd3f0670f97(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0f2c6cac0ce0e624eb08(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2ed2eef7f03696ca3c94(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6fe33177e10d14328a14(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0ea79e93c3439d90bdb8(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2ab970621d7e037153c9(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4229059ec3d639faf4b2(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6df809b4712b73c8577f(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test37a0a34b2bef743d8241(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd6c37c1e50617419a37d(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2fb71689fb176533159c(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa91d7999dd9b43fb5827(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test8dfd4533e2891d3861ec(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0a9b0c29dfcf4f071eb9(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3882a796318e573b115d(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1ade39a1572a12eda7b8(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd308c7e19671725523cd(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1ac58dc569ce7b4eebdf(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5fe4c34b163d0efa12d5(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test78433ff7edf3224ce58b(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test089ed50cafddf39653d6(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test809723ec7bdea45cf562(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test953cf821d2acc7898582(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0f1db947e4627596eace(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test52f3b0674f30d955eea7(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf95a488631e07f6ca914(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9b7a916f4c1e2a1ae6ee(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test54ea34948e814ef79607(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testcef62af7508e0a1e3ee3(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testffcfb27f0c904fae7833(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test31ed1460205bbc5a4a68(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7d04c8d923b046159db0(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test31b396851023614cf9fd(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5befd800aa07d83e2df7(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2df4f378f687fd80b98c(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test232f5aa6ea7e85e186c4(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test011421ad7da175099088(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf50217feca0ae03a0b03(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste4b49044063dd3c8a7ff(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testbe9295522ec1f0bc9de5(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7a18055f1e3a49f93d40(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd8eebabad65b8ef02375(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test948f36e3182f3c1aa800(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testde02b69600e5931c39ab(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5fdab21609e7017c3b86(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testfb52965f57b912ec23a4(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa3f220ead85b78154f89(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0ef1b1c26e8a1fa34ccd(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7661db62a921285da885(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndMap; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9382f466be3e19ca395f(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test33c4f45355dc7df2e2a8(YAML::Emitter& out) +{ + out << YAML::BeginMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndMap; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_MAP_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testc55c40f32c34c890acce(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb06ba64c5895f218175d(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test14adb5374833871b2d0c(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7ff7826c0f0563ce5a65(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test394e607327447b08e729(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testdf03e1437e901976c2c8(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test77467fcda467dd063050(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5bcea73651331a2357d0(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2956b3f097a16a4cd951(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3170422d0cad24cd602a(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb37f0cd80f138e8f2622(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3e00cce71da4636fa1f7(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testfd184c04759685f21abb(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test14ab4965eff0a569da16(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test271811f2df7210366780(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testfcfe8657dffc21f6cd45(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test609e44eab4ab95f31e33(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7841fc715275a45a2770(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test662c03de87ca40bd943e(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0a9475ec3c946fe11991(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test94d28ebdbee90f430eb1(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd5035afc82e23b67ce03(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testcc9788c342da4454758f(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test140974453293fdb1155d(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testdc0b80a131730e98d735(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1c5225b07d746c2bd331(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << "foo"; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa49a0be204cd2b57f17b(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testbe08cc0a08cf2cb5e7ec(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4d2a2e12689655edd77c(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4d4a25a54401f0282ceb(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test91f55feebb012ce89a93(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test1f3d0b19c6a346b087e0(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4e26682c2daf8ded04a6(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6f24e6df03922bba0d8a(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test60849eca7dc178908ff1(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test28b7db2ac68bb806e143(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test8db156db7065942bc260(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste240aced6e2292a9b091(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test468628a845426ce4a106(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa3a2d467766b74acd6fd(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5bf63d8ed606d688d869(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0d35c1487237ba7d8bdc(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb1fddc2897760d60e733(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testbaf845554a46f088bf71(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test6383f28d62ad9ce3c075(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test88a4c1cc11b99a61eccd(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4716a2cf58a70705987b(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test75222084929bd0f9d38f(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test2fb23c79eec625216523(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb1699a6b7c5ded480677(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testd7de744a20ca1dc099db(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test900b2dcf20981b44ea65(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test20cc330b6d1171584aed(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5ea8e3642fab864fb09d(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test42e21cbc65f534972ead(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test14e3b5dca1d7a5a0c957(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9bd4800a58394b172738(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb715a2b66987a872ced8(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste9b56880009cc6899131(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test21f96f767e38471c9d4d(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa8aebba05fc1858c0a6c(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste6e7442377049b17ee9e(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test428b593e283163fee752(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0b6c63323da4bf9798c2(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test0f4c45c39fe39dfc8a1d(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb8043a7ae1de42dd81db(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test4d9b278579ffb76fc56d(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test672fc8b6d281f82b9332(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb406d378fa0df952b051(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test68a227d03f20863f37e4(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testcee8582fd340377bda46(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test06fd48e8c86baf6fc05b(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test70b4ccbf71c0716bf8e4(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test449c2b349be8da36682b(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9620fa69718e3b4fe391(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test3faaebe701bea6f8ee39(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test763ee61808091c7a354d(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test81b0d6b575228cde91e5(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testb607ae3c5d560092e37b(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testa53c54726737df14a5dd(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginSeq; + out << "foo"; + out << YAML::EndSeq; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SEQ_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test071d73b309a1365e0b07(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf8f45511528fa28cddcb(YAML::Emitter& out) +{ + out << YAML::Comment("comment"); + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testabdd2bf3bdf550e3dd60(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test53424b35498a73fbede9(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testf0c6c1a1afced157d6a5(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST teste45dbac33918e0fee74f(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test903c7ab3d09d4323107f(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test5d39d351680dba4be04b(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << YAML::Comment("comment"); + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testaa1e8d6d4385aab47bcd(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << YAML::Comment("comment"); + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test9bd238b748ced1db588b(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::Comment("comment"); + out << YAML::EndMap; + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST testec1cdffaae8842854947(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::Comment("comment"); + out << YAML::EndSeq; + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test30727d97de63c1ad395a(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +TEST test7adafdc8be65a5d610bf(YAML::Emitter& out) +{ + out << YAML::BeginSeq; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::BeginMap; + out << "foo"; + out << "bar"; + out << YAML::EndMap; + out << YAML::EndSeq; + out << YAML::Comment("comment"); + + HANDLE(out.c_str()); + EXPECT_DOC_START(); + EXPECT_SEQ_START("?", 0); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_MAP_START("?", 0); + EXPECT_SCALAR("?", 0, "foo"); + EXPECT_SCALAR("?", 0, "bar"); + EXPECT_MAP_END(); + EXPECT_SEQ_END(); + EXPECT_DOC_END(); + DONE(); +} +} +#endif // YAML_GEN_TESTS + +void RunGenEmitterTests(int& passed, int& total) +{ +#ifdef YAML_GEN_TESTS + RunGenEmitterTest(&Emitter::test02571eee35ac0cbd3777, "test02571eee35ac0cbd3777", passed, total); + RunGenEmitterTest(&Emitter::test71b969ca18898d226320, "test71b969ca18898d226320", passed, total); + RunGenEmitterTest(&Emitter::testd69e4ea95ce6f221c6e7, "testd69e4ea95ce6f221c6e7", passed, total); + RunGenEmitterTest(&Emitter::testffbfd295ad9bef4deb00, "testffbfd295ad9bef4deb00", passed, total); + RunGenEmitterTest(&Emitter::test6a459b2fe1f6e961e1a7, "test6a459b2fe1f6e961e1a7", passed, total); + RunGenEmitterTest(&Emitter::test869ab95640c9933ed4d6, "test869ab95640c9933ed4d6", passed, total); + RunGenEmitterTest(&Emitter::test433c0771f40ac3ba853e, "test433c0771f40ac3ba853e", passed, total); + RunGenEmitterTest(&Emitter::teste181778974c4003bc5a4, "teste181778974c4003bc5a4", passed, total); + RunGenEmitterTest(&Emitter::testf8cb7e3f1b11791f53b8, "testf8cb7e3f1b11791f53b8", passed, total); + RunGenEmitterTest(&Emitter::test3c48ed06807100f0a111, "test3c48ed06807100f0a111", passed, total); + RunGenEmitterTest(&Emitter::testb13f7b031f425b0e383f, "testb13f7b031f425b0e383f", passed, total); + RunGenEmitterTest(&Emitter::testb77284234d3fbe8b24a0, "testb77284234d3fbe8b24a0", passed, total); + RunGenEmitterTest(&Emitter::test9c56fd285b563327a340, "test9c56fd285b563327a340", passed, total); + RunGenEmitterTest(&Emitter::test1c08639d56176e64c885, "test1c08639d56176e64c885", passed, total); + RunGenEmitterTest(&Emitter::test94c8742f8cab3cec1b4a, "test94c8742f8cab3cec1b4a", passed, total); + RunGenEmitterTest(&Emitter::test79d1806ceb3ecebfa60b, "test79d1806ceb3ecebfa60b", passed, total); + RunGenEmitterTest(&Emitter::test360afe50348ec36569d3, "test360afe50348ec36569d3", passed, total); + RunGenEmitterTest(&Emitter::teste599b3fc1857f4265d3b, "teste599b3fc1857f4265d3b", passed, total); + RunGenEmitterTest(&Emitter::test88adf7adb474ad063424, "test88adf7adb474ad063424", passed, total); + RunGenEmitterTest(&Emitter::test0978ca6f6358ea06e024, "test0978ca6f6358ea06e024", passed, total); + RunGenEmitterTest(&Emitter::testd915f57fca4b0f6d77b4, "testd915f57fca4b0f6d77b4", passed, total); + RunGenEmitterTest(&Emitter::test1fe1f22496f2a0ffd64e, "test1fe1f22496f2a0ffd64e", passed, total); + RunGenEmitterTest(&Emitter::test76422a4077d3bdd03579, "test76422a4077d3bdd03579", passed, total); + RunGenEmitterTest(&Emitter::test92b168a497cb0c7e3144, "test92b168a497cb0c7e3144", passed, total); + RunGenEmitterTest(&Emitter::testa93925b3ae311a7f11d4, "testa93925b3ae311a7f11d4", passed, total); + RunGenEmitterTest(&Emitter::test2dd1aaf6a1c1924557d0, "test2dd1aaf6a1c1924557d0", passed, total); + RunGenEmitterTest(&Emitter::test6ec0585d0f0945ad9dae, "test6ec0585d0f0945ad9dae", passed, total); + RunGenEmitterTest(&Emitter::test7e00bca835d55844bbfe, "test7e00bca835d55844bbfe", passed, total); + RunGenEmitterTest(&Emitter::test70912c7d920a0597bbb2, "test70912c7d920a0597bbb2", passed, total); + RunGenEmitterTest(&Emitter::test16eacbf77bccde360e54, "test16eacbf77bccde360e54", passed, total); + RunGenEmitterTest(&Emitter::test556e0c86efb0716d2778, "test556e0c86efb0716d2778", passed, total); + RunGenEmitterTest(&Emitter::test71b64326d72fe100e6ad, "test71b64326d72fe100e6ad", passed, total); + RunGenEmitterTest(&Emitter::test0c7bb03fbd6b52ea3ad6, "test0c7bb03fbd6b52ea3ad6", passed, total); + RunGenEmitterTest(&Emitter::testb819efb5742c1176df98, "testb819efb5742c1176df98", passed, total); + RunGenEmitterTest(&Emitter::test1f7b7cd5a13070c723d3, "test1f7b7cd5a13070c723d3", passed, total); + RunGenEmitterTest(&Emitter::test32126a88cb2b7311e779, "test32126a88cb2b7311e779", passed, total); + RunGenEmitterTest(&Emitter::testd7f952713bde5ce2f9e7, "testd7f952713bde5ce2f9e7", passed, total); + RunGenEmitterTest(&Emitter::test5030b4f2d1efb798f320, "test5030b4f2d1efb798f320", passed, total); + RunGenEmitterTest(&Emitter::testb9015537b9a9e09b8ec8, "testb9015537b9a9e09b8ec8", passed, total); + RunGenEmitterTest(&Emitter::test03229f6d33fa9007a65d, "test03229f6d33fa9007a65d", passed, total); + RunGenEmitterTest(&Emitter::testf998264dcfd0dba06c0a, "testf998264dcfd0dba06c0a", passed, total); + RunGenEmitterTest(&Emitter::test7defadc52eddfbf766aa, "test7defadc52eddfbf766aa", passed, total); + RunGenEmitterTest(&Emitter::test55a7c58211689c7815b2, "test55a7c58211689c7815b2", passed, total); + RunGenEmitterTest(&Emitter::testc3873d954433175e0143, "testc3873d954433175e0143", passed, total); + RunGenEmitterTest(&Emitter::test81fb6bf1f976e0ad3fba, "test81fb6bf1f976e0ad3fba", passed, total); + RunGenEmitterTest(&Emitter::test29e7ff04645f56a7ea2f, "test29e7ff04645f56a7ea2f", passed, total); + RunGenEmitterTest(&Emitter::testce0089a55f926d311ff4, "testce0089a55f926d311ff4", passed, total); + RunGenEmitterTest(&Emitter::testd1d301bbc73ec11cd49b, "testd1d301bbc73ec11cd49b", passed, total); + RunGenEmitterTest(&Emitter::test4640bfb42711b7209ef9, "test4640bfb42711b7209ef9", passed, total); + RunGenEmitterTest(&Emitter::test1133d19fc3a4ec9fb3e8, "test1133d19fc3a4ec9fb3e8", passed, total); + RunGenEmitterTest(&Emitter::test4a6d083241180899f7ed, "test4a6d083241180899f7ed", passed, total); + RunGenEmitterTest(&Emitter::testbadb5b228a4db78efac0, "testbadb5b228a4db78efac0", passed, total); + RunGenEmitterTest(&Emitter::test5c6d607ed1ad046568e1, "test5c6d607ed1ad046568e1", passed, total); + RunGenEmitterTest(&Emitter::testac34cde109884bb6876b, "testac34cde109884bb6876b", passed, total); + RunGenEmitterTest(&Emitter::test5c19597d5336d541f990, "test5c19597d5336d541f990", passed, total); + RunGenEmitterTest(&Emitter::test39e174ed33d5508a61ce, "test39e174ed33d5508a61ce", passed, total); + RunGenEmitterTest(&Emitter::test43e26cf94441cee4a0c4, "test43e26cf94441cee4a0c4", passed, total); + RunGenEmitterTest(&Emitter::test06afa8e5b516630fc8da, "test06afa8e5b516630fc8da", passed, total); + RunGenEmitterTest(&Emitter::test4d109db0282a7797cdcb, "test4d109db0282a7797cdcb", passed, total); + RunGenEmitterTest(&Emitter::test0c1c00113c20dfa650a9, "test0c1c00113c20dfa650a9", passed, total); + RunGenEmitterTest(&Emitter::testccd7f2183f06483ee5e0, "testccd7f2183f06483ee5e0", passed, total); + RunGenEmitterTest(&Emitter::test52e25e363a17f37c296f, "test52e25e363a17f37c296f", passed, total); + RunGenEmitterTest(&Emitter::testdd81d16d3bdd8636af16, "testdd81d16d3bdd8636af16", passed, total); + RunGenEmitterTest(&Emitter::testd76e8eb5043431c3434e, "testd76e8eb5043431c3434e", passed, total); + RunGenEmitterTest(&Emitter::teste03be55aff3dc08f07a1, "teste03be55aff3dc08f07a1", passed, total); + RunGenEmitterTest(&Emitter::test8ba3e94c45f696c5027b, "test8ba3e94c45f696c5027b", passed, total); + RunGenEmitterTest(&Emitter::test90e45bcf67b89e31fd12, "test90e45bcf67b89e31fd12", passed, total); + RunGenEmitterTest(&Emitter::test0b7c4e535bfebfa3c85d, "test0b7c4e535bfebfa3c85d", passed, total); + RunGenEmitterTest(&Emitter::test3a1c08f490683d254cda, "test3a1c08f490683d254cda", passed, total); + RunGenEmitterTest(&Emitter::test926cd343d3999525d9ce, "test926cd343d3999525d9ce", passed, total); + RunGenEmitterTest(&Emitter::test1e5dd6b1e4dfb59f0346, "test1e5dd6b1e4dfb59f0346", passed, total); + RunGenEmitterTest(&Emitter::test0f064b30c1187ff2dd4b, "test0f064b30c1187ff2dd4b", passed, total); + RunGenEmitterTest(&Emitter::test58fd20c1736964e12b53, "test58fd20c1736964e12b53", passed, total); + RunGenEmitterTest(&Emitter::testbddd187d973b632dc188, "testbddd187d973b632dc188", passed, total); + RunGenEmitterTest(&Emitter::test5bc168e49ab7503fd2e1, "test5bc168e49ab7503fd2e1", passed, total); + RunGenEmitterTest(&Emitter::test712e139d81db4e14196d, "test712e139d81db4e14196d", passed, total); + RunGenEmitterTest(&Emitter::test48130bfdef5d192b888e, "test48130bfdef5d192b888e", passed, total); + RunGenEmitterTest(&Emitter::test27552de54635da852895, "test27552de54635da852895", passed, total); + RunGenEmitterTest(&Emitter::test6529691d17594d5abeb6, "test6529691d17594d5abeb6", passed, total); + RunGenEmitterTest(&Emitter::test46b8a7b9d2461d80e0c0, "test46b8a7b9d2461d80e0c0", passed, total); + RunGenEmitterTest(&Emitter::testbd1cb845de056e97a301, "testbd1cb845de056e97a301", passed, total); + RunGenEmitterTest(&Emitter::testfe1f94c842b37340db76, "testfe1f94c842b37340db76", passed, total); + RunGenEmitterTest(&Emitter::teste3c7fbf8af4d82e891e3, "teste3c7fbf8af4d82e891e3", passed, total); + RunGenEmitterTest(&Emitter::testd6800d90d6d037d02ace, "testd6800d90d6d037d02ace", passed, total); + RunGenEmitterTest(&Emitter::testdf987230fa431b7a8f1b, "testdf987230fa431b7a8f1b", passed, total); + RunGenEmitterTest(&Emitter::testcd22b774448a8b15345e, "testcd22b774448a8b15345e", passed, total); + RunGenEmitterTest(&Emitter::test591a370a1ce302d23688, "test591a370a1ce302d23688", passed, total); + RunGenEmitterTest(&Emitter::test5e56c5800a9f2c4591ff, "test5e56c5800a9f2c4591ff", passed, total); + RunGenEmitterTest(&Emitter::test72f6d368cc2f52b488bd, "test72f6d368cc2f52b488bd", passed, total); + RunGenEmitterTest(&Emitter::test6786da34791cbab71591, "test6786da34791cbab71591", passed, total); + RunGenEmitterTest(&Emitter::test6d53136f35632180e2e8, "test6d53136f35632180e2e8", passed, total); + RunGenEmitterTest(&Emitter::test01020a01f84721d7fb07, "test01020a01f84721d7fb07", passed, total); + RunGenEmitterTest(&Emitter::testc3ab223703ef17e47ec7, "testc3ab223703ef17e47ec7", passed, total); + RunGenEmitterTest(&Emitter::test033db6218db214ae5ef9, "test033db6218db214ae5ef9", passed, total); + RunGenEmitterTest(&Emitter::test38fe09343ac97f51b38f, "test38fe09343ac97f51b38f", passed, total); + RunGenEmitterTest(&Emitter::test99eb29693d619703a052, "test99eb29693d619703a052", passed, total); + RunGenEmitterTest(&Emitter::teste9e58998a49132e15fb4, "teste9e58998a49132e15fb4", passed, total); + RunGenEmitterTest(&Emitter::testc1b4fba9280329b30583, "testc1b4fba9280329b30583", passed, total); + RunGenEmitterTest(&Emitter::test2f8651438d44de183d22, "test2f8651438d44de183d22", passed, total); + RunGenEmitterTest(&Emitter::test4c506bf0bc7a972cb62d, "test4c506bf0bc7a972cb62d", passed, total); + RunGenEmitterTest(&Emitter::test6a42214b8698a0e87f5f, "test6a42214b8698a0e87f5f", passed, total); + RunGenEmitterTest(&Emitter::teste0b5020ccbc0cbc7f699, "teste0b5020ccbc0cbc7f699", passed, total); + RunGenEmitterTest(&Emitter::test3fb453ac1de7a2d37a16, "test3fb453ac1de7a2d37a16", passed, total); + RunGenEmitterTest(&Emitter::test4d3236ecd88c5faa74e8, "test4d3236ecd88c5faa74e8", passed, total); + RunGenEmitterTest(&Emitter::test116230234c38c68eb060, "test116230234c38c68eb060", passed, total); + RunGenEmitterTest(&Emitter::testb7c63d73350b11bf4a56, "testb7c63d73350b11bf4a56", passed, total); + RunGenEmitterTest(&Emitter::test26ae0a3b97fb1c7743bf, "test26ae0a3b97fb1c7743bf", passed, total); + RunGenEmitterTest(&Emitter::testeabf01d5500c4f5c9de5, "testeabf01d5500c4f5c9de5", passed, total); + RunGenEmitterTest(&Emitter::testf9195cd2fb4c57783870, "testf9195cd2fb4c57783870", passed, total); + RunGenEmitterTest(&Emitter::test8c7159f70888a6c5548e, "test8c7159f70888a6c5548e", passed, total); + RunGenEmitterTest(&Emitter::testba96c9cdf5e82c9ebd0f, "testba96c9cdf5e82c9ebd0f", passed, total); + RunGenEmitterTest(&Emitter::test6cbb2232cc1e43752958, "test6cbb2232cc1e43752958", passed, total); + RunGenEmitterTest(&Emitter::test2bc126cc8be9e3d0a5bb, "test2bc126cc8be9e3d0a5bb", passed, total); + RunGenEmitterTest(&Emitter::testb053b9b6ee7c7eecc798, "testb053b9b6ee7c7eecc798", passed, total); + RunGenEmitterTest(&Emitter::testda8339179085c81ac7a9, "testda8339179085c81ac7a9", passed, total); + RunGenEmitterTest(&Emitter::testf38e7a065a9bda416bf0, "testf38e7a065a9bda416bf0", passed, total); + RunGenEmitterTest(&Emitter::test5345180f2a8a65af5b72, "test5345180f2a8a65af5b72", passed, total); + RunGenEmitterTest(&Emitter::test7aee5968853276b78e65, "test7aee5968853276b78e65", passed, total); + RunGenEmitterTest(&Emitter::test1c20b15f6680fd1fa304, "test1c20b15f6680fd1fa304", passed, total); + RunGenEmitterTest(&Emitter::test3ad355d8aa94a80ed9d0, "test3ad355d8aa94a80ed9d0", passed, total); + RunGenEmitterTest(&Emitter::test717b89ec9b7b004e5c17, "test717b89ec9b7b004e5c17", passed, total); + RunGenEmitterTest(&Emitter::testc540c8d6d92913953ef8, "testc540c8d6d92913953ef8", passed, total); + RunGenEmitterTest(&Emitter::test805391f6964c07b1fc51, "test805391f6964c07b1fc51", passed, total); + RunGenEmitterTest(&Emitter::testafc978dbd9b5d8005968, "testafc978dbd9b5d8005968", passed, total); + RunGenEmitterTest(&Emitter::testf137897e42e659d45548, "testf137897e42e659d45548", passed, total); + RunGenEmitterTest(&Emitter::test41c10a5f012922d6d240, "test41c10a5f012922d6d240", passed, total); + RunGenEmitterTest(&Emitter::test6d46af9b0e1bab6eefd2, "test6d46af9b0e1bab6eefd2", passed, total); + RunGenEmitterTest(&Emitter::test6908c1e71bca5b5a09b6, "test6908c1e71bca5b5a09b6", passed, total); + RunGenEmitterTest(&Emitter::test158d6160ee94d7f929c0, "test158d6160ee94d7f929c0", passed, total); + RunGenEmitterTest(&Emitter::test07186666318de7b13975, "test07186666318de7b13975", passed, total); + RunGenEmitterTest(&Emitter::testdcb6011d1dbc47e024b4, "testdcb6011d1dbc47e024b4", passed, total); + RunGenEmitterTest(&Emitter::test998e6b11c32e19f91a43, "test998e6b11c32e19f91a43", passed, total); + RunGenEmitterTest(&Emitter::test7b009b420c34f753e2dc, "test7b009b420c34f753e2dc", passed, total); + RunGenEmitterTest(&Emitter::testba4c5b4eedf23c16ab44, "testba4c5b4eedf23c16ab44", passed, total); + RunGenEmitterTest(&Emitter::test022d120061a5c77c6640, "test022d120061a5c77c6640", passed, total); + RunGenEmitterTest(&Emitter::testeb346f4b70732835631f, "testeb346f4b70732835631f", passed, total); + RunGenEmitterTest(&Emitter::testade70114082f144726ee, "testade70114082f144726ee", passed, total); + RunGenEmitterTest(&Emitter::testf2b68aae6173ab6ad66d, "testf2b68aae6173ab6ad66d", passed, total); + RunGenEmitterTest(&Emitter::teste9a962c26a72ea4d3f8d, "teste9a962c26a72ea4d3f8d", passed, total); + RunGenEmitterTest(&Emitter::testa9603ff993f8a8d47b5d, "testa9603ff993f8a8d47b5d", passed, total); + RunGenEmitterTest(&Emitter::test2b70cf1579b37e0fb086, "test2b70cf1579b37e0fb086", passed, total); + RunGenEmitterTest(&Emitter::test3790d77103bac72dc302, "test3790d77103bac72dc302", passed, total); + RunGenEmitterTest(&Emitter::testadfa25cb2fd5a9346102, "testadfa25cb2fd5a9346102", passed, total); + RunGenEmitterTest(&Emitter::test9764ad298ba1fe9ecfa8, "test9764ad298ba1fe9ecfa8", passed, total); + RunGenEmitterTest(&Emitter::test22f20fac5e02211edadc, "test22f20fac5e02211edadc", passed, total); + RunGenEmitterTest(&Emitter::test8b3b22c8ffd679b15623, "test8b3b22c8ffd679b15623", passed, total); + RunGenEmitterTest(&Emitter::test438d1581dec9088389d7, "test438d1581dec9088389d7", passed, total); + RunGenEmitterTest(&Emitter::test0b417297c8e11f038c7c, "test0b417297c8e11f038c7c", passed, total); + RunGenEmitterTest(&Emitter::testa3686f0b87652d4640c2, "testa3686f0b87652d4640c2", passed, total); + RunGenEmitterTest(&Emitter::testd6f021791f2162c85174, "testd6f021791f2162c85174", passed, total); + RunGenEmitterTest(&Emitter::test3d34018a42371ab9fbcd, "test3d34018a42371ab9fbcd", passed, total); + RunGenEmitterTest(&Emitter::test7a9287f053731d912e63, "test7a9287f053731d912e63", passed, total); + RunGenEmitterTest(&Emitter::testa9aa047a659d330a4a8b, "testa9aa047a659d330a4a8b", passed, total); + RunGenEmitterTest(&Emitter::test74e66203a050c2ce6c17, "test74e66203a050c2ce6c17", passed, total); + RunGenEmitterTest(&Emitter::test7338d0bbe29dd57fab54, "test7338d0bbe29dd57fab54", passed, total); + RunGenEmitterTest(&Emitter::testbd4f6be8cdb35c6f251d, "testbd4f6be8cdb35c6f251d", passed, total); + RunGenEmitterTest(&Emitter::test8f0d1345830b83dfc1b7, "test8f0d1345830b83dfc1b7", passed, total); + RunGenEmitterTest(&Emitter::testa4e1c63bc2832a9ffb90, "testa4e1c63bc2832a9ffb90", passed, total); + RunGenEmitterTest(&Emitter::test9d5abf8cc60b9bd0d314, "test9d5abf8cc60b9bd0d314", passed, total); + RunGenEmitterTest(&Emitter::test332175e66c385ed1a97e, "test332175e66c385ed1a97e", passed, total); + RunGenEmitterTest(&Emitter::test34238765b14f93c81e57, "test34238765b14f93c81e57", passed, total); + RunGenEmitterTest(&Emitter::test10797ce06190a3866a08, "test10797ce06190a3866a08", passed, total); + RunGenEmitterTest(&Emitter::teste92cd495aff9e502a1ca, "teste92cd495aff9e502a1ca", passed, total); + RunGenEmitterTest(&Emitter::testf02ffda4a54ad1390ab6, "testf02ffda4a54ad1390ab6", passed, total); + RunGenEmitterTest(&Emitter::test252e5030af4f0ab7bf2b, "test252e5030af4f0ab7bf2b", passed, total); + RunGenEmitterTest(&Emitter::testfe3d96e64a5db1098e2d, "testfe3d96e64a5db1098e2d", passed, total); + RunGenEmitterTest(&Emitter::test94c9f1a9c03f970dde84, "test94c9f1a9c03f970dde84", passed, total); + RunGenEmitterTest(&Emitter::testd16f010f550e384c3e59, "testd16f010f550e384c3e59", passed, total); + RunGenEmitterTest(&Emitter::test9b6529d7a517cd7dbc13, "test9b6529d7a517cd7dbc13", passed, total); + RunGenEmitterTest(&Emitter::test706fdc6bcd111cd4de81, "test706fdc6bcd111cd4de81", passed, total); + RunGenEmitterTest(&Emitter::test7ce41e86a2afa55d59d7, "test7ce41e86a2afa55d59d7", passed, total); + RunGenEmitterTest(&Emitter::test14aebe584c51e7c2a682, "test14aebe584c51e7c2a682", passed, total); + RunGenEmitterTest(&Emitter::testb9987fabfcd184f82c65, "testb9987fabfcd184f82c65", passed, total); + RunGenEmitterTest(&Emitter::testbe1a5e58793366c0c07a, "testbe1a5e58793366c0c07a", passed, total); + RunGenEmitterTest(&Emitter::test1eac7fa4e151174d20c5, "test1eac7fa4e151174d20c5", passed, total); + RunGenEmitterTest(&Emitter::test5a372a31cdbea0111962, "test5a372a31cdbea0111962", passed, total); + RunGenEmitterTest(&Emitter::testcc1a35b80f0b02e1255e, "testcc1a35b80f0b02e1255e", passed, total); + RunGenEmitterTest(&Emitter::testb04cc0e338c9b30cffa3, "testb04cc0e338c9b30cffa3", passed, total); + RunGenEmitterTest(&Emitter::testb0a82e7bf3b5bdebdd9c, "testb0a82e7bf3b5bdebdd9c", passed, total); + RunGenEmitterTest(&Emitter::test0d883c1652c0b59e6643, "test0d883c1652c0b59e6643", passed, total); + RunGenEmitterTest(&Emitter::testa38bc626fc7e3454333b, "testa38bc626fc7e3454333b", passed, total); + RunGenEmitterTest(&Emitter::test8bea94aa1202a12d9ae9, "test8bea94aa1202a12d9ae9", passed, total); + RunGenEmitterTest(&Emitter::test24a263a0eb80caaaea4b, "test24a263a0eb80caaaea4b", passed, total); + RunGenEmitterTest(&Emitter::testb86b045d63884140fd1d, "testb86b045d63884140fd1d", passed, total); + RunGenEmitterTest(&Emitter::test9d261e666ae24a9cfc70, "test9d261e666ae24a9cfc70", passed, total); + RunGenEmitterTest(&Emitter::test331919d746512b1bd2dd, "test331919d746512b1bd2dd", passed, total); + RunGenEmitterTest(&Emitter::test58b5cb1c0a14ca820fa0, "test58b5cb1c0a14ca820fa0", passed, total); + RunGenEmitterTest(&Emitter::testfcc5a2d53d8b78bff00e, "testfcc5a2d53d8b78bff00e", passed, total); + RunGenEmitterTest(&Emitter::test4e18e90b6551c4af46b7, "test4e18e90b6551c4af46b7", passed, total); + RunGenEmitterTest(&Emitter::testfd0cdd7da5ea80def96c, "testfd0cdd7da5ea80def96c", passed, total); + RunGenEmitterTest(&Emitter::test31fa2c218bc9f47d31b5, "test31fa2c218bc9f47d31b5", passed, total); + RunGenEmitterTest(&Emitter::test486f1defd8f55e9519a9, "test486f1defd8f55e9519a9", passed, total); + RunGenEmitterTest(&Emitter::testbd67707be3be50792791, "testbd67707be3be50792791", passed, total); + RunGenEmitterTest(&Emitter::test1a5d67d4591ad4c8d1e7, "test1a5d67d4591ad4c8d1e7", passed, total); + RunGenEmitterTest(&Emitter::testd1b42a0d7e5156b00706, "testd1b42a0d7e5156b00706", passed, total); + RunGenEmitterTest(&Emitter::test120e16514220d9f1b114, "test120e16514220d9f1b114", passed, total); + RunGenEmitterTest(&Emitter::testf3200a3148254d3357d3, "testf3200a3148254d3357d3", passed, total); + RunGenEmitterTest(&Emitter::test291bb8d225b135c1f926, "test291bb8d225b135c1f926", passed, total); + RunGenEmitterTest(&Emitter::testd89446599f31a400dcec, "testd89446599f31a400dcec", passed, total); + RunGenEmitterTest(&Emitter::test10810f50a49dfe065bfa, "test10810f50a49dfe065bfa", passed, total); + RunGenEmitterTest(&Emitter::testb1f754216d575a8cc3af, "testb1f754216d575a8cc3af", passed, total); + RunGenEmitterTest(&Emitter::testb9d82396ef66bed18aed, "testb9d82396ef66bed18aed", passed, total); + RunGenEmitterTest(&Emitter::test5469f77f98702583e6ea, "test5469f77f98702583e6ea", passed, total); + RunGenEmitterTest(&Emitter::testea4d055788f9af327d2e, "testea4d055788f9af327d2e", passed, total); + RunGenEmitterTest(&Emitter::test08ac3b6e6f8814cdc77a, "test08ac3b6e6f8814cdc77a", passed, total); + RunGenEmitterTest(&Emitter::test9e8e5ac1687da916f607, "test9e8e5ac1687da916f607", passed, total); + RunGenEmitterTest(&Emitter::test6265b47bba1fd6839697, "test6265b47bba1fd6839697", passed, total); + RunGenEmitterTest(&Emitter::testa78aad03d3d6c0cd9810, "testa78aad03d3d6c0cd9810", passed, total); + RunGenEmitterTest(&Emitter::test050fb21ac4e0ec123acc, "test050fb21ac4e0ec123acc", passed, total); + RunGenEmitterTest(&Emitter::test41e74fd70f88555712db, "test41e74fd70f88555712db", passed, total); + RunGenEmitterTest(&Emitter::testc066eeba93b49bfd475e, "testc066eeba93b49bfd475e", passed, total); + RunGenEmitterTest(&Emitter::testba918d828779830ff775, "testba918d828779830ff775", passed, total); + RunGenEmitterTest(&Emitter::test9fc69104bdb595977460, "test9fc69104bdb595977460", passed, total); + RunGenEmitterTest(&Emitter::test0dd65e43cc41ad032d71, "test0dd65e43cc41ad032d71", passed, total); + RunGenEmitterTest(&Emitter::test324295b9fb6b58411e30, "test324295b9fb6b58411e30", passed, total); + RunGenEmitterTest(&Emitter::test8aebc8d0e0485dfeb252, "test8aebc8d0e0485dfeb252", passed, total); + RunGenEmitterTest(&Emitter::testd222de940e9a99d43cdd, "testd222de940e9a99d43cdd", passed, total); + RunGenEmitterTest(&Emitter::test9b7e3c531ced5ced7f08, "test9b7e3c531ced5ced7f08", passed, total); + RunGenEmitterTest(&Emitter::testcfc4d3d407725683e731, "testcfc4d3d407725683e731", passed, total); + RunGenEmitterTest(&Emitter::test76848f10a77db08e038e, "test76848f10a77db08e038e", passed, total); + RunGenEmitterTest(&Emitter::testa4c728e62357ca05c45c, "testa4c728e62357ca05c45c", passed, total); + RunGenEmitterTest(&Emitter::test666ae3bb483cb7d83170, "test666ae3bb483cb7d83170", passed, total); + RunGenEmitterTest(&Emitter::test6ec557a6e48fd6900cb1, "test6ec557a6e48fd6900cb1", passed, total); + RunGenEmitterTest(&Emitter::test18a5d0db57d08d737b99, "test18a5d0db57d08d737b99", passed, total); + RunGenEmitterTest(&Emitter::testd974ded8f39d6b77c0a1, "testd974ded8f39d6b77c0a1", passed, total); + RunGenEmitterTest(&Emitter::test6c6d47297f6ea03c588b, "test6c6d47297f6ea03c588b", passed, total); + RunGenEmitterTest(&Emitter::testfb543650c644777c82ec, "testfb543650c644777c82ec", passed, total); + RunGenEmitterTest(&Emitter::test85cf601a990a9689b6c2, "test85cf601a990a9689b6c2", passed, total); + RunGenEmitterTest(&Emitter::testae2c05021a270e7e6ce6, "testae2c05021a270e7e6ce6", passed, total); + RunGenEmitterTest(&Emitter::testceebe4a07ec516cb5a7a, "testceebe4a07ec516cb5a7a", passed, total); + RunGenEmitterTest(&Emitter::test1a2b24646720aa998cbb, "test1a2b24646720aa998cbb", passed, total); + RunGenEmitterTest(&Emitter::testf415efe81b5c2c8112a2, "testf415efe81b5c2c8112a2", passed, total); + RunGenEmitterTest(&Emitter::test0f1b297a0cb08c094411, "test0f1b297a0cb08c094411", passed, total); + RunGenEmitterTest(&Emitter::test1b49cc3347751dcb09a9, "test1b49cc3347751dcb09a9", passed, total); + RunGenEmitterTest(&Emitter::testffe72c176661d48910bd, "testffe72c176661d48910bd", passed, total); + RunGenEmitterTest(&Emitter::testf3f2d1d0e79f326b3d2f, "testf3f2d1d0e79f326b3d2f", passed, total); + RunGenEmitterTest(&Emitter::testeb66a6725a958bb76923, "testeb66a6725a958bb76923", passed, total); + RunGenEmitterTest(&Emitter::test0a8fc83bac630f116c86, "test0a8fc83bac630f116c86", passed, total); + RunGenEmitterTest(&Emitter::test6c62ccca61f383967d91, "test6c62ccca61f383967d91", passed, total); + RunGenEmitterTest(&Emitter::test6ba9e6495bef38087e7f, "test6ba9e6495bef38087e7f", passed, total); + RunGenEmitterTest(&Emitter::test643e77d887ec7390c1c9, "test643e77d887ec7390c1c9", passed, total); + RunGenEmitterTest(&Emitter::testa9725ffe34acd33603c4, "testa9725ffe34acd33603c4", passed, total); + RunGenEmitterTest(&Emitter::test1a65df7ae90ac6ba1f22, "test1a65df7ae90ac6ba1f22", passed, total); + RunGenEmitterTest(&Emitter::test7f982251b9a09ebb1059, "test7f982251b9a09ebb1059", passed, total); + RunGenEmitterTest(&Emitter::test4b2138b3eafc346d6bd3, "test4b2138b3eafc346d6bd3", passed, total); + RunGenEmitterTest(&Emitter::testa316e26e6b940d585005, "testa316e26e6b940d585005", passed, total); + RunGenEmitterTest(&Emitter::testda2e0d2a6fd2a83cb298, "testda2e0d2a6fd2a83cb298", passed, total); + RunGenEmitterTest(&Emitter::test54aac276524c0baaecd1, "test54aac276524c0baaecd1", passed, total); + RunGenEmitterTest(&Emitter::testd1fb3fd39f4a2fda5c6a, "testd1fb3fd39f4a2fda5c6a", passed, total); + RunGenEmitterTest(&Emitter::test4aaf20817b31a62e905f, "test4aaf20817b31a62e905f", passed, total); + RunGenEmitterTest(&Emitter::test446f00cbeee81a34d936, "test446f00cbeee81a34d936", passed, total); + RunGenEmitterTest(&Emitter::testb13663976ee52dac5370, "testb13663976ee52dac5370", passed, total); + RunGenEmitterTest(&Emitter::testd245994f89c881efef06, "testd245994f89c881efef06", passed, total); + RunGenEmitterTest(&Emitter::testb6e7c5ee86f3c0559fe3, "testb6e7c5ee86f3c0559fe3", passed, total); + RunGenEmitterTest(&Emitter::testee28e38a088388ee5d9f, "testee28e38a088388ee5d9f", passed, total); + RunGenEmitterTest(&Emitter::test9b40d68cb65d34934b50, "test9b40d68cb65d34934b50", passed, total); + RunGenEmitterTest(&Emitter::test045fac0048d3cfc15d88, "test045fac0048d3cfc15d88", passed, total); + RunGenEmitterTest(&Emitter::test85c3ad95991be29b3aff, "test85c3ad95991be29b3aff", passed, total); + RunGenEmitterTest(&Emitter::test2abfed1da9a2ab365c18, "test2abfed1da9a2ab365c18", passed, total); + RunGenEmitterTest(&Emitter::testa999e4a9d0199bf463ec, "testa999e4a9d0199bf463ec", passed, total); + RunGenEmitterTest(&Emitter::test8452a26a810950ad47b2, "test8452a26a810950ad47b2", passed, total); + RunGenEmitterTest(&Emitter::test1e2b3a261f435a0f6316, "test1e2b3a261f435a0f6316", passed, total); + RunGenEmitterTest(&Emitter::test1423ee4cd0795e6ef646, "test1423ee4cd0795e6ef646", passed, total); + RunGenEmitterTest(&Emitter::testf95070e81f8def8ceec9, "testf95070e81f8def8ceec9", passed, total); + RunGenEmitterTest(&Emitter::testf533a12940040f665761, "testf533a12940040f665761", passed, total); + RunGenEmitterTest(&Emitter::test51bd09a609a537b79c8a, "test51bd09a609a537b79c8a", passed, total); + RunGenEmitterTest(&Emitter::testc10b994394aa86a1789b, "testc10b994394aa86a1789b", passed, total); + RunGenEmitterTest(&Emitter::testc5de3511ef8fa1e5841e, "testc5de3511ef8fa1e5841e", passed, total); + RunGenEmitterTest(&Emitter::test0e957613f266e5693f83, "test0e957613f266e5693f83", passed, total); + RunGenEmitterTest(&Emitter::testf36b8fb2ec772e02a48c, "testf36b8fb2ec772e02a48c", passed, total); + RunGenEmitterTest(&Emitter::test249b4ee9b0e6936bdfcf, "test249b4ee9b0e6936bdfcf", passed, total); + RunGenEmitterTest(&Emitter::testdae669b09d29d1d05e81, "testdae669b09d29d1d05e81", passed, total); + RunGenEmitterTest(&Emitter::testa3645755a60c69fe8af4, "testa3645755a60c69fe8af4", passed, total); + RunGenEmitterTest(&Emitter::test5500c0af0cbb6a8efc04, "test5500c0af0cbb6a8efc04", passed, total); + RunGenEmitterTest(&Emitter::test6528fe35c2b993cbd28b, "test6528fe35c2b993cbd28b", passed, total); + RunGenEmitterTest(&Emitter::test072a41bf81e5b4dcd7d2, "test072a41bf81e5b4dcd7d2", passed, total); + RunGenEmitterTest(&Emitter::test3b47e24ba197ca8f686b, "test3b47e24ba197ca8f686b", passed, total); + RunGenEmitterTest(&Emitter::test938c1c274b5ebf36c6b2, "test938c1c274b5ebf36c6b2", passed, total); + RunGenEmitterTest(&Emitter::testeea818614d4fbef183a8, "testeea818614d4fbef183a8", passed, total); + RunGenEmitterTest(&Emitter::test18533eabe468baceac59, "test18533eabe468baceac59", passed, total); + RunGenEmitterTest(&Emitter::teste239cd01ef68ce26375d, "teste239cd01ef68ce26375d", passed, total); + RunGenEmitterTest(&Emitter::testd3a9b36f8218cd633402, "testd3a9b36f8218cd633402", passed, total); + RunGenEmitterTest(&Emitter::testa899f4512569981104e8, "testa899f4512569981104e8", passed, total); + RunGenEmitterTest(&Emitter::test230a8fd0d19c5e15963b, "test230a8fd0d19c5e15963b", passed, total); + RunGenEmitterTest(&Emitter::test4fa431a3bea1c616f8d0, "test4fa431a3bea1c616f8d0", passed, total); + RunGenEmitterTest(&Emitter::testdd05d8f0df4f1ba79b8f, "testdd05d8f0df4f1ba79b8f", passed, total); + RunGenEmitterTest(&Emitter::test0cb381d8a384434a2646, "test0cb381d8a384434a2646", passed, total); + RunGenEmitterTest(&Emitter::testeadefbe24693d510ac03, "testeadefbe24693d510ac03", passed, total); + RunGenEmitterTest(&Emitter::test0b43e898410a9da3db1a, "test0b43e898410a9da3db1a", passed, total); + RunGenEmitterTest(&Emitter::test450ed0f6d19326bab043, "test450ed0f6d19326bab043", passed, total); + RunGenEmitterTest(&Emitter::test38b7c3f09ffb6f4e73a5, "test38b7c3f09ffb6f4e73a5", passed, total); + RunGenEmitterTest(&Emitter::testab434195f62ee39997ae, "testab434195f62ee39997ae", passed, total); + RunGenEmitterTest(&Emitter::testdce4c351d6c426d24f14, "testdce4c351d6c426d24f14", passed, total); + RunGenEmitterTest(&Emitter::test2363249f46e86ae9bd64, "test2363249f46e86ae9bd64", passed, total); + RunGenEmitterTest(&Emitter::test6225a910ac0a5ce7304f, "test6225a910ac0a5ce7304f", passed, total); + RunGenEmitterTest(&Emitter::testf7898be54854e4587c54, "testf7898be54854e4587c54", passed, total); + RunGenEmitterTest(&Emitter::test1ab55f98773e2e58c659, "test1ab55f98773e2e58c659", passed, total); + RunGenEmitterTest(&Emitter::testf116d0bf1446d5e989db, "testf116d0bf1446d5e989db", passed, total); + RunGenEmitterTest(&Emitter::test90df709c20ab5305b5b0, "test90df709c20ab5305b5b0", passed, total); + RunGenEmitterTest(&Emitter::test37e041f7726819b98004, "test37e041f7726819b98004", passed, total); + RunGenEmitterTest(&Emitter::test5c13c8d0762eb77abbbe, "test5c13c8d0762eb77abbbe", passed, total); + RunGenEmitterTest(&Emitter::test3c9ec0009e080492d6a0, "test3c9ec0009e080492d6a0", passed, total); + RunGenEmitterTest(&Emitter::testd016b2610a9701c799be, "testd016b2610a9701c799be", passed, total); + RunGenEmitterTest(&Emitter::test12e858bf6ec981811cc8, "test12e858bf6ec981811cc8", passed, total); + RunGenEmitterTest(&Emitter::test0e09fd8b6ac12a309a36, "test0e09fd8b6ac12a309a36", passed, total); + RunGenEmitterTest(&Emitter::testca30dc12961feab24a33, "testca30dc12961feab24a33", passed, total); + RunGenEmitterTest(&Emitter::test162ca62af5cdf9d02507, "test162ca62af5cdf9d02507", passed, total); + RunGenEmitterTest(&Emitter::teste3a7658df7a81c1ce8e5, "teste3a7658df7a81c1ce8e5", passed, total); + RunGenEmitterTest(&Emitter::test9dac5e4f0e78f96fcaad, "test9dac5e4f0e78f96fcaad", passed, total); + RunGenEmitterTest(&Emitter::testaf2e952791b73c6bf78c, "testaf2e952791b73c6bf78c", passed, total); + RunGenEmitterTest(&Emitter::test82b161574e0926b9c854, "test82b161574e0926b9c854", passed, total); + RunGenEmitterTest(&Emitter::test13c3f29be0e6b7bc92b1, "test13c3f29be0e6b7bc92b1", passed, total); + RunGenEmitterTest(&Emitter::teste87c7e9ce16fd2ac5f0e, "teste87c7e9ce16fd2ac5f0e", passed, total); + RunGenEmitterTest(&Emitter::testeed7f7f244221932d32f, "testeed7f7f244221932d32f", passed, total); + RunGenEmitterTest(&Emitter::test31a5563bfa532571339f, "test31a5563bfa532571339f", passed, total); + RunGenEmitterTest(&Emitter::test502ab92aab5195ff4759, "test502ab92aab5195ff4759", passed, total); + RunGenEmitterTest(&Emitter::testdbe2ce5bc02435009b2c, "testdbe2ce5bc02435009b2c", passed, total); + RunGenEmitterTest(&Emitter::test06b8d2cc9bbb233d55d5, "test06b8d2cc9bbb233d55d5", passed, total); + RunGenEmitterTest(&Emitter::test9adf48ae5d6dff37e89a, "test9adf48ae5d6dff37e89a", passed, total); + RunGenEmitterTest(&Emitter::test398282871dcc1c7f8dbe, "test398282871dcc1c7f8dbe", passed, total); + RunGenEmitterTest(&Emitter::test2e2b3c35732210898be1, "test2e2b3c35732210898be1", passed, total); + RunGenEmitterTest(&Emitter::test155697ae715940b6d804, "test155697ae715940b6d804", passed, total); + RunGenEmitterTest(&Emitter::testb01c87881d846bb10ecd, "testb01c87881d846bb10ecd", passed, total); + RunGenEmitterTest(&Emitter::test84a9d3d2ae4eaacc9c98, "test84a9d3d2ae4eaacc9c98", passed, total); + RunGenEmitterTest(&Emitter::testb836cd5dc876cf6eb204, "testb836cd5dc876cf6eb204", passed, total); + RunGenEmitterTest(&Emitter::test4aa81dc715c5e5c53de1, "test4aa81dc715c5e5c53de1", passed, total); + RunGenEmitterTest(&Emitter::testfa8ba9d405de1af93537, "testfa8ba9d405de1af93537", passed, total); + RunGenEmitterTest(&Emitter::test3c07c460dae114d3f278, "test3c07c460dae114d3f278", passed, total); + RunGenEmitterTest(&Emitter::testf513330011b92283e713, "testf513330011b92283e713", passed, total); + RunGenEmitterTest(&Emitter::test88667a8fe856748b4dc6, "test88667a8fe856748b4dc6", passed, total); + RunGenEmitterTest(&Emitter::test7cbc7ae88a6b60d3cb54, "test7cbc7ae88a6b60d3cb54", passed, total); + RunGenEmitterTest(&Emitter::test8b126d00ee878273f3e9, "test8b126d00ee878273f3e9", passed, total); + RunGenEmitterTest(&Emitter::test414dcec883b2fb2668d9, "test414dcec883b2fb2668d9", passed, total); + RunGenEmitterTest(&Emitter::test41754fe2ab40560f1afe, "test41754fe2ab40560f1afe", passed, total); + RunGenEmitterTest(&Emitter::test39b7a9ee0ccb5580ef60, "test39b7a9ee0ccb5580ef60", passed, total); + RunGenEmitterTest(&Emitter::test1f4cbfdb2f53d041fb74, "test1f4cbfdb2f53d041fb74", passed, total); + RunGenEmitterTest(&Emitter::testc20612e8922a8eeba24d, "testc20612e8922a8eeba24d", passed, total); + RunGenEmitterTest(&Emitter::test693f48133cf726f1e05c, "test693f48133cf726f1e05c", passed, total); + RunGenEmitterTest(&Emitter::test12b26bfed7a24736dd8b, "test12b26bfed7a24736dd8b", passed, total); + RunGenEmitterTest(&Emitter::test41d6ec7f045897841e9c, "test41d6ec7f045897841e9c", passed, total); + RunGenEmitterTest(&Emitter::test2bc8d1d6e4ec042ede3e, "test2bc8d1d6e4ec042ede3e", passed, total); + RunGenEmitterTest(&Emitter::test647ff876c844ad7540ff, "test647ff876c844ad7540ff", passed, total); + RunGenEmitterTest(&Emitter::test844c1bcb896dde8ea51b, "test844c1bcb896dde8ea51b", passed, total); + RunGenEmitterTest(&Emitter::testbcf04a5174e8505d1891, "testbcf04a5174e8505d1891", passed, total); + RunGenEmitterTest(&Emitter::testdb6c8ca130035d7a271f, "testdb6c8ca130035d7a271f", passed, total); + RunGenEmitterTest(&Emitter::testa0db96f3d93a255f2201, "testa0db96f3d93a255f2201", passed, total); + RunGenEmitterTest(&Emitter::test4fb3eaac714942122715, "test4fb3eaac714942122715", passed, total); + RunGenEmitterTest(&Emitter::test634678f31daa20127d6c, "test634678f31daa20127d6c", passed, total); + RunGenEmitterTest(&Emitter::test1dd395a1149e46dcc208, "test1dd395a1149e46dcc208", passed, total); + RunGenEmitterTest(&Emitter::testebc585cbde90d10a0af1, "testebc585cbde90d10a0af1", passed, total); + RunGenEmitterTest(&Emitter::testd1ecec189e73f8932485, "testd1ecec189e73f8932485", passed, total); + RunGenEmitterTest(&Emitter::testf8fc72597f0a41b22daa, "testf8fc72597f0a41b22daa", passed, total); + RunGenEmitterTest(&Emitter::testd01959c5c228946c8759, "testd01959c5c228946c8759", passed, total); + RunGenEmitterTest(&Emitter::teste8236a9672d9244ca486, "teste8236a9672d9244ca486", passed, total); + RunGenEmitterTest(&Emitter::test22bd5d24dbd3f0670f97, "test22bd5d24dbd3f0670f97", passed, total); + RunGenEmitterTest(&Emitter::test0f2c6cac0ce0e624eb08, "test0f2c6cac0ce0e624eb08", passed, total); + RunGenEmitterTest(&Emitter::test2ed2eef7f03696ca3c94, "test2ed2eef7f03696ca3c94", passed, total); + RunGenEmitterTest(&Emitter::test6fe33177e10d14328a14, "test6fe33177e10d14328a14", passed, total); + RunGenEmitterTest(&Emitter::test0ea79e93c3439d90bdb8, "test0ea79e93c3439d90bdb8", passed, total); + RunGenEmitterTest(&Emitter::test2ab970621d7e037153c9, "test2ab970621d7e037153c9", passed, total); + RunGenEmitterTest(&Emitter::test4229059ec3d639faf4b2, "test4229059ec3d639faf4b2", passed, total); + RunGenEmitterTest(&Emitter::test6df809b4712b73c8577f, "test6df809b4712b73c8577f", passed, total); + RunGenEmitterTest(&Emitter::test37a0a34b2bef743d8241, "test37a0a34b2bef743d8241", passed, total); + RunGenEmitterTest(&Emitter::testd6c37c1e50617419a37d, "testd6c37c1e50617419a37d", passed, total); + RunGenEmitterTest(&Emitter::test2fb71689fb176533159c, "test2fb71689fb176533159c", passed, total); + RunGenEmitterTest(&Emitter::testa91d7999dd9b43fb5827, "testa91d7999dd9b43fb5827", passed, total); + RunGenEmitterTest(&Emitter::test8dfd4533e2891d3861ec, "test8dfd4533e2891d3861ec", passed, total); + RunGenEmitterTest(&Emitter::test0a9b0c29dfcf4f071eb9, "test0a9b0c29dfcf4f071eb9", passed, total); + RunGenEmitterTest(&Emitter::test3882a796318e573b115d, "test3882a796318e573b115d", passed, total); + RunGenEmitterTest(&Emitter::test1ade39a1572a12eda7b8, "test1ade39a1572a12eda7b8", passed, total); + RunGenEmitterTest(&Emitter::testd308c7e19671725523cd, "testd308c7e19671725523cd", passed, total); + RunGenEmitterTest(&Emitter::test1ac58dc569ce7b4eebdf, "test1ac58dc569ce7b4eebdf", passed, total); + RunGenEmitterTest(&Emitter::test5fe4c34b163d0efa12d5, "test5fe4c34b163d0efa12d5", passed, total); + RunGenEmitterTest(&Emitter::test78433ff7edf3224ce58b, "test78433ff7edf3224ce58b", passed, total); + RunGenEmitterTest(&Emitter::test089ed50cafddf39653d6, "test089ed50cafddf39653d6", passed, total); + RunGenEmitterTest(&Emitter::test809723ec7bdea45cf562, "test809723ec7bdea45cf562", passed, total); + RunGenEmitterTest(&Emitter::test953cf821d2acc7898582, "test953cf821d2acc7898582", passed, total); + RunGenEmitterTest(&Emitter::test0f1db947e4627596eace, "test0f1db947e4627596eace", passed, total); + RunGenEmitterTest(&Emitter::test52f3b0674f30d955eea7, "test52f3b0674f30d955eea7", passed, total); + RunGenEmitterTest(&Emitter::testf95a488631e07f6ca914, "testf95a488631e07f6ca914", passed, total); + RunGenEmitterTest(&Emitter::test9b7a916f4c1e2a1ae6ee, "test9b7a916f4c1e2a1ae6ee", passed, total); + RunGenEmitterTest(&Emitter::test54ea34948e814ef79607, "test54ea34948e814ef79607", passed, total); + RunGenEmitterTest(&Emitter::testcef62af7508e0a1e3ee3, "testcef62af7508e0a1e3ee3", passed, total); + RunGenEmitterTest(&Emitter::testffcfb27f0c904fae7833, "testffcfb27f0c904fae7833", passed, total); + RunGenEmitterTest(&Emitter::test31ed1460205bbc5a4a68, "test31ed1460205bbc5a4a68", passed, total); + RunGenEmitterTest(&Emitter::test7d04c8d923b046159db0, "test7d04c8d923b046159db0", passed, total); + RunGenEmitterTest(&Emitter::test31b396851023614cf9fd, "test31b396851023614cf9fd", passed, total); + RunGenEmitterTest(&Emitter::test5befd800aa07d83e2df7, "test5befd800aa07d83e2df7", passed, total); + RunGenEmitterTest(&Emitter::test2df4f378f687fd80b98c, "test2df4f378f687fd80b98c", passed, total); + RunGenEmitterTest(&Emitter::test232f5aa6ea7e85e186c4, "test232f5aa6ea7e85e186c4", passed, total); + RunGenEmitterTest(&Emitter::test011421ad7da175099088, "test011421ad7da175099088", passed, total); + RunGenEmitterTest(&Emitter::testf50217feca0ae03a0b03, "testf50217feca0ae03a0b03", passed, total); + RunGenEmitterTest(&Emitter::teste4b49044063dd3c8a7ff, "teste4b49044063dd3c8a7ff", passed, total); + RunGenEmitterTest(&Emitter::testbe9295522ec1f0bc9de5, "testbe9295522ec1f0bc9de5", passed, total); + RunGenEmitterTest(&Emitter::test7a18055f1e3a49f93d40, "test7a18055f1e3a49f93d40", passed, total); + RunGenEmitterTest(&Emitter::testd8eebabad65b8ef02375, "testd8eebabad65b8ef02375", passed, total); + RunGenEmitterTest(&Emitter::test948f36e3182f3c1aa800, "test948f36e3182f3c1aa800", passed, total); + RunGenEmitterTest(&Emitter::testde02b69600e5931c39ab, "testde02b69600e5931c39ab", passed, total); + RunGenEmitterTest(&Emitter::test5fdab21609e7017c3b86, "test5fdab21609e7017c3b86", passed, total); + RunGenEmitterTest(&Emitter::testfb52965f57b912ec23a4, "testfb52965f57b912ec23a4", passed, total); + RunGenEmitterTest(&Emitter::testa3f220ead85b78154f89, "testa3f220ead85b78154f89", passed, total); + RunGenEmitterTest(&Emitter::test0ef1b1c26e8a1fa34ccd, "test0ef1b1c26e8a1fa34ccd", passed, total); + RunGenEmitterTest(&Emitter::test7661db62a921285da885, "test7661db62a921285da885", passed, total); + RunGenEmitterTest(&Emitter::test9382f466be3e19ca395f, "test9382f466be3e19ca395f", passed, total); + RunGenEmitterTest(&Emitter::test33c4f45355dc7df2e2a8, "test33c4f45355dc7df2e2a8", passed, total); + RunGenEmitterTest(&Emitter::testc55c40f32c34c890acce, "testc55c40f32c34c890acce", passed, total); + RunGenEmitterTest(&Emitter::testb06ba64c5895f218175d, "testb06ba64c5895f218175d", passed, total); + RunGenEmitterTest(&Emitter::test14adb5374833871b2d0c, "test14adb5374833871b2d0c", passed, total); + RunGenEmitterTest(&Emitter::test7ff7826c0f0563ce5a65, "test7ff7826c0f0563ce5a65", passed, total); + RunGenEmitterTest(&Emitter::test394e607327447b08e729, "test394e607327447b08e729", passed, total); + RunGenEmitterTest(&Emitter::testdf03e1437e901976c2c8, "testdf03e1437e901976c2c8", passed, total); + RunGenEmitterTest(&Emitter::test77467fcda467dd063050, "test77467fcda467dd063050", passed, total); + RunGenEmitterTest(&Emitter::test5bcea73651331a2357d0, "test5bcea73651331a2357d0", passed, total); + RunGenEmitterTest(&Emitter::test2956b3f097a16a4cd951, "test2956b3f097a16a4cd951", passed, total); + RunGenEmitterTest(&Emitter::test3170422d0cad24cd602a, "test3170422d0cad24cd602a", passed, total); + RunGenEmitterTest(&Emitter::testb37f0cd80f138e8f2622, "testb37f0cd80f138e8f2622", passed, total); + RunGenEmitterTest(&Emitter::test3e00cce71da4636fa1f7, "test3e00cce71da4636fa1f7", passed, total); + RunGenEmitterTest(&Emitter::testfd184c04759685f21abb, "testfd184c04759685f21abb", passed, total); + RunGenEmitterTest(&Emitter::test14ab4965eff0a569da16, "test14ab4965eff0a569da16", passed, total); + RunGenEmitterTest(&Emitter::test271811f2df7210366780, "test271811f2df7210366780", passed, total); + RunGenEmitterTest(&Emitter::testfcfe8657dffc21f6cd45, "testfcfe8657dffc21f6cd45", passed, total); + RunGenEmitterTest(&Emitter::test609e44eab4ab95f31e33, "test609e44eab4ab95f31e33", passed, total); + RunGenEmitterTest(&Emitter::test7841fc715275a45a2770, "test7841fc715275a45a2770", passed, total); + RunGenEmitterTest(&Emitter::test662c03de87ca40bd943e, "test662c03de87ca40bd943e", passed, total); + RunGenEmitterTest(&Emitter::test0a9475ec3c946fe11991, "test0a9475ec3c946fe11991", passed, total); + RunGenEmitterTest(&Emitter::test94d28ebdbee90f430eb1, "test94d28ebdbee90f430eb1", passed, total); + RunGenEmitterTest(&Emitter::testd5035afc82e23b67ce03, "testd5035afc82e23b67ce03", passed, total); + RunGenEmitterTest(&Emitter::testcc9788c342da4454758f, "testcc9788c342da4454758f", passed, total); + RunGenEmitterTest(&Emitter::test140974453293fdb1155d, "test140974453293fdb1155d", passed, total); + RunGenEmitterTest(&Emitter::testdc0b80a131730e98d735, "testdc0b80a131730e98d735", passed, total); + RunGenEmitterTest(&Emitter::test1c5225b07d746c2bd331, "test1c5225b07d746c2bd331", passed, total); + RunGenEmitterTest(&Emitter::testa49a0be204cd2b57f17b, "testa49a0be204cd2b57f17b", passed, total); + RunGenEmitterTest(&Emitter::testbe08cc0a08cf2cb5e7ec, "testbe08cc0a08cf2cb5e7ec", passed, total); + RunGenEmitterTest(&Emitter::test4d2a2e12689655edd77c, "test4d2a2e12689655edd77c", passed, total); + RunGenEmitterTest(&Emitter::test4d4a25a54401f0282ceb, "test4d4a25a54401f0282ceb", passed, total); + RunGenEmitterTest(&Emitter::test91f55feebb012ce89a93, "test91f55feebb012ce89a93", passed, total); + RunGenEmitterTest(&Emitter::test1f3d0b19c6a346b087e0, "test1f3d0b19c6a346b087e0", passed, total); + RunGenEmitterTest(&Emitter::test4e26682c2daf8ded04a6, "test4e26682c2daf8ded04a6", passed, total); + RunGenEmitterTest(&Emitter::test6f24e6df03922bba0d8a, "test6f24e6df03922bba0d8a", passed, total); + RunGenEmitterTest(&Emitter::test60849eca7dc178908ff1, "test60849eca7dc178908ff1", passed, total); + RunGenEmitterTest(&Emitter::test28b7db2ac68bb806e143, "test28b7db2ac68bb806e143", passed, total); + RunGenEmitterTest(&Emitter::test8db156db7065942bc260, "test8db156db7065942bc260", passed, total); + RunGenEmitterTest(&Emitter::teste240aced6e2292a9b091, "teste240aced6e2292a9b091", passed, total); + RunGenEmitterTest(&Emitter::test468628a845426ce4a106, "test468628a845426ce4a106", passed, total); + RunGenEmitterTest(&Emitter::testa3a2d467766b74acd6fd, "testa3a2d467766b74acd6fd", passed, total); + RunGenEmitterTest(&Emitter::test5bf63d8ed606d688d869, "test5bf63d8ed606d688d869", passed, total); + RunGenEmitterTest(&Emitter::test0d35c1487237ba7d8bdc, "test0d35c1487237ba7d8bdc", passed, total); + RunGenEmitterTest(&Emitter::testb1fddc2897760d60e733, "testb1fddc2897760d60e733", passed, total); + RunGenEmitterTest(&Emitter::testbaf845554a46f088bf71, "testbaf845554a46f088bf71", passed, total); + RunGenEmitterTest(&Emitter::test6383f28d62ad9ce3c075, "test6383f28d62ad9ce3c075", passed, total); + RunGenEmitterTest(&Emitter::test88a4c1cc11b99a61eccd, "test88a4c1cc11b99a61eccd", passed, total); + RunGenEmitterTest(&Emitter::test4716a2cf58a70705987b, "test4716a2cf58a70705987b", passed, total); + RunGenEmitterTest(&Emitter::test75222084929bd0f9d38f, "test75222084929bd0f9d38f", passed, total); + RunGenEmitterTest(&Emitter::test2fb23c79eec625216523, "test2fb23c79eec625216523", passed, total); + RunGenEmitterTest(&Emitter::testb1699a6b7c5ded480677, "testb1699a6b7c5ded480677", passed, total); + RunGenEmitterTest(&Emitter::testd7de744a20ca1dc099db, "testd7de744a20ca1dc099db", passed, total); + RunGenEmitterTest(&Emitter::test900b2dcf20981b44ea65, "test900b2dcf20981b44ea65", passed, total); + RunGenEmitterTest(&Emitter::test20cc330b6d1171584aed, "test20cc330b6d1171584aed", passed, total); + RunGenEmitterTest(&Emitter::test5ea8e3642fab864fb09d, "test5ea8e3642fab864fb09d", passed, total); + RunGenEmitterTest(&Emitter::test42e21cbc65f534972ead, "test42e21cbc65f534972ead", passed, total); + RunGenEmitterTest(&Emitter::test14e3b5dca1d7a5a0c957, "test14e3b5dca1d7a5a0c957", passed, total); + RunGenEmitterTest(&Emitter::test9bd4800a58394b172738, "test9bd4800a58394b172738", passed, total); + RunGenEmitterTest(&Emitter::testb715a2b66987a872ced8, "testb715a2b66987a872ced8", passed, total); + RunGenEmitterTest(&Emitter::teste9b56880009cc6899131, "teste9b56880009cc6899131", passed, total); + RunGenEmitterTest(&Emitter::test21f96f767e38471c9d4d, "test21f96f767e38471c9d4d", passed, total); + RunGenEmitterTest(&Emitter::testa8aebba05fc1858c0a6c, "testa8aebba05fc1858c0a6c", passed, total); + RunGenEmitterTest(&Emitter::teste6e7442377049b17ee9e, "teste6e7442377049b17ee9e", passed, total); + RunGenEmitterTest(&Emitter::test428b593e283163fee752, "test428b593e283163fee752", passed, total); + RunGenEmitterTest(&Emitter::test0b6c63323da4bf9798c2, "test0b6c63323da4bf9798c2", passed, total); + RunGenEmitterTest(&Emitter::test0f4c45c39fe39dfc8a1d, "test0f4c45c39fe39dfc8a1d", passed, total); + RunGenEmitterTest(&Emitter::testb8043a7ae1de42dd81db, "testb8043a7ae1de42dd81db", passed, total); + RunGenEmitterTest(&Emitter::test4d9b278579ffb76fc56d, "test4d9b278579ffb76fc56d", passed, total); + RunGenEmitterTest(&Emitter::test672fc8b6d281f82b9332, "test672fc8b6d281f82b9332", passed, total); + RunGenEmitterTest(&Emitter::testb406d378fa0df952b051, "testb406d378fa0df952b051", passed, total); + RunGenEmitterTest(&Emitter::test68a227d03f20863f37e4, "test68a227d03f20863f37e4", passed, total); + RunGenEmitterTest(&Emitter::testcee8582fd340377bda46, "testcee8582fd340377bda46", passed, total); + RunGenEmitterTest(&Emitter::test06fd48e8c86baf6fc05b, "test06fd48e8c86baf6fc05b", passed, total); + RunGenEmitterTest(&Emitter::test70b4ccbf71c0716bf8e4, "test70b4ccbf71c0716bf8e4", passed, total); + RunGenEmitterTest(&Emitter::test449c2b349be8da36682b, "test449c2b349be8da36682b", passed, total); + RunGenEmitterTest(&Emitter::test9620fa69718e3b4fe391, "test9620fa69718e3b4fe391", passed, total); + RunGenEmitterTest(&Emitter::test3faaebe701bea6f8ee39, "test3faaebe701bea6f8ee39", passed, total); + RunGenEmitterTest(&Emitter::test763ee61808091c7a354d, "test763ee61808091c7a354d", passed, total); + RunGenEmitterTest(&Emitter::test81b0d6b575228cde91e5, "test81b0d6b575228cde91e5", passed, total); + RunGenEmitterTest(&Emitter::testb607ae3c5d560092e37b, "testb607ae3c5d560092e37b", passed, total); + RunGenEmitterTest(&Emitter::testa53c54726737df14a5dd, "testa53c54726737df14a5dd", passed, total); + RunGenEmitterTest(&Emitter::test071d73b309a1365e0b07, "test071d73b309a1365e0b07", passed, total); + RunGenEmitterTest(&Emitter::testf8f45511528fa28cddcb, "testf8f45511528fa28cddcb", passed, total); + RunGenEmitterTest(&Emitter::testabdd2bf3bdf550e3dd60, "testabdd2bf3bdf550e3dd60", passed, total); + RunGenEmitterTest(&Emitter::test53424b35498a73fbede9, "test53424b35498a73fbede9", passed, total); + RunGenEmitterTest(&Emitter::testf0c6c1a1afced157d6a5, "testf0c6c1a1afced157d6a5", passed, total); + RunGenEmitterTest(&Emitter::teste45dbac33918e0fee74f, "teste45dbac33918e0fee74f", passed, total); + RunGenEmitterTest(&Emitter::test903c7ab3d09d4323107f, "test903c7ab3d09d4323107f", passed, total); + RunGenEmitterTest(&Emitter::test5d39d351680dba4be04b, "test5d39d351680dba4be04b", passed, total); + RunGenEmitterTest(&Emitter::testaa1e8d6d4385aab47bcd, "testaa1e8d6d4385aab47bcd", passed, total); + RunGenEmitterTest(&Emitter::test9bd238b748ced1db588b, "test9bd238b748ced1db588b", passed, total); + RunGenEmitterTest(&Emitter::testec1cdffaae8842854947, "testec1cdffaae8842854947", passed, total); + RunGenEmitterTest(&Emitter::test30727d97de63c1ad395a, "test30727d97de63c1ad395a", passed, total); + RunGenEmitterTest(&Emitter::test7adafdc8be65a5d610bf, "test7adafdc8be65a5d610bf", passed, total); +#else // YAML_GEN_TESTS + (void)passed; (void)total; +#endif // YAML_GEN_TESTS +} diff --git a/test/handlermacros.h b/test/handlermacros.h new file mode 100644 index 0000000..db2019c --- /dev/null +++ b/test/handlermacros.h @@ -0,0 +1,190 @@ +#include "teststruct.h" +#pragma once + +#include "yaml-cpp/yaml.h" +#include "yaml-cpp/eventhandler.h" +#include +#include + +namespace Test { + inline std::string Quote(const std::string& text) { + YAML::Emitter out; + out << YAML::DoubleQuoted << text; + return out.c_str(); + } + + struct Event { + enum Type { DocStart, DocEnd, Null, Alias, Scalar, SeqStart, SeqEnd, MapStart, MapEnd }; + + typedef YAML::Mark Mark; + typedef YAML::anchor_t anchor_t; + + Event(Type type_, const std::string& tag_, anchor_t anchor_, const std::string& scalar_): type(type_), tag(tag_), anchor(anchor_), scalar(scalar_) {} + + Type type; + std::string tag; + anchor_t anchor; + std::string scalar; + + std::ostream& write(std::ostream& out) const { + switch(type) { + case DocStart: + return out << "DocStart"; + case DocEnd: + return out << "DocEnd"; + case Null: + return out << "Null(" << anchor << ")"; + case Alias: + return out << "Alias(" << anchor << ")"; + case Scalar: + return out << "Scalar(" << Quote(tag) << ", " << anchor << ", " << Quote(scalar) << ")"; + case SeqStart: + return out << "SeqStart(" << Quote(tag) << ", " << anchor << ")"; + case SeqEnd: + return out << "SeqEnd"; + case MapStart: + return out << "MapStart(" << Quote(tag) << ", " << anchor << ")"; + case MapEnd: + return out << "MapEnd"; + } + assert(false); + return out; + } + }; + + inline std::ostream& operator << (std::ostream& out, const Event& event) { + return event.write(out); + } + + inline bool operator == (const Event& a, const Event& b) { + return a.type == b.type && a.tag == b.tag && a.anchor == b.anchor && a.scalar == b.scalar; + } + + inline bool operator != (const Event& a, const Event& b) { + return !(a == b); + } + + class MockEventHandler: public YAML::EventHandler + { + public: + typedef YAML::Mark Mark; + typedef YAML::anchor_t anchor_t; + + MockEventHandler() {} + + virtual void OnDocumentStart(const Mark&) { + m_actualEvents.push_back(Event(Event::DocStart, "", 0, "")); + } + + virtual void OnDocumentEnd() { + m_actualEvents.push_back(Event(Event::DocEnd, "", 0, "")); + } + + virtual void OnNull(const Mark&, anchor_t anchor) { + m_actualEvents.push_back(Event(Event::Null, "", anchor, "")); + } + + virtual void OnAlias(const Mark&, anchor_t anchor) { + m_actualEvents.push_back(Event(Event::Alias, "", anchor, "")); + } + + virtual void OnScalar(const Mark&, const std::string& tag, anchor_t anchor, const std::string& value) { + m_actualEvents.push_back(Event(Event::Scalar, tag, anchor, value)); + } + + virtual void OnSequenceStart(const Mark&, const std::string& tag, anchor_t anchor) { + m_actualEvents.push_back(Event(Event::SeqStart, tag, anchor, "")); + } + + virtual void OnSequenceEnd() { + m_actualEvents.push_back(Event(Event::SeqEnd, "", 0, "")); + } + + virtual void OnMapStart(const Mark&, const std::string& tag, anchor_t anchor) { + m_actualEvents.push_back(Event(Event::MapStart, tag, anchor, "")); + } + + virtual void OnMapEnd() { + m_actualEvents.push_back(Event(Event::MapEnd, "", 0, "")); + } + + void Expect(const Event& event) { m_expectedEvents.push_back(event); } + + Test::TEST Check() const { + std::size_t N = std::max(m_expectedEvents.size(), m_actualEvents.size()); + for(std::size_t i=0;i= m_expectedEvents.size()) { + std::stringstream out; + for(std::size_t j=0;j= m_actualEvents.size()) { + std::stringstream out; + for(std::size_t j=0;j m_expectedEvents; + std::vector m_actualEvents; + }; + +#define HANDLE(ex)\ +MockEventHandler handler;\ +std::stringstream stream(ex);\ +YAML::Parser parser(stream);\ +while(parser.HandleNextDocument(handler)) {} + +#define EXPECT_DOC_START()\ +handler.Expect(Event(Event::DocStart, "", 0, "")) + +#define EXPECT_DOC_END()\ +handler.Expect(Event(Event::DocEnd, "", 0, "")) + +#define EXPECT_NULL(anchor)\ +handler.Expect(Event(Event::Null, "", anchor, "")) + +#define EXPECT_ALIAS(anchor)\ +handler.Expect(Event(Event::Alias, "", anchor, "")) + +#define EXPECT_SCALAR(tag, anchor, value)\ +handler.Expect(Event(Event::Scalar, tag, anchor, value)) + +#define EXPECT_SEQ_START(tag, anchor)\ +handler.Expect(Event(Event::SeqStart, tag, anchor, "")) + +#define EXPECT_SEQ_END()\ +handler.Expect(Event(Event::SeqEnd, "", 0, "")) + +#define EXPECT_MAP_START(tag, anchor)\ +handler.Expect(Event(Event::MapStart, tag, anchor, "")) + +#define EXPECT_MAP_END()\ +handler.Expect(Event(Event::MapEnd, "", 0, "")) + +#define DONE()\ +return handler.Check() + +} diff --git a/test/spectests.h b/test/spectests.h index 5246df5..611f3c0 100644 --- a/test/spectests.h +++ b/test/spectests.h @@ -5,18 +5,9 @@ #pragma once #endif -#include +#include "teststruct.h" namespace Test { - struct TEST { - TEST(): ok(false) {} - TEST(bool ok_): ok(ok_) {} - TEST(const char *error_): ok(false), error(error_) {} - - bool ok; - std::string error; - }; - namespace Spec { // 2.1 TEST SeqScalars(); diff --git a/test/teststruct.h b/test/teststruct.h new file mode 100644 index 0000000..2d563e5 --- /dev/null +++ b/test/teststruct.h @@ -0,0 +1,18 @@ +#pragma once + +#include + +#define YAML_ASSERT(cond) do { if(!(cond)) return " Assert failed: " #cond; } while(false) + +namespace Test +{ + struct TEST { + TEST(): ok(false) {} + TEST(bool ok_): ok(ok_) {} + TEST(const char *error_): ok(false), error(error_) {} + + bool ok; + std::string error; + }; + +} diff --git a/util/CMakeLists.txt b/util/CMakeLists.txt index 22339f0..1e2f59e 100644 --- a/util/CMakeLists.txt +++ b/util/CMakeLists.txt @@ -1,2 +1,5 @@ add_executable(parse parse.cpp) target_link_libraries(parse yaml-cpp) + +add_executable(sandbox sandbox.cpp) +target_link_libraries(sandbox yaml-cpp) diff --git a/util/sandbox.cpp b/util/sandbox.cpp new file mode 100644 index 0000000..be24ae1 --- /dev/null +++ b/util/sandbox.cpp @@ -0,0 +1,13 @@ +#include "yaml-cpp/yaml.h" +#include + +int main() +{ + YAML::Emitter out; + out << YAML::BeginSeq; + out << ':'; + out << YAML::EndSeq; + + std::cout << out.c_str() << "\n"; + return 0; +}