xref: /third_party/vk-gl-cts/framework/platform/android/tcuTestLogParserJNI.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program Tester Core
 * ----------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Android JNI interface for instrumentations log parsing.
 *//*--------------------------------------------------------------------*/

#include "tcuDefs.hpp"

#include "xeTestResultParser.hpp"
#include "xeTestCaseResult.hpp"
#include "xeContainerFormatParser.hpp"
#include "xeTestLogWriter.hpp"
#include "xeXMLWriter.hpp"

#include <jni.h>
#include <stdlib.h>
#include <android/log.h>

#include <sstream>

namespace
{
static const char*	TESTCASE_STYLESHEET	= "testlog.xsl";
static const char*	LOG_TAG				= "dEQP-TestLog";

class TestLogListener
{
public:
						TestLogListener		(JNIEnv* env, jobject object);
						~TestLogListener	(void);

	void				beginSession		(void);
	void				endSession			(void);
	void				sessionInfo			(const char* name, const char* value);

	void				beginTestCase		(const char* testCasePath);
	void				endTestCase			(void);

	void				terminateTestCase	(const char* reason);
	void				testCaseResult		(const char* statusCode, const char* details);

	void				testLogData			(const char* data);

private:
	JNIEnv*				m_env;
	jobject				m_object;
	jclass				m_class;

	jmethodID			m_sessionInfoID;
	jmethodID			m_beginSessionID;
	jmethodID			m_endSessionID;

	jmethodID			m_beginTestCaseID;
	jmethodID			m_endTestCaseID;
	jmethodID			m_terminateTestCaseID;
	jmethodID			m_testCaseResultID;
	jmethodID			m_testLogData;

						TestLogListener		(const TestLogListener&);
	TestLogListener&	operator=			(const TestLogListener&);
};

TestLogListener::TestLogListener (JNIEnv* env, jobject object)
	: m_env		(env)
	, m_object	(object)
{
	m_class					= m_env->GetObjectClass(m_object);
	m_sessionInfoID			= m_env->GetMethodID(m_class, "sessionInfo",		"(Ljava/lang/String;Ljava/lang/String;)V");
	m_beginSessionID		= m_env->GetMethodID(m_class, "beginSession",		"()V");
	m_endSessionID			= m_env->GetMethodID(m_class, "endSession",			"()V");
	m_beginTestCaseID		= m_env->GetMethodID(m_class, "beginTestCase",		"(Ljava/lang/String;)V");
	m_endTestCaseID			= m_env->GetMethodID(m_class, "endTestCase",		"()V");
	m_terminateTestCaseID	= m_env->GetMethodID(m_class, "terminateTestCase",	"(Ljava/lang/String;)V");
	m_testCaseResultID		= m_env->GetMethodID(m_class, "testCaseResult",		"(Ljava/lang/String;Ljava/lang/String;)V");
	m_testLogData			= m_env->GetMethodID(m_class, "testLogData",		"(Ljava/lang/String;)V");

	TCU_CHECK_INTERNAL(m_beginSessionID);
	TCU_CHECK_INTERNAL(m_endSessionID);
	TCU_CHECK_INTERNAL(m_sessionInfoID);
	TCU_CHECK_INTERNAL(m_beginTestCaseID);
	TCU_CHECK_INTERNAL(m_endTestCaseID);
	TCU_CHECK_INTERNAL(m_terminateTestCaseID);
	TCU_CHECK_INTERNAL(m_testCaseResultID);
	TCU_CHECK_INTERNAL(m_testLogData);
}

TestLogListener::~TestLogListener (void)
{
}

void TestLogListener::beginSession (void)
{
	m_env->CallVoidMethod(m_object, m_beginSessionID);
}

void TestLogListener::endSession (void)
{
	m_env->CallVoidMethod(m_object, m_endSessionID);
}

void TestLogListener::sessionInfo (const char* name, const char* value)
{
	jstring jName	= m_env->NewStringUTF(name);
	jstring jValue	= m_env->NewStringUTF(value);

	m_env->CallVoidMethod(m_object, m_sessionInfoID, jName, jValue);
	m_env->DeleteLocalRef(jName);
	m_env->DeleteLocalRef(jValue);
}

void TestLogListener::beginTestCase (const char* testCasePath)
{
	jstring jTestCasePath = m_env->NewStringUTF(testCasePath);

	m_env->CallVoidMethod(m_object, m_beginTestCaseID, jTestCasePath);
	m_env->DeleteLocalRef(jTestCasePath);
}

void TestLogListener::endTestCase (void)
{
	m_env->CallVoidMethod(m_object, m_endTestCaseID);
}

void TestLogListener::terminateTestCase (const char* reason)
{
	jstring	 jReason = m_env->NewStringUTF(reason);

	m_env->CallVoidMethod(m_object, m_terminateTestCaseID, jReason);
	m_env->DeleteLocalRef(jReason);
}

void TestLogListener::testCaseResult (const char* statusCode, const char* details)
{
	jstring	 jStatusCode	= m_env->NewStringUTF(statusCode);
	jstring	 jDetails		= m_env->NewStringUTF(details);

	m_env->CallVoidMethod(m_object, m_testCaseResultID, jStatusCode, jDetails);
	m_env->DeleteLocalRef(jStatusCode);
	m_env->DeleteLocalRef(jDetails);
}

void TestLogListener::testLogData (const char* data)
{
	jstring logData = m_env->NewStringUTF(data);

	m_env->CallVoidMethod(m_object, m_testLogData, logData);
	m_env->DeleteLocalRef(logData);
}

class TestLogParser
{
public:
								TestLogParser	(bool logData);
								~TestLogParser	(void);

	void						parse			(TestLogListener& listener, const char* buffer, size_t size);

private:
	const bool					m_logData;

	bool						m_inTestCase;
	bool						m_loggedResult;
	xe::ContainerFormatParser	m_containerParser;
	xe::TestCaseResult			m_testCaseResult;
	xe::TestResultParser		m_testResultParser;

								TestLogParser	(const TestLogParser&);
	TestLogParser&				operator=		(const TestLogParser&);
};

TestLogParser::TestLogParser (bool logData)
	: m_logData			(logData)
	, m_inTestCase		(DE_FALSE)
	, m_loggedResult	(DE_FALSE)
{
}

TestLogParser::~TestLogParser (void)
{
}

void TestLogParser::parse (TestLogListener& listener, const char* buffer, size_t size)
{
	m_containerParser.feed((const deUint8*)buffer, size);

	while (m_containerParser.getElement() != xe::CONTAINERELEMENT_INCOMPLETE)
	{
		switch (m_containerParser.getElement())
		{
			case xe::CONTAINERELEMENT_END_OF_STRING:
				// Do nothing
				break;

			case xe::CONTAINERELEMENT_BEGIN_SESSION:
				listener.beginSession();
				break;

			case xe::CONTAINERELEMENT_END_SESSION:
				listener.endSession();
				break;

			case xe::CONTAINERELEMENT_SESSION_INFO:
				listener.sessionInfo(m_containerParser.getSessionInfoAttribute(), m_containerParser.getSessionInfoValue());
				break;

			case xe::CONTAINERELEMENT_BEGIN_TEST_CASE_RESULT:
				listener.beginTestCase(m_containerParser.getTestCasePath());

				m_inTestCase		= DE_TRUE;
				m_loggedResult		= DE_FALSE;
				m_testCaseResult	= xe::TestCaseResult();

				m_testResultParser.init(&m_testCaseResult);
				break;

			case xe::CONTAINERELEMENT_END_TEST_CASE_RESULT:
				if (m_testCaseResult.statusCode != xe::TESTSTATUSCODE_LAST && !m_loggedResult)
				{
					listener.testCaseResult(xe::getTestStatusCodeName(m_testCaseResult.statusCode), m_testCaseResult.statusDetails.c_str());
					m_loggedResult = DE_TRUE;
				}

				if (m_logData)
				{
					std::ostringstream	testLog;
					xe::xml::Writer		xmlWriter(testLog);

					testLog << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
							<< "<?xml-stylesheet href=\"" << TESTCASE_STYLESHEET << "\" type=\"text/xsl\"?>\n";

					xe::writeTestResult(m_testCaseResult, xmlWriter);

					listener.testLogData(testLog.str().c_str());
				}

				listener.endTestCase();

				m_inTestCase = DE_FALSE;
				break;

			case xe::CONTAINERELEMENT_TERMINATE_TEST_CASE_RESULT:
				if (m_logData)
				{
					std::ostringstream	testLog;
					xe::xml::Writer		xmlWriter(testLog);

					testLog << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
							<< "<?xml-stylesheet href=\"" << TESTCASE_STYLESHEET << "\" type=\"text/xsl\"?>\n";

					xe::writeTestResult(m_testCaseResult, xmlWriter);

					listener.testLogData(testLog.str().c_str());
				}

				if (m_testCaseResult.statusCode != xe::TESTSTATUSCODE_LAST && !m_loggedResult)
				{
					listener.testCaseResult(xe::getTestStatusCodeName(m_testCaseResult.statusCode), m_testCaseResult.statusDetails.c_str());
					m_loggedResult = DE_TRUE;
				}

				listener.terminateTestCase(m_containerParser.getTerminateReason());
				m_inTestCase = DE_FALSE;
				break;

			case xe::CONTAINERELEMENT_TEST_LOG_DATA:
			{
				if (m_inTestCase)
				{
					std::vector<deUint8> data(m_containerParser.getDataSize());
					m_containerParser.getData(&(data[0]), (int)data.size(), 0);

					//tcu::print("%d %s :%s %s", __LINE__, std::string((const char*)&data[0], data.size()).c_str(), __func__, __FILE__);

					if (m_testResultParser.parse(&(data[0]), (int)data.size()) == xe::TestResultParser::PARSERESULT_CHANGED)
					{
						if (m_testCaseResult.statusCode != xe::TESTSTATUSCODE_LAST && !m_loggedResult)
						{
							listener.testCaseResult(xe::getTestStatusCodeName(m_testCaseResult.statusCode), m_testCaseResult.statusDetails.c_str());
							m_loggedResult = DE_TRUE;
						}
					}
				}

				break;
			}

			default:
				DE_ASSERT(DE_FALSE);

		};

		m_containerParser.advance();
	}
}

void throwJNIException (JNIEnv* env, const std::exception& e)
{
	jclass exClass;

	exClass = env->FindClass("java/lang/Exception");

	TCU_CHECK_INTERNAL(exClass != DE_NULL);

	TCU_CHECK_INTERNAL(env->ThrowNew(exClass, e.what()) == 0);
}

} // anonymous

DE_BEGIN_EXTERN_C

JNIEXPORT jlong JNICALL Java_com_drawelements_deqp_testercore_TestLogParser_nativeCreate (JNIEnv* env, jclass, jboolean logData)
{
	DE_UNREF(env);

	try
	{
		return (jlong)new TestLogParser(logData);
	}
	catch (const std::exception& e)
	{
		__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "%s", e.what());

		throwJNIException(env, e);
		return 0;
	}
}

JNIEXPORT void JNICALL Java_com_drawelements_deqp_testercore_TestLogParser_nativeDestroy (JNIEnv* env, jclass, jlong nativePointer)
{
	DE_UNREF(env);

	try
	{
		delete ((TestLogParser*)nativePointer);
	}
	catch (const std::exception& e)
	{
		__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "%s", e.what());

		throwJNIException(env, e);
	}
}

JNIEXPORT void JNICALL Java_com_drawelements_deqp_testercore_TestLogParser_nativeParse (JNIEnv* env, jclass, jlong nativePointer, jobject instrumentation, jbyteArray buffer, jint size)
{
	jbyte* logData = DE_NULL;

	try
	{
		TestLogParser*	parser		= (TestLogParser*)nativePointer;
		TestLogListener	listener	(env, instrumentation);

		logData = env->GetByteArrayElements(buffer, NULL);

		parser->parse(listener, (const char*)logData, (size_t)size);
		env->ReleaseByteArrayElements(buffer, logData, JNI_ABORT);
		logData = DE_NULL;
	}
	catch (const std::exception& e)
	{
		__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, "%s", e.what());

		if (logData)
			env->ReleaseByteArrayElements(buffer, logData, JNI_ABORT);

		throwJNIException(env, e);
	}
}

DE_END_EXTERN_C