xref: /external/deqp/executor/tools/xeBatchResultToJUnit.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program Test Executor
 * ------------------------------------------
 *
 * 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 Batch result to JUnit report conversion tool.
 *//*--------------------------------------------------------------------*/

#include "xeTestLogParser.hpp"
#include "xeTestResultParser.hpp"
#include "xeXMLWriter.hpp"
#include "deFilePath.hpp"
#include "deString.h"
#include "deStringUtil.hpp"

#include <vector>
#include <string>
#include <map>
#include <cstdio>
#include <fstream>

using std::vector;
using std::string;
using std::map;

struct CommandLine
{
	CommandLine (void)
	{
	}

	std::string		batchResultFile;
	std::string		outputFile;
};

static void printHelp (const char* binName)
{
	printf("%s: [testlog] [output file]\n", binName);
}

static void parseCommandLine (CommandLine& cmdLine, int argc, const char* const* argv)
{
	if (argc != 3)
		throw xe::Error("Expected input and output paths");

	cmdLine.batchResultFile	= argv[argc-2];
	cmdLine.outputFile		= argv[argc-1];
}

static void parseBatchResult (xe::TestLogParser& parser, const char* filename)
{
	std::ifstream	in			(filename, std::ios_base::binary);
	deUint8			buf[2048];

	for (;;)
	{
		in.read((char*)&buf[0], sizeof(buf));
		int numRead = (int)in.gcount();

		if (numRead > 0)
			parser.parse(&buf[0], numRead);

		if (numRead < (int)sizeof(buf))
			break;
	}
}

class ResultToJUnitHandler : public xe::TestLogHandler
{
public:
	ResultToJUnitHandler (xe::xml::Writer& writer)
		: m_writer(writer)
	{
	}

	void setSessionInfo (const xe::SessionInfo&)
	{
	}

	xe::TestCaseResultPtr startTestCaseResult (const char* casePath)
	{
		return xe::TestCaseResultPtr(new xe::TestCaseResultData(casePath));
	}

	void testCaseResultUpdated (const xe::TestCaseResultPtr&)
	{
	}

	void testCaseResultComplete (const xe::TestCaseResultPtr& resultData)
	{
		using xe::xml::Writer;

		xe::TestCaseResult result;

		xe::parseTestCaseResultFromData(&m_resultParser, &result, *resultData.get());

		// Split group and case names.
		size_t			sepPos		= result.casePath.find_last_of('.');
		std::string		caseName	= result.casePath.substr(sepPos+1);
		std::string		groupName	= result.casePath.substr(0, sepPos);

		// Write result.
		m_writer << Writer::BeginElement("testcase")
				 << Writer::Attribute("name", caseName)
				 << Writer::Attribute("classname", groupName);

		if (result.statusCode != xe::TESTSTATUSCODE_PASS)
			m_writer << Writer::BeginElement("failure")
					 << Writer::Attribute("type", xe::getTestStatusCodeName(result.statusCode))
					 << result.statusDetails
					 << Writer::EndElement;

		m_writer << Writer::EndElement;
	}

private:
	xe::xml::Writer&		m_writer;
	xe::TestResultParser	m_resultParser;
};

static void batchResultToJUnitReport (const char* batchResultFilename, const char* dstFileName)
{
	std::ofstream				out			(dstFileName, std::ios_base::binary);
	xe::xml::Writer				writer		(out);
	ResultToJUnitHandler		handler		(writer);
	xe::TestLogParser			parser		(&handler);

	XE_CHECK(out.good());

	out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";

	writer << xe::xml::Writer::BeginElement("testsuites")
		   << xe::xml::Writer::BeginElement("testsuite");

	// Parse and write individual cases
	parseBatchResult(parser, batchResultFilename);

	writer << xe::xml::Writer::EndElement << xe::xml::Writer::EndElement;
}

int main (int argc, const char* const* argv)
{
	CommandLine cmdLine;
	try
	{
		parseCommandLine(cmdLine, argc, argv);
	}
	catch (const std::exception&)
	{
		printHelp(argv[0]);
		return -1;
	}

	try
	{
		batchResultToJUnitReport(cmdLine.batchResultFile.c_str(), cmdLine.outputFile.c_str());
	}
	catch (const std::exception& e)
	{
		printf("%s\n", e.what());
		return -1;
	}

	return 0;
}