json_error_t* json_append_child(json_t *root, json_t *child) {
json_t* current;
json_t* last;
if(!root || !child) {
return parsingError(
JSON_NULL_POINTER,
"Error: Unable to append child to root object. in json_append_child() function",
NULL,
NULL
);
}
if(!root->children) {
root->children = child;
} else {
for(current = root->children; current != NULL; current = current->next ) {
last = current;
}
last->next = child;
}
child->next = NULL;
// root->children->last = child;
return NULL; /* exit without any error */
}
void tst_QWaveDecoder::file()
{
QFETCH(QString, file);
QFETCH(tst_QWaveDecoder::Corruption, corruption);
QFETCH(int, channels);
QFETCH(int, samplesize);
QFETCH(int, samplerate);
QFETCH(QAudioFormat::Endian, byteorder);
QFile stream;
stream.setFileName(file);
stream.open(QIODevice::ReadOnly);
QVERIFY(stream.isOpen());
QWaveDecoder waveDecoder(&stream);
QSignalSpy validFormatSpy(&waveDecoder, SIGNAL(formatKnown()));
QSignalSpy parsingErrorSpy(&waveDecoder, SIGNAL(parsingError()));
if (corruption == NotAWav) {
QSKIP("Not all failures detected correctly yet");
QTRY_COMPARE(parsingErrorSpy.count(), 1);
QCOMPARE(validFormatSpy.count(), 0);
} else if (corruption == NoSampleData) {
QTRY_COMPARE(validFormatSpy.count(), 1);
QCOMPARE(parsingErrorSpy.count(), 0);
QVERIFY(waveDecoder.audioFormat().isValid());
QVERIFY(waveDecoder.size() == 0);
QVERIFY(waveDecoder.duration() == 0);
} else if (corruption == FormatDescriptor) {
QTRY_COMPARE(parsingErrorSpy.count(), 1);
QCOMPARE(validFormatSpy.count(), 0);
} else if (corruption == FormatString) {
QTRY_COMPARE(parsingErrorSpy.count(), 1);
QCOMPARE(validFormatSpy.count(), 0);
QVERIFY(!waveDecoder.audioFormat().isValid());
} else if (corruption == DataDescriptor) {
QTRY_COMPARE(parsingErrorSpy.count(), 1);
QCOMPARE(validFormatSpy.count(), 0);
QVERIFY(waveDecoder.size() == 0);
} else if (corruption == None) {
QTRY_COMPARE(validFormatSpy.count(), 1);
QCOMPARE(parsingErrorSpy.count(), 0);
QVERIFY(waveDecoder.audioFormat().isValid());
QVERIFY(waveDecoder.size() > 0);
QVERIFY(waveDecoder.duration() == 250);
QAudioFormat format = waveDecoder.audioFormat();
QVERIFY(format.isValid());
QVERIFY(format.channelCount() == channels);
QVERIFY(format.sampleSize() == samplesize);
QVERIFY(format.sampleRate() == samplerate);
if (format.sampleSize() != 8) {
QVERIFY(format.byteOrder() == byteorder);
}
}
stream.close();
}
void QWaveDecoder::parsingFailed()
{
Q_ASSERT(source);
source->disconnect(SIGNAL(readyRead()), this, SLOT(handleData()));
emit parsingError();
}
json_error_t * json_from_string(char *jsonString, json_t **destObject) {
int resultCode = 0;
jsmn_parser parser;
jsmntok_t tokens[TOKENS_COUNT];
size_t tokenIndex = 0;
jsmntok_t *failedToken = NULL;
if(jsonString == NULL) {
return parsingError(
JSON_NULL_POINTER,
"Error: Json string is NULL.",
NULL,
NULL
);
}
memset(tokens, 0, TOKENS_COUNT*sizeof(jsmntok_t));
json_t *root = NULL;
jsmn_init(&parser);
resultCode = jsmn_parse(&parser, jsonString, tokens, TOKENS_COUNT);
if(resultCode != JSMN_SUCCESS) {
failedToken = ((tokenIndex <= TOKENS_COUNT) ? &tokens[tokenIndex] : NULL);
switch(resultCode) {
case JSMN_ERROR_INVAL:
return parsingError(
JSON_INVALID_INPUT,
"Error: Invalid character inside JSON string.",
failedToken,
jsonString
);
case JSMN_ERROR_NOMEM:
return parsingError(
JSON_MEMORY_ALLOC_FAILED,
"Error: Not enough tokens were provided. Please add more tokens in application configuration.",
failedToken,
jsonString
);
case JSMN_ERROR_PART:
return parsingError(
JSON_INVALID_INPUT,
"Error: The string is not a full JSON packet, more bytes expected.",
failedToken,
jsonString
);
case JSMN_SUCCESS:
break;
default:
return parsingError(
JSON_INLLEGAL_STATE_EXCEPTION,
"Error: Invalid jsmp result code. Normally program should not reach here.",
NULL,
NULL
);
}
}
json_error_t *parseError = NULL;
parseError = createJsonObject(&root, jsonString, tokens, TOKENS_COUNT, &tokenIndex );
if(parseError != NULL) {
json_object_free(root);
return parseError;
}
*destObject = root;
return NULL; /* none errors */
}
inline
json_error_t* allocate_object_by_type(
json_t **objectPtr,
jsmntok_t *token,
jsmntok_t tokens[TOKENS_COUNT], size_t tokensCount, size_t *tokenIndex,
char* js) {
json_error_t* parseError = NULL;
json_t* jsonObject = NULL;
json_type type = decode_jsmn_type(token->type);
switch (type) {
case JSON_STRING:
jsonObject = json_alloc(JSON_STRING, token->size);
if(jsonObject == NULL) {
parseError = parsingError(
JSON_MEMORY_ALLOC_FAILED,
"Error: Unable to allocate string object.",
token,
js
);
}
break;
case JSON_PRIMITIVE:
{
char *firstCharacter = js + token->start;
switch(*firstCharacter) {
case '-': {};
case '0': {};
case '1': {};
case '2': {};
case '3': {};
case '4': {};
case '5': {};
case '6': {};
case '7': {};
case '8': {};
case '9': {};
jsonObject = json_alloc(JSON_NUMBER, token->size);
break;
case 't':
jsonObject = json_alloc(JSON_TRUE, token->size);
break;
case 'f':
jsonObject = json_alloc(JSON_FALSE, token->size);
break;
case 'n' :
jsonObject = json_alloc(JSON_NULL, token->size);
break;
default:
parseError = parsingError(
JSON_INVALID_OBJECT_TYPE,
"Error: Unable to allocate primitive object by first character. Wrong character at -->",
token,
js
);
break;
}
} break;
case JSON_OBJECT:
case JSON_ARRAY:
parseError = createJsonObject(&jsonObject, js, tokens, tokensCount, tokenIndex);
break;
default:
parseError = parsingError(
JSON_INVALID_OBJECT_TYPE,
"Error: Unable to allocate object by type. Wrong type.",
token,
js
);
break;
}
if(parseError == NULL) {
add_value_from_token(jsonObject, js, token);
// /* assign returned object */
// if(objectPtr != NULL) {
// json_free(objectPtr);
// }
// objectPtr = (json_t*) json_malloc(sizeof(json_t));
// memcpy(objectPtr, jsonObject, sizeof(json_t));
//
// json_free(jsonObject);
*objectPtr = jsonObject;
}
return parseError;
}
json_error_t* createJsonObject(
json_t **json_root,
char *js,
jsmntok_t tokens[TOKENS_COUNT],
size_t tokensCount,
size_t *tokenIndex
) {
typedef enum { START, KEY, PRINT, VALUE, ARRAY, STOP } parse_state;
parse_state state = START;
json_error_t* error = NULL;
//static char msgBuffer[MSG_BUFFER_SIZE];
//size_t tokenIndex = 0;
// strbuffer_t *tokenStr = NULL;
size_t object_tokens = 0;
json_t *root = NULL;
json_t *key = NULL;
json_t *value = NULL;
for (; *tokenIndex < tokensCount; *tokenIndex += 1 ) {
jsmntok_t *token = &tokens[*tokenIndex];
// size_t heapSize = xPortGetFreeHeapSize();
// sprintf(msgBuffer, "HEAP SIZE: %d\n", heapSize);
// log_d(msgBuffer);
if(token->start > strlen(js)
|| token->end > strlen(js)
|| token->end > strlen(js)
|| (token->end - token->start) > strlen(js)
) {
continue;
}
// tokenStr = json_token_tostr(js, token);
switch (state) {
case START:
if (token->type != JSMN_OBJECT && token->type != JSMN_ARRAY) {
return parsingError(
JSON_INVALID_OBJECT_TYPE,
"Error: Root object is not object or array.",
token,
js
);
}
switch(token->type) {
case JSMN_OBJECT:
root = json_alloc(JSON_OBJECT, token->size);
if(root == NULL) {
freeResources(root, key, value);
return parsingError(
JSON_MEMORY_ALLOC_FAILED,
"Error: Unable to allocate root object.",
token,
js
);
}
state = KEY;
break;
case JSMN_ARRAY:
state = ARRAY;
root = json_alloc(JSON_ARRAY, token->size);
if(root == NULL) {
freeResources(root, key, value);
return parsingError(
JSON_MEMORY_ALLOC_FAILED,
"Error: Unable to allocate root array.",
token,
js
);
}
break;
default:
freeResources(root, key, value);
return parsingError(
JSON_INVALID_OBJECT_TYPE,
"Error: Root object is not object or array.",
token,
js
);
}
object_tokens = token->size;
if (object_tokens == 0) {
*json_root = root;
return NULL; /* exit with no errors */
}
// if (object_tokens % 2 != 0)
// log_die("Invalid response: object must have even number of children. %d\n", tokenIndex);
break;
case KEY:
if (token->type != JSMN_STRING) {
freeResources(root, key, value);
return parsingError(
JSON_INVALID_OBJECT_TYPE,
"Error: Object key is not string.",
token,
js
);
}
key = json_alloc(JSON_KEY, token->size);
if(key == NULL) {
freeResources(root, key, value);
return parsingError(
JSON_MEMORY_ALLOC_FAILED,
"Error: Unable to allocate memory for json key object.",
token,
js
);
}
add_value_from_token(key, js, token);
if(key->value == NULL) {
freeResources(root, key, value);
return parsingError(
JSON_MEMORY_ALLOC_FAILED,
"Error: Unable to allocate memory for json key string.",
token,
js
);
}
error = json_append_child(root, key);
if( error != NULL) {
freeResources(root, key, value);
return error;
}
object_tokens--;
state = VALUE;
break;
case VALUE:
// if (token->type != JSMN_STRING && token->type != JSMN_PRIMITIVE)
// printf("failed: not string and not primitive skip %d\n", tokenIndex);
error = allocate_object_by_type(
&value,
token, tokens, tokensCount,
tokenIndex, js);
if(error != NULL) {
freeResources(root, key, value);
return error;
}
error = json_append_child(key, value);
if(error != NULL) {
freeResources(root, key, value);
return error;
}
object_tokens--;
state = KEY;
if (object_tokens == 0) {
*json_root = root;
return NULL; /* exit with no errors */
}
break;
case ARRAY:
if(root->type != JSON_ARRAY) {
freeResources(root, key, value);
return parsingError(
JSON_INVALID_OBJECT_TYPE,
"Error: In state ARRAY. Parent element is not array",
token,
js
);
}
error = allocate_object_by_type(
&value,
token, tokens, tokensCount,
tokenIndex, js);
if(error != NULL) {
freeResources(root, key, value);
return error;
}
error = json_append_child(root, value);
if(error != NULL) {
freeResources(root, key, value);
return error;
}
object_tokens--;
state = ARRAY;
if (object_tokens == 0) {
*json_root = root;
return NULL; /* exit with no errors */
}
break;
case STOP:
// Just consume the tokens
return NULL; /* exit with no errors */
break;
default:
return parsingError(
JSON_INLLEGAL_STATE_EXCEPTION,
"Error: Invalid parsing state. Program should not get here!",
NULL,
NULL
);
}
}
return parsingError(
JSON_INLLEGAL_STATE_EXCEPTION,
"Error: Program should not get here!",
NULL,
NULL
);
//json_object_free(root);
// for (tokenIndex = 0, tokensLeft = 1; tokensLeft > 0;
// tokenIndex++, tokensLeft--) {
//
// jsmntok_t *t = &tokens[tokenIndex];
//
// // Should never reach uninitialized tokens
// log_assert(t->start != -1 && t->end != -1);
//
// if (t->type == JSMN_ARRAY || t->type == JSMN_OBJECT)
// tokensLeft += t->size;
//
// switch (state) {
// case START:
// if (t->type != JSMN_OBJECT)
// printf("failed NOt object: %d\n", tokenIndex);
//
// state = KEY;
// object_tokens = t->size;
//
// if (object_tokens == 0)
// state = STOP;
//
// if (object_tokens % 2 != 0)
// printf("failed: %d\n", tokenIndex);
//
// break;
//
// case KEY:
// object_tokens--;
//
// if (t->type != JSMN_STRING)
// printf("failed: Key is not string %d\n", tokenIndex);
//
// state = SKIP;
//
// for (i = 0; i < sizeof(KEYS) / sizeof(char *); i++) {
// if (json_token_streq(js, t, KEYS[i])) {
// printf("%s: ", KEYS[i]);
// state = PRINT;
// break;
// }
// }
//
// break;
//
// case SKIP:
// if (t->type != JSMN_STRING && t->type != JSMN_PRIMITIVE)
// printf("failed: not string and not primitive skip %d\n", tokenIndex);
//
// object_tokens--;
// state = KEY;
//
// if (object_tokens == 0)
// state = STOP;
//
// break;
//
// case PRINT:
// if (t->type != JSMN_STRING && t->type != JSMN_PRIMITIVE)
// printf("failed not string and not primitive print: %d\n", tokenIndex);
//
// char *str = json_token_tostr(js, t);
// puts(str);
//
// object_tokens--;
// state = KEY;
//
// if (object_tokens == 0)
// state = STOP;
//
// break;
//
// case STOP:
// // Just consume the tokens
// break;
//
// default:
// log_die("Invalid state %u", state);
// }
// }
}
