xref: /haiku/src/tests/kits/shared/JsonErrorHandlingTest.cpp

/*
 * Copyright 2017, Andrew Lindesay <apl@lindesay.co.nz>
 * Distributed under the terms of the MIT License.
 */
#include "JsonErrorHandlingTest.h"

#include <AutoDeleter.h>

#include <Json.h>
#include <JsonEventListener.h>

#include <cppunit/TestCaller.h>
#include <cppunit/TestSuite.h>

#include "JsonSamples.h"


using namespace BPrivate;

class ErrorCapturingListener : public BJsonEventListener {
public:
								ErrorCapturingListener();
		virtual					~ErrorCapturingListener();

			bool				Handle(const BJsonEvent& event);
			void				HandleError(status_t status, int32 line,
									const char* message);
			void				Complete() {};

			status_t			ErrorStatus();
			int32				GetErrorLine();
			BString				GetErrorMessage();
			bool				HasEventsAfterError();
			json_event_type		FirstEventTypeAfterError();
private:
			status_t			fErrorStatus;
			int32				fErrorLine;
			BString				fErrorMessage;
			json_event_type		fFirstEventTypeAfterError;
			int32				fEventCountAfterError;

};


/*! This DataIO concrete implementation is designed to open and then to fail
    in order to simulate what might happen if there were an IO problem when
    parsing some JSON.
*/

class FailingDataIO : public BDataIO {
public:
									FailingDataIO();
		virtual						~FailingDataIO();

		ssize_t						Read(void* buffer, size_t size);
		ssize_t						Write(const void* buffer, size_t size);

		status_t					Flush();
};


// #pragma mark - FailingDataIO


FailingDataIO::FailingDataIO()
{
}


FailingDataIO::~FailingDataIO()
{
}


ssize_t
FailingDataIO::Read(void* buffer, size_t size)
{
	return B_IO_ERROR;
}


ssize_t
FailingDataIO::Write(const void* buffer, size_t size)
{
	fprintf(stdout, "attempt to write");
	return B_IO_ERROR;
}


status_t
FailingDataIO::Flush()
{
	return B_IO_ERROR;
}


// #pragma mark - ErrorCapturingListener


ErrorCapturingListener::ErrorCapturingListener()
{
	fErrorStatus = B_OK;
	fFirstEventTypeAfterError = B_JSON_NULL; // least likely
	fEventCountAfterError = 0;
}


ErrorCapturingListener::~ErrorCapturingListener()
{
}


bool
ErrorCapturingListener::Handle(const BJsonEvent& event)
{
	if (fErrorStatus != B_OK) {
		if (fEventCountAfterError == 0)
			fFirstEventTypeAfterError = event.EventType();

		fEventCountAfterError++;
	}
	return true; // keep going.
}


void
ErrorCapturingListener::HandleError(status_t status, int32 line,
	const char *message)
{
	fErrorStatus = status;
	fErrorLine = line;

	if (message != NULL)
		fErrorMessage = BString(message);
	else
		fErrorMessage = BString();
}


status_t
ErrorCapturingListener::ErrorStatus()
{
	return fErrorStatus;
}


int32
ErrorCapturingListener::GetErrorLine()
{
	return fErrorLine;
}


BString
ErrorCapturingListener::GetErrorMessage()
{
	return fErrorMessage;
}


json_event_type
ErrorCapturingListener::FirstEventTypeAfterError()
{
	return fFirstEventTypeAfterError;
}


bool
ErrorCapturingListener::HasEventsAfterError()
{
	return fEventCountAfterError > 0;
}


JsonErrorHandlingTest::JsonErrorHandlingTest()
{
}


JsonErrorHandlingTest::~JsonErrorHandlingTest()
{
}


void
JsonErrorHandlingTest::TestParseWithBadStringEscape(const char* input,
	int32 line, status_t expectedStatus, char expectedBadEscapeChar)
{
	BString expectedMessage;
	expectedMessage.SetToFormat("unexpected escaped character [%c] "
		"in string parsing", expectedBadEscapeChar);

	TestParseWithErrorMessage(input, line, expectedStatus,
		expectedMessage.String());
}


void
JsonErrorHandlingTest::TestParseWithUnterminatedElement(const char* input,
	int32 line, status_t expectedStatus)
{
	BString expectedMessage;
	expectedMessage.SetToFormat("unterminated element");

	TestParseWithErrorMessage(input, line, expectedStatus,
		expectedMessage.String());
}


void
JsonErrorHandlingTest::TestParseWithUnexpectedCharacter(const char* input,
	int32 line, status_t expectedStatus, char expectedChar)
{
	BString expectedMessage;
	expectedMessage.SetToFormat("unexpected character [%" B_PRIu8
		"] (%c) when parsing element", static_cast<uint8>(expectedChar),
		expectedChar);

	TestParseWithErrorMessage(input, line, expectedStatus,
		expectedMessage.String());
}


void
JsonErrorHandlingTest::TestParseWithErrorMessage(const char* input, int32 line,
	status_t expectedStatus, const char* expectedMessage)
{
	fprintf(stderr, "in >%s<\n", input);
	BDataIO *inputData = new BMemoryIO(input, strlen(input));
	ObjectDeleter<BDataIO> inputDataDeleter(inputData);
	TestParseWithErrorMessage(inputData, line, expectedStatus, expectedMessage);
}


void
JsonErrorHandlingTest::TestParseWithErrorMessage(BDataIO* inputData, int32 line,
	status_t expectedStatus, const char* expectedMessage)
{
	ErrorCapturingListener* listener = new ErrorCapturingListener();
	ObjectDeleter<ErrorCapturingListener> listenerDeleter(listener);

// ----------------------
	BPrivate::BJson::Parse(inputData, listener);
// ----------------------

	fprintf(stderr, "expected error at line %" B_PRIi32 " - %s : %s\n",
		line,
		strerror(expectedStatus),
		expectedMessage);

	fprintf(stderr, "actual error at line %" B_PRIi32 " - %s : %s\n",
		listener->GetErrorLine(),
		strerror(listener->ErrorStatus()),
		listener->GetErrorMessage().String());

	if (listener->HasEventsAfterError()) {
		fprintf(stderr, "first event after error [%d]\n",
			listener->FirstEventTypeAfterError());
	}

	CPPUNIT_ASSERT(!listener->HasEventsAfterError());
	CPPUNIT_ASSERT_EQUAL(expectedStatus, listener->ErrorStatus());
	CPPUNIT_ASSERT_EQUAL(line, listener->GetErrorLine());
	CPPUNIT_ASSERT(0 == strcmp(expectedMessage,
		listener->GetErrorMessage().String()));
}


void
JsonErrorHandlingTest::TestCompletelyUnknown()
{
	TestParseWithUnexpectedCharacter(
		JSON_SAMPLE_BROKEN_COMPLETELY_UNKNOWN, 1, B_BAD_DATA, 'z');
}


void
JsonErrorHandlingTest::TestObjectWithPrematureSeparator()
{
	TestParseWithErrorMessage(JSON_SAMPLE_BROKEN_OBJECT_PREMATURE_SEPARATOR, 1,
		B_BAD_DATA, "unexpected item separator when parsing start of object");
}


void
JsonErrorHandlingTest::TestStringUnterminated()
{
	TestParseWithErrorMessage(JSON_SAMPLE_BROKEN_UNTERMINATED_STRING, 1,
		B_BAD_DATA, "unexpected end of input");
}


void
JsonErrorHandlingTest::TestBadStringEscape()
{
	TestParseWithBadStringEscape(
		JSON_SAMPLE_BROKEN_BAD_STRING_ESCAPE, 1, B_BAD_DATA, 'v');
}


void
JsonErrorHandlingTest::TestBadNumber()
{
	TestParseWithErrorMessage(JSON_SAMPLE_BROKEN_NUMBER, 1, B_BAD_DATA,
		"malformed number");
}


void
JsonErrorHandlingTest::TestIOIssue()
{
	BDataIO *inputData = new FailingDataIO();
	ObjectDeleter<BDataIO> inputDataDeleter(inputData);
	TestParseWithErrorMessage(inputData, -1, B_IO_ERROR,
		"io related read error");
}


/*static*/ void
JsonErrorHandlingTest::AddTests(BTestSuite& parent)
{
	CppUnit::TestSuite& suite = *new CppUnit::TestSuite(
		"JsonErrorHandlingTest");

	suite.addTest(new CppUnit::TestCaller<JsonErrorHandlingTest>(
		"JsonErrorHandlingTest::TestCompletelyUnknown",
		&JsonErrorHandlingTest::TestCompletelyUnknown));

	suite.addTest(new CppUnit::TestCaller<JsonErrorHandlingTest>(
		"JsonErrorHandlingTest::TestObjectWithPrematureSeparator",
		&JsonErrorHandlingTest::TestObjectWithPrematureSeparator));

	suite.addTest(new CppUnit::TestCaller<JsonErrorHandlingTest>(
		"JsonErrorHandlingTest::TestStringUnterminated",
		&JsonErrorHandlingTest::TestStringUnterminated));

	suite.addTest(new CppUnit::TestCaller<JsonErrorHandlingTest>(
		"JsonErrorHandlingTest::TestBadStringEscape",
		&JsonErrorHandlingTest::TestBadStringEscape));

	suite.addTest(new CppUnit::TestCaller<JsonErrorHandlingTest>(
		"JsonErrorHandlingTest::TestBadNumber",
		&JsonErrorHandlingTest::TestBadNumber));

	suite.addTest(new CppUnit::TestCaller<JsonErrorHandlingTest>(
		"JsonErrorHandlingTest::TestIOIssue",
		&JsonErrorHandlingTest::TestIOIssue));

	parent.addTest("JsonErrorHandlingTest", &suite);
}