executor/tools/xeMergeTestLogs.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 Merge two test logs.
 *
 * \todo [2013-11-08 pyry] Write variant that can operate with less memory.
 *//*--------------------------------------------------------------------*/

#include "xeTestLogParser.hpp"
#include "xeTestResultParser.hpp"
#include "xeTestLogWriter.hpp"
#include "deString.h"

#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <stdexcept>

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

enum Flags
{
	FLAG_USE_LAST_INFO = (1<<0)
};

struct CommandLine
{
	CommandLine (void)
		: flags(0)
	{
	}

	vector<string>	srcFilenames;
	string			dstFilename;
	deUint32		flags;
};

class LogHandler : public xe::TestLogHandler
{
public:
	LogHandler (xe::BatchResult* batchResult, deUint32 flags)
		: m_batchResult	(batchResult)
		, m_flags		(flags)
	{
	}

	void setSessionInfo (const xe::SessionInfo& info)
	{
		xe::SessionInfo& combinedInfo = m_batchResult->getSessionInfo();

		if (m_flags & FLAG_USE_LAST_INFO)
		{
			if (!info.targetName.empty())		combinedInfo.targetName			= info.targetName;
			if (!info.releaseId.empty())		combinedInfo.releaseId			= info.releaseId;
			if (!info.releaseName.empty())		combinedInfo.releaseName		= info.releaseName;
			if (!info.candyTargetName.empty())	combinedInfo.candyTargetName	= info.candyTargetName;
			if (!info.configName.empty())		combinedInfo.configName			= info.configName;
			if (!info.resultName.empty())		combinedInfo.resultName			= info.resultName;
			if (!info.timestamp.empty())		combinedInfo.timestamp			= info.timestamp;
		}
		else
		{
			if (combinedInfo.targetName.empty())		combinedInfo.targetName			= info.targetName;
			if (combinedInfo.releaseId.empty())			combinedInfo.releaseId			= info.releaseId;
			if (combinedInfo.releaseName.empty())		combinedInfo.releaseName		= info.releaseName;
			if (combinedInfo.candyTargetName.empty())	combinedInfo.candyTargetName	= info.candyTargetName;
			if (combinedInfo.configName.empty())		combinedInfo.configName			= info.configName;
			if (combinedInfo.resultName.empty())		combinedInfo.resultName			= info.resultName;
			if (combinedInfo.timestamp.empty())			combinedInfo.timestamp			= info.timestamp;
		}
	}

	xe::TestCaseResultPtr startTestCaseResult (const char* casePath)
	{
		if (m_batchResult->hasTestCaseResult(casePath))
		{
			xe::TestCaseResultPtr existingResult = m_batchResult->getTestCaseResult(casePath);
			existingResult->clear();
			return existingResult;
		}
		else
			return m_batchResult->createTestCaseResult(casePath);
	}

	void testCaseResultUpdated (const xe::TestCaseResultPtr&)
	{
		// Ignored.
	}

	void testCaseResultComplete (const xe::TestCaseResultPtr&)
	{
		// Ignored.
	}

private:
	xe::BatchResult* const	m_batchResult;
	const deUint32			m_flags;
};

static void readLogFile (xe::BatchResult* dstResult, const char* filename, deUint32 flags)
{
	std::ifstream		in				(filename, std::ifstream::binary|std::ifstream::in);
	LogHandler			resultHandler	(dstResult, flags);
	xe::TestLogParser	parser			(&resultHandler);
	deUint8				buf				[2048];
	int					numRead			= 0;

	if (!in.good())
		throw std::runtime_error(string("Failed to open '") + filename + "'");

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

		if (numRead <= 0)
			break;

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

	in.close();
}

static void mergeTestLogs (const CommandLine& cmdLine)
{
	xe::BatchResult batchResult;

	for (vector<string>::const_iterator filename = cmdLine.srcFilenames.begin(); filename != cmdLine.srcFilenames.end(); ++filename)
		readLogFile(&batchResult, filename->c_str(), cmdLine.flags);

	if (!cmdLine.dstFilename.empty())
		xe::writeBatchResultToFile(batchResult, cmdLine.dstFilename.c_str());
	else
		xe::writeTestLog(batchResult, std::cout);
}

static void printHelp (const char* binName)
{
	printf("%s: [filename] [[filename 2] ...]\n", binName);
	printf("  --dst=[filename]    Write final log to file, otherwise written to stdout.\n");
	printf("  --info=[first|last] Select which session info to use (default: first).\n");
}

static bool parseCommandLine (CommandLine& cmdLine, int argc, const char* const* argv)
{
	for (int argNdx = 1; argNdx < argc; argNdx++)
	{
		const char* arg = argv[argNdx];

		if (!deStringBeginsWith(arg, "--"))
			cmdLine.srcFilenames.push_back(arg);
		else if (deStringBeginsWith(arg, "--dst="))
		{
			if (!cmdLine.dstFilename.empty())
				return false;
			cmdLine.dstFilename = arg+6;
		}
		else if (deStringEqual(arg, "--info=first"))
			cmdLine.flags &= ~FLAG_USE_LAST_INFO;
		else if (deStringEqual(arg, "--info=last"))
			cmdLine.flags |= FLAG_USE_LAST_INFO;
		else
			return false;
	}

	if (cmdLine.srcFilenames.empty())
		return false;

	return true;
}

int main (int argc, const char* const* argv)
{
	try
	{
		CommandLine cmdLine;

		if (!parseCommandLine(cmdLine, argc, argv))
		{
			printHelp(argv[0]);
			return -1;
		}

		mergeTestLogs(cmdLine);
	}
	catch (const std::exception& e)
	{
		printf("FATAL ERROR: %s\n", e.what());
		return -1;
	}

	return 0;
}