Home | History | Annotate | Download | only in executor 
      1 #ifndef _XEBATCHRESULT_HPP
      2 #define _XEBATCHRESULT_HPP
      3 /*-------------------------------------------------------------------------
      4  * drawElements Quality Program Test Executor
      5  * ------------------------------------------
      6  *
      7  * Copyright 2014 The Android Open Source Project
      8  *
      9  * Licensed under the Apache License, Version 2.0 (the "License");
     10  * you may not use this file except in compliance with the License.
     11  * You may obtain a copy of the License at
     12  *
     13  *      http://www.apache.org/licenses/LICENSE-2.0
     14  *
     15  * Unless required by applicable law or agreed to in writing, software
     16  * distributed under the License is distributed on an "AS IS" BASIS,
     17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     18  * See the License for the specific language governing permissions and
     19  * limitations under the License.
     20  *
     21  *//*!
     22  * \file
     23  * \brief Test batch result.
     24  *//*--------------------------------------------------------------------*/
     25 
     26 #include "xeDefs.hpp"
     27 #include "xeTestCase.hpp"
     28 #include "xeTestCaseResult.hpp"
     29 #include "deSharedPtr.hpp"
     30 
     31 #include <string>
     32 #include <vector>
     33 #include <map>
     34 
     35 namespace xe
     36 {
     37 
     38 class SessionInfo
     39 {
     40 public:
     41 	// Produced by test binary.
     42 	std::string			releaseName;
     43 	std::string			releaseId;
     44 	std::string			targetName;
     45 
     46 	// Produced by Candy.
     47 	std::string			candyTargetName;
     48 	std::string			configName;
     49 	std::string			resultName;
     50 	std::string			timestamp;
     51 };
     52 
     53 class InfoLog
     54 {
     55 public:
     56 							InfoLog			(void);
     57 
     58 	size_t					getSize			(void) const { return m_data.size();							}
     59 	const deUint8*			getBytes		(void) const { return !m_data.empty() ? &m_data[0] : DE_NULL;	}
     60 
     61 	void					append			(const deUint8* bytes, size_t numBytes);
     62 
     63 private:
     64 							InfoLog			(const InfoLog& other);
     65 	InfoLog&				operator=		(const InfoLog& other);
     66 
     67 	std::vector<deUint8>	m_data;
     68 };
     69 
     70 class TestCaseResultData
     71 {
     72 public:
     73 								TestCaseResultData				(const char* casePath);
     74 								~TestCaseResultData				(void);
     75 
     76 	const char*					getTestCasePath					(void) const	{ return m_casePath.c_str();		}
     77 
     78 	void						setTestResult					(TestStatusCode code, const char* details);
     79 
     80 	TestStatusCode				getStatusCode					(void) const	{ return m_statusCode;				}
     81 	const char*					getStatusDetails				(void) const	{ return m_statusDetails.c_str();	}
     82 
     83 	int							getDataSize						(void) const	{ return (int)m_data.size();		}
     84 	void						setDataSize						(int size)		{ m_data.resize(size);				}
     85 
     86 	const deUint8*				getData							(void) const	{ return !m_data.empty() ? &m_data[0] : DE_NULL;	}
     87 	deUint8*					getData							(void)			{ return !m_data.empty() ? &m_data[0] : DE_NULL;	}
     88 
     89 	void						clear							(void);
     90 
     91 private:
     92 	// \note statusCode and statusDetails are either set by BatchExecutor or later parsed from data.
     93 	std::string					m_casePath;
     94 	TestStatusCode				m_statusCode;
     95 	std::string					m_statusDetails;
     96 	std::vector<deUint8>		m_data;
     97 };
     98 
     99 typedef de::SharedPtr<TestCaseResultData>			TestCaseResultPtr;
    100 typedef de::SharedPtr<const TestCaseResultData>		ConstTestCaseResultPtr;
    101 
    102 class BatchResult
    103 {
    104 public:
    105 										BatchResult				(void);
    106 										~BatchResult			(void);
    107 
    108 	const SessionInfo&					getSessionInfo			(void) const	{ return m_sessionInfo;	}
    109 	SessionInfo&						getSessionInfo			(void)			{ return m_sessionInfo;	}
    110 
    111 	int									getNumTestCaseResults	(void) const	{ return (int)m_testCaseResults.size();							}
    112 	ConstTestCaseResultPtr				getTestCaseResult		(int ndx) const	{ return ConstTestCaseResultPtr(m_testCaseResults[ndx]);		}
    113 	TestCaseResultPtr					getTestCaseResult		(int ndx)		{ return m_testCaseResults[ndx];								}
    114 
    115 	bool								hasTestCaseResult		(const char* casePath) const;
    116 	ConstTestCaseResultPtr				getTestCaseResult		(const char* casePath) const;
    117 	TestCaseResultPtr					getTestCaseResult		(const char* casePath);
    118 
    119 	TestCaseResultPtr					createTestCaseResult	(const char* casePath);
    120 
    121 private:
    122 										BatchResult				(const BatchResult& other);
    123 	BatchResult&						operator=				(const BatchResult& other);
    124 
    125 	SessionInfo							m_sessionInfo;
    126 	std::vector<TestCaseResultPtr>		m_testCaseResults;
    127 	std::map<std::string, int>			m_resultMap;
    128 };
    129 
    130 } // xe
    131 
    132 #endif // _XEBATCHRESULT_HPP
    133