generic-library/jsoncpp
1
0
Fork 0
mirror of https://github.com/open-source-parsers/jsoncpp.git synced 2025-05-07 09:20:06 +02:00
Code Issues Projects Releases Wiki Activity

Merge pull request #784 from Nekto89/cppcheck_fix

Browse Source 
Multiple fixes for issues found by Cppcheck
This commit is contained in:
Christopher Dunn 2018-06-03 13:28:53 -05:00 committed by GitHub
commit c4103ab390
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 72 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/json/value.h
View File

@ -427,12 +427,12 @@ Json::Value obj_value(Json::objectValue); // {}
/// \post type() is unchanged /// \post type() is unchanged
void clear(); void clear();
/// Resize the array to size elements. /// Resize the array to newSize elements.
/// New elements are initialized to null. /// New elements are initialized to null.
/// May only be called on nullValue or arrayValue. /// May only be called on nullValue or arrayValue.
/// \pre type() is arrayValue or nullValue /// \pre type() is arrayValue or nullValue
/// \post type() is arrayValue /// \post type() is arrayValue
void resize(ArrayIndex size); void resize(ArrayIndex newSize);
/// Access an array element (zero based index ). /// Access an array element (zero based index ).
/// If the array contains less than index element, then null value are /// If the array contains less than index element, then null value are
@ -562,10 +562,10 @@ Json::Value obj_value(Json::objectValue); // {}
/** \brief Remove the indexed array element. /** \brief Remove the indexed array element.
O(n) expensive operations. O(n) expensive operations.
Update 'removed' iff removed. Update 'removed' if removed.
\return true iff removed (no exceptions) \return true if removed (no exceptions)
*/ */
bool removeIndex(ArrayIndex i, Value* removed); bool removeIndex(ArrayIndex index, Value* removed);
/// Return true if the object has a member named key. /// Return true if the object has a member named key.
/// \note 'key' must be null-terminated. /// \note 'key' must be null-terminated.
@ -720,7 +720,7 @@ private:
const InArgs& in, const InArgs& in,
InArgs::const_iterator& itInArg, InArgs::const_iterator& itInArg,
PathArgument::Kind kind); PathArgument::Kind kind);
void invalidPath(const JSONCPP_STRING& path, int location); static void invalidPath(const JSONCPP_STRING& path, int location);
Args args_; Args args_;
}; };

6
include/json/writer.h
View File

@ -249,7 +249,7 @@ private:
void unindent(); void unindent();
void writeCommentBeforeValue(const Value& root); void writeCommentBeforeValue(const Value& root);
void writeCommentAfterValueOnSameLine(const Value& root); void writeCommentAfterValueOnSameLine(const Value& root);
bool hasCommentForValue(const Value& value); static bool hasCommentForValue(const Value& value);
static JSONCPP_STRING normalizeEOL(const JSONCPP_STRING& text); static JSONCPP_STRING normalizeEOL(const JSONCPP_STRING& text);
typedef std::vector<JSONCPP_STRING> ChildValues; typedef std::vector<JSONCPP_STRING> ChildValues;
@ -300,7 +300,7 @@ public:
/** /**
* \param indentation Each level will be indented by this amount extra. * \param indentation Each level will be indented by this amount extra.
*/ */
StyledStreamWriter(JSONCPP_STRING indentation = "\t"); StyledStreamWriter(const JSONCPP_STRING& indentation = "\t");
~StyledStreamWriter() {} ~StyledStreamWriter() {}
public: public:
@ -323,7 +323,7 @@ private:
void unindent(); void unindent();
void writeCommentBeforeValue(const Value& root); void writeCommentBeforeValue(const Value& root);
void writeCommentAfterValueOnSameLine(const Value& root); void writeCommentAfterValueOnSameLine(const Value& root);
bool hasCommentForValue(const Value& value); static bool hasCommentForValue(const Value& value);
static JSONCPP_STRING normalizeEOL(const JSONCPP_STRING& text); static JSONCPP_STRING normalizeEOL(const JSONCPP_STRING& text);
typedef std::vector<JSONCPP_STRING> ChildValues; typedef std::vector<JSONCPP_STRING> ChildValues;

4
src/jsontestrunner/main.cpp
View File

@ -106,9 +106,9 @@ static void printValueTree(FILE* fout,
for (Json::ArrayIndex index = 0; index < size; ++index) { for (Json::ArrayIndex index = 0; index < size; ++index) {
static char buffer[16]; static char buffer[16];
#if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__) #if defined(_MSC_VER) && defined(__STDC_SECURE_LIB__)
sprintf_s(buffer, sizeof(buffer), "[%d]", index); sprintf_s(buffer, sizeof(buffer), "[%u]", index);
#else #else
snprintf(buffer, sizeof(buffer), "[%d]", index); snprintf(buffer, sizeof(buffer), "[%u]", index);
#endif #endif
printValueTree(fout, value[index], path + buffer); printValueTree(fout, value[index], path + buffer);
} }

58
src/lib_json/json_reader.cpp
View File

@ -112,8 +112,8 @@ bool Reader::parse(const std::string& document,
return parse(begin, end, root, collectComments); return parse(begin, end, root, collectComments);
} }
bool Reader::parse(std::istream& sin, Value& root, bool collectComments) { bool Reader::parse(std::istream& is, Value& root, bool collectComments) {
// std::istream_iterator<char> begin(sin); // std::istream_iterator<char> begin(is);
// std::istream_iterator<char> end; // std::istream_iterator<char> end;
// Those would allow streamed input from a file, if parse() were a // Those would allow streamed input from a file, if parse() were a
// template function. // template function.
@ -121,7 +121,7 @@ bool Reader::parse(std::istream& sin, Value& root, bool collectComments) {
// Since JSONCPP_STRING is reference-counted, this at least does not // Since JSONCPP_STRING is reference-counted, this at least does not
// create an extra copy. // create an extra copy.
JSONCPP_STRING doc; JSONCPP_STRING doc;
std::getline(sin, doc, (char)EOF); std::getline(is, doc, (char)EOF);
return parse(doc.data(), doc.data() + doc.size(), root, collectComments); return parse(doc.data(), doc.data() + doc.size(), root, collectComments);
} }
@ -460,12 +460,12 @@ bool Reader::readString() {
return c == '"'; return c == '"';
} }
bool Reader::readObject(Token& tokenStart) { bool Reader::readObject(Token& token) {
Token tokenName; Token tokenName;
JSONCPP_STRING name; JSONCPP_STRING name;
Value init(objectValue); Value init(objectValue);
currentValue().swapPayload(init); currentValue().swapPayload(init);
currentValue().setOffsetStart(tokenStart.start_ - begin_); currentValue().setOffsetStart(token.start_ - begin_);
while (readToken(tokenName)) { while (readToken(tokenName)) {
bool initialTokenOk = true; bool initialTokenOk = true;
while (tokenName.type_ == tokenComment && initialTokenOk) while (tokenName.type_ == tokenComment && initialTokenOk)
@ -516,10 +516,10 @@ bool Reader::readObject(Token& tokenStart) {
tokenObjectEnd); tokenObjectEnd);
} }
bool Reader::readArray(Token& tokenStart) { bool Reader::readArray(Token& token) {
Value init(arrayValue); Value init(arrayValue);
currentValue().swapPayload(init); currentValue().swapPayload(init);
currentValue().setOffsetStart(tokenStart.start_ - begin_); currentValue().setOffsetStart(token.start_ - begin_);
skipSpaces(); skipSpaces();
if (current_ != end_ && *current_ == ']') // empty array if (current_ != end_ && *current_ == ']') // empty array
{ {
@ -536,19 +536,19 @@ bool Reader::readArray(Token& tokenStart) {
if (!ok) // error already set if (!ok) // error already set
return recoverFromError(tokenArrayEnd); return recoverFromError(tokenArrayEnd);
Token token; Token currentToken;
// Accept Comment after last item in the array. // Accept Comment after last item in the array.
ok = readToken(token); ok = readToken(currentToken);
while (token.type_ == tokenComment && ok) { while (currentToken.type_ == tokenComment && ok) {
ok = readToken(token); ok = readToken(currentToken);
} }
bool badTokenType = bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
(token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd); currentToken.type_ != tokenArrayEnd);
if (!ok || badTokenType) { if (!ok || badTokenType) {
return addErrorAndRecover("Missing ',' or ']' in array declaration", return addErrorAndRecover("Missing ',' or ']' in array declaration",
token, tokenArrayEnd); currentToken, tokenArrayEnd);
} }
if (token.type_ == tokenArrayEnd) if (currentToken.type_ == tokenArrayEnd)
break; break;
} }
return true; return true;
@ -706,8 +706,8 @@ bool Reader::decodeUnicodeCodePoint(Token& token,
return addError( return addError(
"additional six characters expected to parse unicode surrogate pair.", "additional six characters expected to parse unicode surrogate pair.",
token, current); token, current);
unsigned int surrogatePair;
if (*(current++) == '\\' && *(current++) == 'u') { if (*(current++) == '\\' && *(current++) == 'u') {
unsigned int surrogatePair;
if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) { if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF); unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
} else } else
@ -1450,12 +1450,12 @@ bool OurReader::readStringSingleQuote() {
return c == '\''; return c == '\'';
} }
bool OurReader::readObject(Token& tokenStart) { bool OurReader::readObject(Token& token) {
Token tokenName; Token tokenName;
JSONCPP_STRING name; JSONCPP_STRING name;
Value init(objectValue); Value init(objectValue);
currentValue().swapPayload(init); currentValue().swapPayload(init);
currentValue().setOffsetStart(tokenStart.start_ - begin_); currentValue().setOffsetStart(token.start_ - begin_);
while (readToken(tokenName)) { while (readToken(tokenName)) {
bool initialTokenOk = true; bool initialTokenOk = true;
while (tokenName.type_ == tokenComment && initialTokenOk) while (tokenName.type_ == tokenComment && initialTokenOk)
@ -1512,10 +1512,10 @@ bool OurReader::readObject(Token& tokenStart) {
tokenObjectEnd); tokenObjectEnd);
} }
bool OurReader::readArray(Token& tokenStart) { bool OurReader::readArray(Token& token) {
Value init(arrayValue); Value init(arrayValue);
currentValue().swapPayload(init); currentValue().swapPayload(init);
currentValue().setOffsetStart(tokenStart.start_ - begin_); currentValue().setOffsetStart(token.start_ - begin_);
skipSpaces(); skipSpaces();
if (current_ != end_ && *current_ == ']') // empty array if (current_ != end_ && *current_ == ']') // empty array
{ {
@ -1532,19 +1532,19 @@ bool OurReader::readArray(Token& tokenStart) {
if (!ok) // error already set if (!ok) // error already set
return recoverFromError(tokenArrayEnd); return recoverFromError(tokenArrayEnd);
Token token; Token currentToken;
// Accept Comment after last item in the array. // Accept Comment after last item in the array.
ok = readToken(token); ok = readToken(currentToken);
while (token.type_ == tokenComment && ok) { while (currentToken.type_ == tokenComment && ok) {
ok = readToken(token); ok = readToken(currentToken);
} }
bool badTokenType = bool badTokenType = (currentToken.type_ != tokenArraySeparator &&
(token.type_ != tokenArraySeparator && token.type_ != tokenArrayEnd); currentToken.type_ != tokenArrayEnd);
if (!ok || badTokenType) { if (!ok || badTokenType) {
return addErrorAndRecover("Missing ',' or ']' in array declaration", return addErrorAndRecover("Missing ',' or ']' in array declaration",
token, tokenArrayEnd); currentToken, tokenArrayEnd);
} }
if (token.type_ == tokenArrayEnd) if (currentToken.type_ == tokenArrayEnd)
break; break;
} }
return true; return true;
@ -1726,8 +1726,8 @@ bool OurReader::decodeUnicodeCodePoint(Token& token,
return addError( return addError(
"additional six characters expected to parse unicode surrogate pair.", "additional six characters expected to parse unicode surrogate pair.",
token, current); token, current);
unsigned int surrogatePair;
if (*(current++) == '\\' && *(current++) == 'u') { if (*(current++) == '\\' && *(current++) == 'u') {
unsigned int surrogatePair;
if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) { if (decodeUnicodeEscapeSequence(token, current, end, surrogatePair)) {
unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF); unicode = 0x10000 + ((unicode & 0x3FF) << 10) + (surrogatePair & 0x3FF);
} else } else

50
src/lib_json/json_value.cpp
View File

@ -241,15 +241,15 @@ void Value::CommentInfo::setComment(const char* text, size_t len) {
// Notes: policy_ indicates if the string was allocated when // Notes: policy_ indicates if the string was allocated when
// a string is stored. // a string is stored.
Value::CZString::CZString(ArrayIndex aindex) : cstr_(0), index_(aindex) {} Value::CZString::CZString(ArrayIndex index) : cstr_(0), index_(index) {}
Value::CZString::CZString(char const* str, Value::CZString::CZString(char const* str,
unsigned ulength, unsigned length,
DuplicationPolicy allocate) DuplicationPolicy allocate)
: cstr_(str) { : cstr_(str) {
// allocate != duplicate // allocate != duplicate
storage_.policy_ = allocate & 0x3; storage_.policy_ = allocate & 0x3;
storage_.length_ = ulength & 0x3FFFFFFF; storage_.length_ = length & 0x3FFFFFFF;
} }
Value::CZString::CZString(const CZString& other) { Value::CZString::CZString(const CZString& other) {
@ -357,10 +357,10 @@ bool Value::CZString::isStaticString() const {
* memset( this, 0, sizeof(Value) ) * memset( this, 0, sizeof(Value) )
* This optimization is used in ValueInternalMap fast allocator. * This optimization is used in ValueInternalMap fast allocator.
*/ */
Value::Value(ValueType vtype) { Value::Value(ValueType type) {
static char const emptyString[] = ""; static char const emptyString[] = "";
initBasic(vtype); initBasic(type);
switch (vtype) { switch (type) {
case nullValue: case nullValue:
break; break;
case intValue: case intValue:
@ -418,10 +418,10 @@ Value::Value(const char* value) {
value, static_cast<unsigned>(strlen(value))); value, static_cast<unsigned>(strlen(value)));
} }
Value::Value(const char* beginValue, const char* endValue) { Value::Value(const char* begin, const char* end) {
initBasic(stringValue, true); initBasic(stringValue, true);
value_.string_ = duplicateAndPrefixStringValue( value_.string_ =
beginValue, static_cast<unsigned>(endValue - beginValue)); duplicateAndPrefixStringValue(begin, static_cast<unsigned>(end - begin));
} }
Value::Value(const JSONCPP_STRING& value) { Value::Value(const JSONCPP_STRING& value) {
@ -645,14 +645,14 @@ unsigned Value::getCStringLength() const {
} }
#endif #endif
bool Value::getString(char const** str, char const** cend) const { bool Value::getString(char const** begin, char const** end) const {
if (type_ != stringValue) if (type_ != stringValue)
return false; return false;
if (value_.string_ == 0) if (value_.string_ == 0)
return false; return false;
unsigned length; unsigned length;
decodePrefixedString(this->allocated_, this->value_.string_, &length, str); decodePrefixedString(this->allocated_, this->value_.string_, &length, begin);
*cend = *str + length; *end = *begin + length;
return true; return true;
} }
@ -1003,8 +1003,8 @@ const Value& Value::operator[](int index) const {
return (*this)[ArrayIndex(index)]; return (*this)[ArrayIndex(index)];
} }
void Value::initBasic(ValueType vtype, bool allocated) { void Value::initBasic(ValueType type, bool allocated) {
type_ = vtype; type_ = type;
allocated_ = allocated; allocated_ = allocated;
comments_ = 0; comments_ = 0;
start_ = 0; start_ = 0;
@ -1101,13 +1101,13 @@ Value& Value::resolveReference(const char* key) {
} }
// @param key is not null-terminated. // @param key is not null-terminated.
Value& Value::resolveReference(char const* key, char const* cend) { Value& Value::resolveReference(char const* key, char const* end) {
JSON_ASSERT_MESSAGE( JSON_ASSERT_MESSAGE(
type_ == nullValue || type_ == objectValue, type_ == nullValue || type_ == objectValue,
"in Json::Value::resolveReference(key, end): requires objectValue"); "in Json::Value::resolveReference(key, end): requires objectValue");
if (type_ == nullValue) if (type_ == nullValue)
*this = Value(objectValue); *this = Value(objectValue);
CZString actualKey(key, static_cast<unsigned>(cend - key), CZString actualKey(key, static_cast<unsigned>(end - key),
CZString::duplicateOnCopy); CZString::duplicateOnCopy);
ObjectValues::iterator it = value_.map_->lower_bound(actualKey); ObjectValues::iterator it = value_.map_->lower_bound(actualKey);
if (it != value_.map_->end() && (*it).first == actualKey) if (it != value_.map_->end() && (*it).first == actualKey)
@ -1126,13 +1126,13 @@ Value Value::get(ArrayIndex index, const Value& defaultValue) const {
bool Value::isValidIndex(ArrayIndex index) const { return index < size(); } bool Value::isValidIndex(ArrayIndex index) const { return index < size(); }
Value const* Value::find(char const* key, char const* cend) const { Value const* Value::find(char const* begin, char const* end) const {
JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue, JSON_ASSERT_MESSAGE(type_ == nullValue || type_ == objectValue,
"in Json::Value::find(key, end, found): requires " "in Json::Value::find(key, end, found): requires "
"objectValue or nullValue"); "objectValue or nullValue");
if (type_ == nullValue) if (type_ == nullValue)
return NULL; return NULL;
CZString actualKey(key, static_cast<unsigned>(cend - key), CZString actualKey(begin, static_cast<unsigned>(end - begin),
CZString::noDuplication); CZString::noDuplication);
ObjectValues::const_iterator it = value_.map_->find(actualKey); ObjectValues::const_iterator it = value_.map_->find(actualKey);
if (it == value_.map_->end()) if (it == value_.map_->end())
@ -1184,10 +1184,10 @@ Value& Value::append(Value&& value) {
} }
#endif #endif
Value Value::get(char const* key, Value Value::get(char const* begin,
char const* cend, char const* end,
Value const& defaultValue) const { Value const& defaultValue) const {
Value const* found = find(key, cend); Value const* found = find(begin, end);
return !found ? defaultValue : *found; return !found ? defaultValue : *found;
} }
Value Value::get(char const* key, Value const& defaultValue) const { Value Value::get(char const* key, Value const& defaultValue) const {
@ -1197,11 +1197,11 @@ Value Value::get(JSONCPP_STRING const& key, Value const& defaultValue) const {
return get(key.data(), key.data() + key.length(), defaultValue); return get(key.data(), key.data() + key.length(), defaultValue);
} }
bool Value::removeMember(const char* key, const char* cend, Value* removed) { bool Value::removeMember(const char* begin, const char* end, Value* removed) {
if (type_ != objectValue) { if (type_ != objectValue) {
return false; return false;
} }
CZString actualKey(key, static_cast<unsigned>(cend - key), CZString actualKey(begin, static_cast<unsigned>(end - begin),
CZString::noDuplication); CZString::noDuplication);
ObjectValues::iterator it = value_.map_->find(actualKey); ObjectValues::iterator it = value_.map_->find(actualKey);
if (it == value_.map_->end()) if (it == value_.map_->end())
@ -1264,8 +1264,8 @@ Value Value::get(const CppTL::ConstString& key,
} }
#endif #endif
bool Value::isMember(char const* key, char const* cend) const { bool Value::isMember(char const* begin, char const* end) const {
Value const* value = find(key, cend); Value const* value = find(begin, end);
return NULL != value; return NULL != value;
} }
bool Value::isMember(char const* key) const { bool Value::isMember(char const* key) const {

6
src/lib_json/json_writer.cpp
View File

@ -643,7 +643,7 @@ bool StyledWriter::hasCommentForValue(const Value& value) {
// Class StyledStreamWriter // Class StyledStreamWriter
// ////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////
StyledStreamWriter::StyledStreamWriter(JSONCPP_STRING indentation) StyledStreamWriter::StyledStreamWriter(const JSONCPP_STRING& indentation)
: document_(NULL), rightMargin_(74), indentation_(indentation), : document_(NULL), rightMargin_(74), indentation_(indentation),
addChildValues_(), indented_(false) {} addChildValues_(), indented_(false) {}
@ -1245,10 +1245,10 @@ void StreamWriterBuilder::setDefaults(Json::Value* settings) {
//! [StreamWriterBuilderDefaults] //! [StreamWriterBuilderDefaults]
} }
JSONCPP_STRING writeString(StreamWriter::Factory const& builder, JSONCPP_STRING writeString(StreamWriter::Factory const& factory,
Value const& root) { Value const& root) {
JSONCPP_OSTRINGSTREAM sout; JSONCPP_OSTRINGSTREAM sout;
StreamWriterPtr const writer(builder.newStreamWriter()); StreamWriterPtr const writer(factory.newStreamWriter());
writer->write(root, &sout); writer->write(root, &sout);
return sout.str(); return sout.str();
} }

16
src/test_lib_json/jsontest.cpp
View File

@ -140,16 +140,6 @@ TestResult& TestResult::popPredicateContext() {
bool TestResult::failed() const { return !failures_.empty(); } bool TestResult::failed() const { return !failures_.empty(); }
unsigned int TestResult::getAssertionNestingLevel() const {
unsigned int level = 0;
const PredicateContext* lastNode = &rootPredicateNode_;
while (lastNode->next_ != 0) {
lastNode = lastNode->next_;
++level;
}
return level;
}
void TestResult::printFailure(bool printTestName) const { void TestResult::printFailure(bool printTestName) const {
if (failures_.empty()) { if (failures_.empty()) {
return; return;
@ -165,7 +155,7 @@ void TestResult::printFailure(bool printTestName) const {
const Failure& failure = *it; const Failure& failure = *it;
JSONCPP_STRING indent(failure.nestingLevel_ * 2, ' '); JSONCPP_STRING indent(failure.nestingLevel_ * 2, ' ');
if (failure.file_) { if (failure.file_) {
printf("%s%s(%d): ", indent.c_str(), failure.file_, failure.line_); printf("%s%s(%u): ", indent.c_str(), failure.file_, failure.line_);
} }
if (!failure.expr_.empty()) { if (!failure.expr_.empty()) {
printf("%s\n", failure.expr_.c_str()); printf("%s\n", failure.expr_.c_str());
@ -281,7 +271,7 @@ bool Runner::runAllTest(bool printSummary) const {
if (failures.empty()) { if (failures.empty()) {
if (printSummary) { if (printSummary) {
printf("All %d tests passed\n", count); printf("All %u tests passed\n", count);
} }
return true; return true;
} else { } else {
@ -293,7 +283,7 @@ bool Runner::runAllTest(bool printSummary) const {
if (printSummary) { if (printSummary) {
unsigned int failedCount = static_cast<unsigned int>(failures.size()); unsigned int failedCount = static_cast<unsigned int>(failures.size());
unsigned int passedCount = count - failedCount; unsigned int passedCount = count - failedCount;
printf("%d/%d tests passed (%d failure(s))\n", passedCount, count, printf("%u/%u tests passed (%u failure(s))\n", passedCount, count,
failedCount); failedCount);
} }
return false; return false;

3
src/test_lib_json/jsontest.h
View File

@ -97,7 +97,6 @@ public:
private: private:
TestResult& addToLastFailure(const JSONCPP_STRING& message); TestResult& addToLastFailure(const JSONCPP_STRING& message);
unsigned int getAssertionNestingLevel() const;
/// Adds a failure or a predicate context /// Adds a failure or a predicate context
void addFailureInfo(const char* file, void addFailureInfo(const char* file,
unsigned int line, unsigned int line,
@ -168,7 +167,7 @@ private: // prevents copy construction and assignment
private: private:
void listTests() const; void listTests() const;
bool testIndex(const JSONCPP_STRING& testName, unsigned int& index) const; bool testIndex(const JSONCPP_STRING& testName, unsigned int& indexOut) const;
static void preventDialogOnCrash(); static void preventDialogOnCrash();
private: private: