/*-------------------------------------------------------------------------
|
* 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
|
