executor/xeCallQueue.cpp \
executor/xeCommLink.cpp \
executor/xeContainerFormatParser.cpp \
- executor/xeDefs.cpp \
executor/xeLocalTcpIpLink.cpp \
executor/xeTcpIpLink.cpp \
executor/xeTestCase.cpp \
executor/xeTestLogParser.cpp \
executor/xeTestLogWriter.cpp \
executor/xeTestResultParser.cpp \
- executor/xeXMLParser.cpp \
executor/xeXMLWriter.cpp \
external/vulkancts/framework/vulkan/vkAllocationCallbackUtil.cpp \
external/vulkancts/framework/vulkan/vkApiVersion.cpp \
framework/common/tcuTexture.cpp \
framework/common/tcuTextureUtil.cpp \
framework/common/tcuThreadUtil.cpp \
+ framework/common/tcuWaiverUtil.cpp \
framework/delibs/debase/deDefs.c \
framework/delibs/debase/deFloat16.c \
framework/delibs/debase/deFloat16Test.c \
framework/randomshaders
framework/egl
framework/egl/wrapper
+ framework/xexml
external/vulkancts/framework/vulkan
)
xeCommLink.hpp
xeContainerFormatParser.cpp
xeContainerFormatParser.hpp
- xeDefs.cpp
- xeDefs.hpp
xeLocalTcpIpLink.cpp
xeLocalTcpIpLink.hpp
xeTcpIpLink.cpp
xeTestLogWriter.hpp
xeTestResultParser.cpp
xeTestResultParser.hpp
- xeXMLParser.cpp
- xeXMLParser.hpp
xeXMLWriter.cpp
xeXMLWriter.hpp
)
set(XECORE_LIBS
+ xexml
xscore
decpp
deutil
target_link_libraries(xecore ${XECORE_LIBS})
include_directories(.)
+include_directories(../framework/xexml)
if (DE_OS_IS_WIN32 OR DE_OS_IS_UNIX OR DE_OS_IS_OSX OR DE_OS_IS_ANDROID)
add_executable(executor tools/xeCommandLineExecutor.cpp)
+++ /dev/null
-/*-------------------------------------------------------------------------
- * 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 Executor base definitions.
- *//*--------------------------------------------------------------------*/
-
-#include "xeDefs.hpp"
-
-#include <sstream>
-
-namespace xe
-{
-
-static std::string formatError (const char* message, const char* expr, const char* file, int line)
-{
- std::ostringstream msg;
- msg << (message ? message : "Runtime check failed") << ": ";
- if (expr)
- msg << '\'' << expr << '\'';
- msg << " at " << file << ":" << line;
- return msg.str();
-}
-
-Error::Error (const char* message, const char* expr, const char* file, int line)
- : std::runtime_error(formatError(message, expr, file, line))
-{
-}
-
-} // xe
+++ /dev/null
-#ifndef _XEDEFS_HPP
-#define _XEDEFS_HPP
-/*-------------------------------------------------------------------------
- * 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 Executor base definitions.
- *//*--------------------------------------------------------------------*/
-
-#include "deDefs.hpp"
-
-#include <string>
-#include <stdexcept>
-
-namespace xe
-{
-
-class Error : public std::runtime_error
-{
-public:
- Error (const std::string& message) : std::runtime_error(message) {}
- Error (const char* message, const char* expr, const char* file, int line);
-};
-
-class ParseError : public Error
-{
-public:
- ParseError (const std::string& message) : Error(message) {}
-};
-
-} // xe
-
-#define XE_FAIL(MSG) throw xe::Error(MSG, "", __FILE__, __LINE__)
-#define XE_CHECK(X) do { if ((!deGetFalse() && (X)) ? DE_FALSE : DE_TRUE) throw xe::Error(NULL, #X, __FILE__, __LINE__); } while(deGetFalse())
-#define XE_CHECK_MSG(X, MSG) do { if ((!deGetFalse() && (X)) ? DE_FALSE : DE_TRUE) throw xe::Error(MSG, #X, __FILE__, __LINE__); } while(deGetFalse())
-
-#endif // _XEDEFS_HPP
+++ /dev/null
-/*-------------------------------------------------------------------------
- * 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 XML Parser.
- *//*--------------------------------------------------------------------*/
-
-#include "xeXMLParser.hpp"
-#include "deInt32.h"
-
-namespace xe
-{
-namespace xml
-{
-
-enum
-{
- TOKENIZER_INITIAL_BUFFER_SIZE = 1024
-};
-
-static inline bool isIdentifierStartChar (int ch)
-{
- return de::inRange<int>(ch, 'a', 'z') || de::inRange<int>(ch, 'A', 'Z');
-}
-
-static inline bool isIdentifierChar (int ch)
-{
- return isIdentifierStartChar(ch) || de::inRange<int>(ch, '0', '9') || (ch == '-') || (ch == '_');
-}
-
-static inline bool isWhitespaceChar (int ch)
-{
- return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
-}
-
-static int getNextBufferSize (int curSize, int minNewSize)
-{
- return de::max(curSize*2, 1<<deLog2Ceil32(minNewSize));
-}
-
-Tokenizer::Tokenizer (void)
- : m_curToken (TOKEN_INCOMPLETE)
- , m_curTokenLen (0)
- , m_state (STATE_DATA)
- , m_buf (TOKENIZER_INITIAL_BUFFER_SIZE)
-{
-}
-
-Tokenizer::~Tokenizer (void)
-{
-}
-
-void Tokenizer::clear (void)
-{
- m_curToken = TOKEN_INCOMPLETE;
- m_curTokenLen = 0;
- m_state = STATE_DATA;
- m_buf.clear();
-}
-
-void Tokenizer::error (const std::string& what)
-{
- throw ParseError(what);
-}
-
-void Tokenizer::feed (const deUint8* bytes, int numBytes)
-{
- // Grow buffer if necessary.
- if (m_buf.getNumFree() < numBytes)
- {
- m_buf.resize(getNextBufferSize(m_buf.getSize(), m_buf.getNumElements()+numBytes));
- }
-
- // Append to front.
- m_buf.pushFront(bytes, numBytes);
-
- // If we haven't parsed complete token, re-try after data feed.
- if (m_curToken == TOKEN_INCOMPLETE)
- advance();
-}
-
-int Tokenizer::getChar (int offset) const
-{
- DE_ASSERT(de::inRange(offset, 0, m_buf.getNumElements()));
-
- if (offset < m_buf.getNumElements())
- return m_buf.peekBack(offset);
- else
- return END_OF_BUFFER;
-}
-
-void Tokenizer::advance (void)
-{
- if (m_curToken != TOKEN_INCOMPLETE)
- {
- // Parser should not try to advance beyond end of string.
- DE_ASSERT(m_curToken != TOKEN_END_OF_STRING);
-
- // If current token is tag end, change state to data.
- if (m_curToken == TOKEN_TAG_END ||
- m_curToken == TOKEN_EMPTY_ELEMENT_END ||
- m_curToken == TOKEN_PROCESSING_INSTRUCTION_END ||
- m_curToken == TOKEN_COMMENT ||
- m_curToken == TOKEN_ENTITY)
- m_state = STATE_DATA;
-
- // Advance buffer by length of last token.
- m_buf.popBack(m_curTokenLen);
-
- // Reset state.
- m_curToken = TOKEN_INCOMPLETE;
- m_curTokenLen = 0;
-
- // If we hit end of string here, report it as end of string.
- if (getChar(0) == END_OF_STRING)
- {
- m_curToken = TOKEN_END_OF_STRING;
- m_curTokenLen = 1;
- return;
- }
- }
-
- int curChar = getChar(m_curTokenLen);
-
- for (;;)
- {
- if (m_state == STATE_DATA)
- {
- // Advance until we hit end of buffer or tag start and treat that as data token.
- if (curChar == END_OF_STRING || curChar == (int)END_OF_BUFFER || curChar == '<' || curChar == '&')
- {
- if (curChar == '<')
- m_state = STATE_TAG;
- else if (curChar == '&')
- m_state = STATE_ENTITY;
-
- if (m_curTokenLen > 0)
- {
- // Report data token.
- m_curToken = TOKEN_DATA;
- return;
- }
- else if (curChar == END_OF_STRING || curChar == (int)END_OF_BUFFER)
- {
- // Just return incomplete token, no data parsed.
- return;
- }
- else
- {
- DE_ASSERT(m_state == STATE_TAG || m_state == STATE_ENTITY);
- continue;
- }
- }
- }
- else
- {
- // Eat all whitespace if present.
- if (m_curTokenLen == 0)
- {
- while (isWhitespaceChar(curChar))
- {
- m_buf.popBack();
- curChar = getChar(0);
- }
- }
-
- // Handle end of string / buffer.
- if (curChar == END_OF_STRING)
- error("Unexpected end of string");
- else if (curChar == (int)END_OF_BUFFER)
- {
- DE_ASSERT(m_curToken == TOKEN_INCOMPLETE);
- return;
- }
-
- if (m_curTokenLen == 0)
- {
- // Expect start of identifier, value or special tag token.
- if (curChar == '\'' || curChar == '"')
- m_state = STATE_VALUE;
- else if (isIdentifierStartChar(curChar))
- m_state = STATE_IDENTIFIER;
- else if (curChar == '<' || curChar == '?' || curChar == '/')
- m_state = STATE_TAG;
- else if (curChar == '&')
- DE_ASSERT(m_state == STATE_ENTITY);
- else if (curChar == '=')
- {
- m_curToken = TOKEN_EQUAL;
- m_curTokenLen = 1;
- return;
- }
- else if (curChar == '>')
- {
- m_curToken = TOKEN_TAG_END;
- m_curTokenLen = 1;
- return;
- }
- else
- error("Unexpected character");
- }
- else if (m_state == STATE_IDENTIFIER)
- {
- if (!isIdentifierChar(curChar))
- {
- m_curToken = TOKEN_IDENTIFIER;
- return;
- }
- }
- else if (m_state == STATE_VALUE)
- {
- // \todo [2012-06-07 pyry] Escapes.
- if (curChar == '\'' || curChar == '"')
- {
- // \todo [2012-10-17 pyry] Should we actually do the check against getChar(0)?
- if (curChar != getChar(0))
- error("Mismatched quote");
- m_curToken = TOKEN_STRING;
- m_curTokenLen += 1;
- return;
- }
- }
- else if (m_state == STATE_COMMENT)
- {
- DE_ASSERT(m_curTokenLen >= 2); // 2 characters have been parsed if we are in comment state.
-
- if (m_curTokenLen <= 3)
- {
- if (curChar != '-')
- error("Invalid comment start");
- }
- else
- {
- int prev2 = m_curTokenLen > 5 ? getChar(m_curTokenLen-2) : 0;
- int prev1 = m_curTokenLen > 4 ? getChar(m_curTokenLen-1) : 0;
-
- if (prev2 == '-' && prev1 == '-')
- {
- if (curChar != '>')
- error("Invalid comment end");
- m_curToken = TOKEN_COMMENT;
- m_curTokenLen += 1;
- return;
- }
- }
- }
- else if (m_state == STATE_ENTITY)
- {
- if (m_curTokenLen >= 1)
- {
- if (curChar == ';')
- {
- m_curToken = TOKEN_ENTITY;
- m_curTokenLen += 1;
- return;
- }
- else if (!de::inRange<int>(curChar, '0', '9') &&
- !de::inRange<int>(curChar, 'a', 'z') &&
- !de::inRange<int>(curChar, 'A', 'Z'))
- error("Invalid entity");
- }
- }
- else
- {
- // Special tokens are at most 2 characters.
- DE_ASSERT(m_state == STATE_TAG && m_curTokenLen == 1);
-
- int prevChar = getChar(m_curTokenLen-1);
-
- if (prevChar == '<')
- {
- // Tag start.
- if (curChar == '/')
- {
- m_curToken = TOKEN_END_TAG_START;
- m_curTokenLen = 2;
- return;
- }
- else if (curChar == '?')
- {
- m_curToken = TOKEN_PROCESSING_INSTRUCTION_START;
- m_curTokenLen = 2;
- return;
- }
- else if (curChar == '!')
- {
- m_state = STATE_COMMENT;
- }
- else
- {
- m_curToken = TOKEN_TAG_START;
- m_curTokenLen = 1;
- return;
- }
- }
- else if (prevChar == '?')
- {
- if (curChar != '>')
- error("Invalid processing instruction end");
- m_curToken = TOKEN_PROCESSING_INSTRUCTION_END;
- m_curTokenLen = 2;
- return;
- }
- else if (prevChar == '/')
- {
- if (curChar != '>')
- error("Invalid empty element end");
- m_curToken = TOKEN_EMPTY_ELEMENT_END;
- m_curTokenLen = 2;
- return;
- }
- else
- error("Could not parse special token");
- }
- }
-
- m_curTokenLen += 1;
- curChar = getChar(m_curTokenLen);
- }
-}
-
-void Tokenizer::getString (std::string& dst) const
-{
- DE_ASSERT(m_curToken == TOKEN_STRING);
- dst.resize(m_curTokenLen-2);
- for (int ndx = 0; ndx < m_curTokenLen-2; ndx++)
- dst[ndx] = m_buf.peekBack(ndx+1);
-}
-
-Parser::Parser (void)
- : m_element (ELEMENT_INCOMPLETE)
- , m_state (STATE_DATA)
-{
-}
-
-Parser::~Parser (void)
-{
-}
-
-void Parser::clear (void)
-{
- m_tokenizer.clear();
- m_elementName.clear();
- m_attributes.clear();
- m_attribName.clear();
- m_entityValue.clear();
-
- m_element = ELEMENT_INCOMPLETE;
- m_state = STATE_DATA;
-}
-
-void Parser::error (const std::string& what)
-{
- throw ParseError(what);
-}
-
-void Parser::feed (const deUint8* bytes, int numBytes)
-{
- m_tokenizer.feed(bytes, numBytes);
-
- if (m_element == ELEMENT_INCOMPLETE)
- advance();
-}
-
-void Parser::advance (void)
-{
- if (m_element == ELEMENT_START)
- m_attributes.clear();
-
- // \note No token is advanced when element end is reported.
- if (m_state == STATE_YIELD_EMPTY_ELEMENT_END)
- {
- DE_ASSERT(m_element == ELEMENT_START);
- m_element = ELEMENT_END;
- m_state = STATE_DATA;
- return;
- }
-
- if (m_element != ELEMENT_INCOMPLETE)
- {
- m_tokenizer.advance();
- m_element = ELEMENT_INCOMPLETE;
- }
-
- for (;;)
- {
- Token curToken = m_tokenizer.getToken();
-
- // Skip comments.
- while (curToken == TOKEN_COMMENT)
- {
- m_tokenizer.advance();
- curToken = m_tokenizer.getToken();
- }
-
- if (curToken == TOKEN_INCOMPLETE)
- {
- DE_ASSERT(m_element == ELEMENT_INCOMPLETE);
- return;
- }
-
- switch (m_state)
- {
- case STATE_ENTITY:
- m_state = STATE_DATA;
- // Fall-through
-
- case STATE_DATA:
- switch (curToken)
- {
- case TOKEN_DATA:
- m_element = ELEMENT_DATA;
- return;
-
- case TOKEN_END_OF_STRING:
- m_element = ELEMENT_END_OF_STRING;
- return;
-
- case TOKEN_TAG_START:
- m_state = STATE_START_TAG_OPEN;
- break;
-
- case TOKEN_END_TAG_START:
- m_state = STATE_END_TAG_OPEN;
- break;
-
- case TOKEN_PROCESSING_INSTRUCTION_START:
- m_state = STATE_IN_PROCESSING_INSTRUCTION;
- break;
-
- case TOKEN_ENTITY:
- m_state = STATE_ENTITY;
- m_element = ELEMENT_DATA;
- parseEntityValue();
- return;
-
- default:
- error("Unexpected token");
- }
- break;
-
- case STATE_IN_PROCESSING_INSTRUCTION:
- if (curToken == TOKEN_PROCESSING_INSTRUCTION_END)
- m_state = STATE_DATA;
- else
- if (curToken != TOKEN_IDENTIFIER && curToken != TOKEN_EQUAL && curToken != TOKEN_STRING)
- error("Unexpected token in processing instruction");
- break;
-
- case STATE_START_TAG_OPEN:
- if (curToken != TOKEN_IDENTIFIER)
- error("Expected identifier");
- m_tokenizer.getTokenStr(m_elementName);
- m_state = STATE_ATTRIBUTE_LIST;
- break;
-
- case STATE_END_TAG_OPEN:
- if (curToken != TOKEN_IDENTIFIER)
- error("Expected identifier");
- m_tokenizer.getTokenStr(m_elementName);
- m_state = STATE_EXPECTING_END_TAG_CLOSE;
- break;
-
- case STATE_EXPECTING_END_TAG_CLOSE:
- if (curToken != TOKEN_TAG_END)
- error("Expected tag end");
- m_state = STATE_DATA;
- m_element = ELEMENT_END;
- return;
-
- case STATE_ATTRIBUTE_LIST:
- if (curToken == TOKEN_IDENTIFIER)
- {
- m_tokenizer.getTokenStr(m_attribName);
- m_state = STATE_EXPECTING_ATTRIBUTE_EQ;
- }
- else if (curToken == TOKEN_EMPTY_ELEMENT_END)
- {
- m_state = STATE_YIELD_EMPTY_ELEMENT_END;
- m_element = ELEMENT_START;
- return;
- }
- else if (curToken == TOKEN_TAG_END)
- {
- m_state = STATE_DATA;
- m_element = ELEMENT_START;
- return;
- }
- else
- error("Unexpected token");
- break;
-
- case STATE_EXPECTING_ATTRIBUTE_EQ:
- if (curToken != TOKEN_EQUAL)
- error("Expected '='");
- m_state = STATE_EXPECTING_ATTRIBUTE_VALUE;
- break;
-
- case STATE_EXPECTING_ATTRIBUTE_VALUE:
- if (curToken != TOKEN_STRING)
- error("Expected value");
- if (hasAttribute(m_attribName.c_str()))
- error("Duplicate attribute");
-
- m_tokenizer.getString(m_attributes[m_attribName]);
- m_state = STATE_ATTRIBUTE_LIST;
- break;
-
- default:
- DE_ASSERT(false);
- }
-
- m_tokenizer.advance();
- }
-}
-
-static char getEntityValue (const std::string& entity)
-{
- static const struct
- {
- const char* name;
- char value;
- } s_entities[] =
- {
- { "<", '<' },
- { ">", '>' },
- { "&", '&' },
- { "'", '\''},
- { """, '"' },
- };
-
- for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_entities); ndx++)
- {
- if (entity == s_entities[ndx].name)
- return s_entities[ndx].value;
- }
-
- return 0;
-}
-
-void Parser::parseEntityValue (void)
-{
- DE_ASSERT(m_state == STATE_ENTITY && m_tokenizer.getToken() == TOKEN_ENTITY);
-
- std::string entity;
- m_tokenizer.getTokenStr(entity);
-
- const char value = getEntityValue(entity);
- if (value == 0)
- error("Invalid entity '" + entity + "'");
-
- m_entityValue.resize(1);
- m_entityValue[0] = value;
-}
-
-} // xml
-} // xe
+++ /dev/null
-#ifndef _XEXMLPARSER_HPP
-#define _XEXMLPARSER_HPP
-/*-------------------------------------------------------------------------
- * 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 XML Parser.
- *
- * \todo [2012-06-07 pyry] Not supported / handled properly:
- * - xml namespaces (<ns:Element>)
- * - backslash escapes in strings
- * - " -style escapes
- * - utf-8
- *//*--------------------------------------------------------------------*/
-
-#include "xeDefs.hpp"
-#include "deRingBuffer.hpp"
-
-#include <string>
-#include <map>
-
-namespace xe
-{
-namespace xml
-{
-
-enum Token
-{
- TOKEN_INCOMPLETE = 0, //!< Not enough data to determine token.
- TOKEN_END_OF_STRING, //!< End of document string.
- TOKEN_DATA, //!< Block of data (anything outside tags).
- TOKEN_COMMENT, //!< <!-- comment -->
- TOKEN_IDENTIFIER, //!< Identifier (in tags).
- TOKEN_STRING, //!< String (in tags).
- TOKEN_TAG_START, //!< <
- TOKEN_TAG_END, //!< >
- TOKEN_END_TAG_START, //!< </
- TOKEN_EMPTY_ELEMENT_END, //!< />
- TOKEN_PROCESSING_INSTRUCTION_START, //!< <?
- TOKEN_PROCESSING_INSTRUCTION_END, //!< ?>
- TOKEN_EQUAL, //!< =
- TOKEN_ENTITY, //!< Entity reference, such as &
-
- TOKEN_LAST
-};
-
-enum Element
-{
- ELEMENT_INCOMPLETE = 0, //!< Incomplete element.
- ELEMENT_START, //!< Element start.
- ELEMENT_END, //!< Element end.
- ELEMENT_DATA, //!< Data element.
- ELEMENT_END_OF_STRING, //!< End of document string.
-
- ELEMENT_LAST
-};
-
-const char* getTokenName (Token token);
-
-// \todo [2012-10-17 pyry] Add line number etc.
-class ParseError : public xe::ParseError
-{
-public:
- ParseError (const std::string& message) : xe::ParseError(message) {}
-};
-
-class Tokenizer
-{
-public:
- Tokenizer (void);
- ~Tokenizer (void);
-
- void clear (void); //!< Resets tokenizer to initial state.
-
- void feed (const deUint8* bytes, int numBytes);
- void advance (void);
-
- Token getToken (void) const { return m_curToken; }
- int getTokenLen (void) const { return m_curTokenLen; }
- deUint8 getTokenByte (int offset) const { DE_ASSERT(m_curToken != TOKEN_INCOMPLETE && m_curToken != TOKEN_END_OF_STRING); return m_buf.peekBack(offset); }
- void getTokenStr (std::string& dst) const;
- void appendTokenStr (std::string& dst) const;
-
- void getString (std::string& dst) const;
-
-private:
- Tokenizer (const Tokenizer& other);
- Tokenizer& operator= (const Tokenizer& other);
-
- int getChar (int offset) const;
-
- void error (const std::string& what);
-
- enum State
- {
- STATE_DATA = 0,
- STATE_TAG,
- STATE_IDENTIFIER,
- STATE_VALUE,
- STATE_COMMENT,
- STATE_ENTITY,
-
- STATE_LAST
- };
-
- enum
- {
- END_OF_STRING = 0, //!< End of string (0).
- END_OF_BUFFER = 0xffffffff //!< End of current data buffer.
- };
-
- Token m_curToken; //!< Current token.
- int m_curTokenLen; //!< Length of current token.
-
- State m_state; //!< Tokenization state.
-
- de::RingBuffer<deUint8> m_buf;
-};
-
-class Parser
-{
-public:
- typedef std::map<std::string, std::string> AttributeMap;
- typedef AttributeMap::const_iterator AttributeIter;
-
- Parser (void);
- ~Parser (void);
-
- void clear (void); //!< Resets parser to initial state.
-
- void feed (const deUint8* bytes, int numBytes);
- void advance (void);
-
- Element getElement (void) const { return m_element; }
-
- // For ELEMENT_START / ELEMENT_END.
- const char* getElementName (void) const { return m_elementName.c_str(); }
-
- // For ELEMENT_START.
- bool hasAttribute (const char* name) const { return m_attributes.find(name) != m_attributes.end(); }
- const char* getAttribute (const char* name) const { return m_attributes.find(name)->second.c_str(); }
- const AttributeMap& attributes (void) const { return m_attributes; }
-
- // For ELEMENT_DATA.
- int getDataSize (void) const;
- deUint8 getDataByte (int offset) const;
- void getDataStr (std::string& dst) const;
- void appendDataStr (std::string& dst) const;
-
-private:
- Parser (const Parser& other);
- Parser& operator= (const Parser& other);
-
- void parseEntityValue (void);
-
- void error (const std::string& what);
-
- enum State
- {
- STATE_DATA = 0, //!< Initial state - assuming data or tag open.
- STATE_ENTITY, //!< Parsed entity is stored - overrides data.
- STATE_IN_PROCESSING_INSTRUCTION, //!< In processing instruction.
- STATE_START_TAG_OPEN, //!< Start tag open.
- STATE_END_TAG_OPEN, //!< End tag open.
- STATE_EXPECTING_END_TAG_CLOSE, //!< Expecting end tag close.
- STATE_ATTRIBUTE_LIST, //!< Expecting attribute list.
- STATE_EXPECTING_ATTRIBUTE_EQ, //!< Got attribute name, expecting =.
- STATE_EXPECTING_ATTRIBUTE_VALUE, //!< Expecting attribute value.
- STATE_YIELD_EMPTY_ELEMENT_END, //!< Empty element: start has been reported but not end.
-
- STATE_LAST
- };
-
- Tokenizer m_tokenizer;
-
- Element m_element;
- std::string m_elementName;
- AttributeMap m_attributes;
-
- State m_state;
- std::string m_attribName;
- std::string m_entityValue; //!< Data override, such as entity value.
-};
-
-// Inline implementations
-
-inline void Tokenizer::getTokenStr (std::string& dst) const
-{
- DE_ASSERT(m_curToken != TOKEN_INCOMPLETE && m_curToken != TOKEN_END_OF_STRING);
- dst.resize(m_curTokenLen);
- for (int ndx = 0; ndx < m_curTokenLen; ndx++)
- dst[ndx] = m_buf.peekBack(ndx);
-}
-
-inline void Tokenizer::appendTokenStr (std::string& dst) const
-{
- DE_ASSERT(m_curToken != TOKEN_INCOMPLETE && m_curToken != TOKEN_END_OF_STRING);
-
- size_t oldLen = dst.size();
- dst.resize(oldLen+m_curTokenLen);
-
- for (int ndx = 0; ndx < m_curTokenLen; ndx++)
- dst[oldLen+ndx] = m_buf.peekBack(ndx);
-}
-
-inline int Parser::getDataSize (void) const
-{
- if (m_state != STATE_ENTITY)
- return m_tokenizer.getTokenLen();
- else
- return (int)m_entityValue.size();
-}
-
-inline deUint8 Parser::getDataByte (int offset) const
-{
- if (m_state != STATE_ENTITY)
- return m_tokenizer.getTokenByte(offset);
- else
- return (deUint8)m_entityValue[offset];
-}
-
-inline void Parser::getDataStr (std::string& dst) const
-{
- if (m_state != STATE_ENTITY)
- return m_tokenizer.getTokenStr(dst);
- else
- dst = m_entityValue;
-}
-
-inline void Parser::appendDataStr (std::string& dst) const
-{
- if (m_state != STATE_ENTITY)
- return m_tokenizer.appendTokenStr(dst);
- else
- dst += m_entityValue;
-}
-
-} // xml
-} // xe
-
-#endif // _XEXMLPARSER_HPP
KHR-GL42.texture_view.gettexparameter
KHR-GL42.texture_view.errors
KHR-GL42.texture_view.view_sampling
+KHR-GL42.texture_view.view_classes
KHR-GL42.texture_view.coherency
KHR-GL42.texture_view.base_and_max_levels
KHR-GL42.texture_view.reference_counting
KHR-GL43.texture_view.gettexparameter
KHR-GL43.texture_view.errors
KHR-GL43.texture_view.view_sampling
+KHR-GL43.texture_view.view_classes
KHR-GL43.texture_view.coherency
KHR-GL43.texture_view.base_and_max_levels
KHR-GL43.texture_view.reference_counting
KHR-GL44.texture_view.gettexparameter
KHR-GL44.texture_view.errors
KHR-GL44.texture_view.view_sampling
+KHR-GL44.texture_view.view_classes
KHR-GL44.texture_view.coherency
KHR-GL44.texture_view.base_and_max_levels
KHR-GL44.texture_view.reference_counting
KHR-GL45.texture_view.gettexparameter
KHR-GL45.texture_view.errors
KHR-GL45.texture_view.view_sampling
+KHR-GL45.texture_view.view_classes
KHR-GL45.texture_view.coherency
KHR-GL45.texture_view.base_and_max_levels
KHR-GL45.texture_view.reference_counting
KHR-GL46.texture_view.gettexparameter
KHR-GL46.texture_view.errors
KHR-GL46.texture_view.view_sampling
+KHR-GL46.texture_view.view_classes
KHR-GL46.texture_view.coherency
KHR-GL46.texture_view.base_and_max_levels
KHR-GL46.texture_view.reference_counting
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<waiver_list>
+
+ <!--/* Copyright (C) 2020 The Khronos Group Inc
+ *
+ * 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.
+*/-->
+ <!--/*
+ Each <waiver> entry must contain vendor and url string attributes.
+ Url should be a full path to gitlab issue(s).
+ Waiver tag should contain one <description> child that describes issue.
+ Waiver tag should containing one <renderer_list> child.
+ Renderer list should have one or more <r> elements containing renderer names for which this waiver was created.
+ String in <r> tags can use wildcard *.
+ Waiver tag should contain one or more <t> elements containing test paths that should be waived.
+ String in <t> tags can use wildcard *.
+
+ <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+ <xs:element name="waiver_list">
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="waiver" maxOccurs="unbounded">
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="description" type="xs:string"/>
+ <xs:element name="renderer_list">
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="r" type="xs:string" minOccurs="1" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="t" type="xs:string" minOccurs="1" maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="vendor" type="xs:string" use="required"/>
+ <xs:attribute name="url" type="xs:string" use="required"/>
+ </xs:complexType>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ </xs:schema>
+*/-->
+
+ <waiver vendor="ATI Technologies Inc." url="https://gitlab.khronos.org/Tracker/vk-gl-cts/issues/1141 , https://gitlab.khronos.org/Tracker/vk-gl-cts/issues/1190">
+ <description></description>
+ <!--TODO: plase let me know for which renderers this waiver should be defined -->
+ <renderer_list>
+ <r>???</r>
+ </renderer_list>
+ <t>KHR-GL42.texture_view.view_classes</t>
+ <t>KHR-GL43.texture_view.view_classes</t>
+ <t>KHR-GL44.texture_view.view_classes</t>
+ <t>KHR-GL45.texture_view.view_classes</t>
+ <t>KHR-GL46.texture_view.view_classes</t>
+ </waiver>
+
+</waiver_list>
\ No newline at end of file
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"
+#include "tcuWaiverUtil.hpp"
#include "subgroups/glcSubgroupsTests.hpp"
class TestCaseWrapper : public tcu::TestCaseExecutor
{
public:
- TestCaseWrapper(SingleConfigTestPackage& package);
+ TestCaseWrapper(SingleConfigTestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism);
~TestCaseWrapper(void);
void init(tcu::TestCase* testCase, const std::string& path);
private:
SingleConfigTestPackage& m_testPackage;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
-TestCaseWrapper::TestCaseWrapper(SingleConfigTestPackage& package) : m_testPackage(package)
+TestCaseWrapper::TestCaseWrapper(SingleConfigTestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism)
+ : m_testPackage(package)
+ , m_waiverMechanism(waiverMechanism)
{
}
{
}
-void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string&)
+void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string& path)
{
+ if (m_waiverMechanism->isOnWaiverList(path))
+ throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
+
testCase->init();
}
tcu::TestCaseExecutor* SingleConfigTestPackage::createExecutor(void) const
{
- return new TestCaseWrapper(const_cast<SingleConfigTestPackage&>(*this));
+ return new TestCaseWrapper(const_cast<SingleConfigTestPackage&>(*this), m_waiverMechanism);
}
} // glcts
*/ /*-------------------------------------------------------------------*/
#include "glcTestPackage.hpp"
+#include "gluContextInfo.hpp"
+#include "tcuTestLog.hpp"
+#include "tcuCommandLine.hpp"
+#include "tcuWaiverUtil.hpp"
+#include "glwEnums.hpp"
namespace deqp
{
PackageContext::PackageContext(tcu::TestContext& testCtx, glu::ContextType renderContextType)
- : m_context(testCtx, renderContextType), m_caseWrapper(m_context)
+ : m_context (testCtx, renderContextType)
+ , m_caseWrapper (m_context)
{
}
TestPackage::TestPackage(tcu::TestContext& testCtx, const char* name, const char* description,
glu::ContextType renderContextType, const char* resourcesPath)
- : tcu::TestPackage(testCtx, name, description)
- , m_renderContextType(renderContextType)
- , m_packageCtx(DE_NULL)
- , m_archive(testCtx.getRootArchive(), resourcesPath)
+ : tcu::TestPackage (testCtx, name, description)
+ , m_waiverMechanism (new tcu::WaiverUtil)
+ , m_renderContextType (renderContextType)
+ , m_packageCtx (DE_NULL)
+ , m_archive (testCtx.getRootArchive(), resourcesPath)
{
}
{
// Create context
m_packageCtx = new PackageContext(m_testCtx, m_renderContextType);
+
+ // Setup waiver mechanism
+ if (m_testCtx.getCommandLine().getRunMode() == tcu::RUNMODE_EXECUTE)
+ {
+ Context& context = m_packageCtx->getContext();
+ const glu::ContextInfo& contextInfo = context.getContextInfo();
+ m_waiverMechanism->setup(context.getTestContext().getCommandLine().getWaiverFileName(), m_name,
+ contextInfo.getString(GL_VENDOR), contextInfo.getString(GL_RENDERER));
+ }
}
catch (...)
{
#include "tcuDefs.hpp"
#include "tcuResource.hpp"
#include "tcuTestPackage.hpp"
+#include "deSharedPtr.hpp"
+
+namespace tcu
+{
+ class WaiverUtil;
+};
namespace deqp
{
return m_packageCtx->getContext();
}
+protected:
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
+
private:
TestPackage(const TestPackage& other);
TestPackage& operator=(const TestPackage& other);
- glu::ContextType m_renderContextType;
-
- PackageContext* m_packageCtx;
- tcu::ResourcePrefix m_archive;
+ glu::ContextType m_renderContextType;
+ PackageContext* m_packageCtx;
+ tcu::ResourcePrefix m_archive;
};
} // deqp
#include "glcNearestEdgeTests.hpp"
#include "gluStateReset.hpp"
#include "tcuTestLog.hpp"
+#include "tcuWaiverUtil.hpp"
#include "../glesext/texture_shadow_lod/esextcTextureShadowLodFunctionsTest.hpp"
class TestCaseWrapper : public tcu::TestCaseExecutor
{
public:
- TestCaseWrapper(GL30TestPackage& package);
+ TestCaseWrapper(GL30TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism);
~TestCaseWrapper(void);
void init(tcu::TestCase* testCase, const std::string& path);
tcu::TestNode::IterateResult iterate(tcu::TestCase* testCase);
private:
- GL30TestPackage& m_testPackage;
+ GL30TestPackage& m_testPackage;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
-TestCaseWrapper::TestCaseWrapper(GL30TestPackage& package) : m_testPackage(package)
+TestCaseWrapper::TestCaseWrapper(GL30TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism)
+ : m_testPackage (package)
+ , m_waiverMechanism (waiverMechanism)
{
}
{
}
-void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string&)
+void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string& path)
{
+ if (m_waiverMechanism->isOnWaiverList(path))
+ throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
+
testCase->init();
}
tcu::TestCaseExecutor* GL30TestPackage::createExecutor(void) const
{
- return new TestCaseWrapper(const_cast<GL30TestPackage&>(*this));
+ return new TestCaseWrapper(const_cast<GL30TestPackage&>(*this), m_waiverMechanism);
}
// GL31TestPackage
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"
+#include "tcuWaiverUtil.hpp"
namespace es2cts
{
class TestCaseWrapper : public tcu::TestCaseExecutor
{
public:
- TestCaseWrapper(TestPackage& package);
+ TestCaseWrapper(TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism);
~TestCaseWrapper(void);
void init(tcu::TestCase* testCase, const std::string& path);
private:
es2cts::TestPackage& m_testPackage;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
-TestCaseWrapper::TestCaseWrapper(TestPackage& package) : m_testPackage(package)
+TestCaseWrapper::TestCaseWrapper(TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism)
+ : m_testPackage(package)
+ , m_waiverMechanism(waiverMechanism)
{
}
{
}
-void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string&)
+void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string& path)
{
+ if (m_waiverMechanism->isOnWaiverList(path))
+ throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
+
glu::resetState(m_testPackage.getContext().getRenderContext(), m_testPackage.getContext().getContextInfo());
testCase->init();
tcu::TestCaseExecutor* TestPackage::createExecutor(void) const
{
- return new TestCaseWrapper(const_cast<TestPackage&>(*this));
+ return new TestCaseWrapper(const_cast<TestPackage&>(*this), m_waiverMechanism);
}
} // es2cts
#ifndef _GLCTESTPACKAGE_HPP
#include "glcTestPackage.hpp"
#endif
+#ifndef _DESHAREDPTR_HPP
+#include "deSharedPtr.hpp"
+#endif
+
+namespace tcu
+{
+ class WaiverUtil;
+};
namespace es2cts
{
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"
+#include "tcuWaiverUtil.hpp"
namespace es3cts
{
class TestCaseWrapper : public tcu::TestCaseExecutor
{
public:
- TestCaseWrapper(ES30TestPackage& package);
+ TestCaseWrapper(ES30TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism);
~TestCaseWrapper(void);
void init(tcu::TestCase* testCase, const std::string& path);
private:
ES30TestPackage& m_testPackage;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
-TestCaseWrapper::TestCaseWrapper(ES30TestPackage& package) : m_testPackage(package)
+TestCaseWrapper::TestCaseWrapper(ES30TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism)
+ : m_testPackage(package), m_waiverMechanism(waiverMechanism)
{
}
{
}
-void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string&)
+void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string& path)
{
+ if (m_waiverMechanism->isOnWaiverList(path))
+ throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
+
glu::resetState(m_testPackage.getContext().getRenderContext(), m_testPackage.getContext().getContextInfo());
testCase->init();
tcu::TestCaseExecutor* ES30TestPackage::createExecutor(void) const
{
- return new TestCaseWrapper(const_cast<ES30TestPackage&>(*this));
+ return new TestCaseWrapper(const_cast<ES30TestPackage&>(*this), m_waiverMechanism);
}
} // es3cts
#include "glcTestPackage.hpp"
#include "tcuDefs.hpp"
+#include "deSharedPtr.hpp"
+
+namespace tcu
+{
+ class WaiverUtil;
+};
namespace es3cts
{
#include "glcNearestEdgeTests.hpp"
#include "gluStateReset.hpp"
+#include "gluContextInfo.hpp"
+#include "tcuCommandLine.hpp"
+#include "tcuWaiverUtil.hpp"
+#include "glwEnums.hpp"
#include "../glesext/draw_buffers_indexed/esextcDrawBuffersIndexedTests.hpp"
#include "../glesext/geometry_shader/esextcGeometryShaderTests.hpp"
class TestCaseWrapper : public tcu::TestCaseExecutor
{
public:
- TestCaseWrapper(ES31TestPackage& package);
+ TestCaseWrapper(ES31TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism);
~TestCaseWrapper(void);
void init(tcu::TestCase* testCase, const std::string& path);
private:
ES31TestPackage& m_testPackage;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
-TestCaseWrapper::TestCaseWrapper(ES31TestPackage& package) : m_testPackage(package)
+TestCaseWrapper::TestCaseWrapper(ES31TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism)
+ : m_testPackage(package), m_waiverMechanism(waiverMechanism)
{
}
{
}
-void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string&)
+void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string& path)
{
+ if (m_waiverMechanism->isOnWaiverList(path))
+ throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
+
glu::resetState(m_testPackage.getContext().getRenderContext(), m_testPackage.getContext().getContextInfo());
testCase->init();
tcu::TestCaseExecutor* ES31TestPackage::createExecutor(void) const
{
- return new TestCaseWrapper(const_cast<ES31TestPackage&>(*this));
+ return new TestCaseWrapper(const_cast<ES31TestPackage&>(*this), m_waiverMechanism);
}
} // es31cts
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"
+#include "tcuWaiverUtil.hpp"
#include "../glesext/draw_buffers_indexed/esextcDrawBuffersIndexedTests.hpp"
#include "../glesext/geometry_shader/esextcGeometryShaderTests.hpp"
class TestCaseWrapper : public tcu::TestCaseExecutor
{
public:
- TestCaseWrapper(ES32TestPackage& package);
+ TestCaseWrapper(ES32TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism);
~TestCaseWrapper(void);
void init(tcu::TestCase* testCase, const std::string& path);
tcu::TestNode::IterateResult iterate(tcu::TestCase* testCase);
private:
- ES32TestPackage& m_testPackage;
+ ES32TestPackage& m_testPackage;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
-TestCaseWrapper::TestCaseWrapper(ES32TestPackage& package) : m_testPackage(package)
+TestCaseWrapper::TestCaseWrapper(ES32TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism)
+ : m_testPackage (package)
+ , m_waiverMechanism (waiverMechanism)
{
}
{
}
-void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string&)
+void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string& path)
{
+ if (m_waiverMechanism->isOnWaiverList(path))
+ throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
+
testCase->init();
}
tcu::TestCaseExecutor* ES32TestPackage::createExecutor(void) const
{
- return new TestCaseWrapper(const_cast<ES32TestPackage&>(*this));
+ return new TestCaseWrapper(const_cast<ES32TestPackage&>(*this), m_waiverMechanism);
}
} // es32cts
#include "glcViewportArrayTests.hpp"
#include "gluStateReset.hpp"
#include "tcuTestLog.hpp"
+#include "tcuWaiverUtil.hpp"
namespace esextcts
{
class TestCaseWrapper : public tcu::TestCaseExecutor
{
public:
- TestCaseWrapper(ESEXTTestPackage& package);
+ TestCaseWrapper(ESEXTTestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism);
~TestCaseWrapper(void);
void init(tcu::TestCase* testCase, const std::string& path);
private:
ESEXTTestPackage& m_testPackage;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
-TestCaseWrapper::TestCaseWrapper(ESEXTTestPackage& package) : m_testPackage(package)
+TestCaseWrapper::TestCaseWrapper(ESEXTTestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism)
+ : m_testPackage(package), m_waiverMechanism(waiverMechanism)
{
}
{
}
-void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string&)
+void TestCaseWrapper::init(tcu::TestCase* testCase, const std::string& path)
{
+ if (m_waiverMechanism->isOnWaiverList(path))
+ throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
+
glu::resetState(m_testPackage.getContext().getRenderContext(), m_testPackage.getContext().getContextInfo());
testCase->init();
tcu::TestCaseExecutor* ESEXTTestPackage::createExecutor(void) const
{
- return new TestCaseWrapper(const_cast<ESEXTTestPackage&>(*this));
+ return new TestCaseWrapper(const_cast<ESEXTTestPackage&>(*this), m_waiverMechanism);
}
} // esextcts
#include "glcTestCase.hpp"
#include "glcTestPackage.hpp"
#include "tcuDefs.hpp"
+#include "deSharedPtr.hpp"
+
+namespace tcu
+{
+class WaiverUtil;
+};
namespace esextcts
{
GL_CTS_KHR_SINGLE_PROJECT = Project(name = "Khronos Mustpass GL Single Config", path = GL_CTS_KHR_MP_SINGLE_DATA_DIR, incpath = GL_CTS_MP_INC_DIR, devicepath = GL_CTS_KHR_MP_SINGLE_DEVICE_DIR, copyright = COPYRIGHT_DECLARATION)
GL_MODULES = OrderedDict([
- ('KHR-GL46', ['master', [include('gl46-master.txt'), exclude('gl46-test-issues.txt'), exclude('gl46-waivers.txt')]]),
- ('KHR-GL45', ['master', [include('gl45-master.txt'), exclude('gl45-test-issues.txt'), exclude('gl45-waivers.txt')]]),
- ('KHR-GL44', ['master', [include('gl44-master.txt'), exclude('gl44-test-issues.txt'), exclude('gl44-waivers.txt')]]),
- ('KHR-GL43', ['master', [include('gl43-master.txt'), exclude('gl43-test-issues.txt'), exclude('gl43-waivers.txt')]]),
- ('KHR-GL42', ['master', [include('gl42-master.txt'), exclude('gl42-test-issues.txt'), exclude('gl42-waivers.txt')]]),
- ('KHR-GL41', ['master', [include('gl41-master.txt'), exclude('gl41-test-issues.txt'), exclude('gl41-waivers.txt')]]),
- ('KHR-GL40', ['master', [include('gl40-master.txt'), exclude('gl40-test-issues.txt'), exclude('gl40-waivers.txt')]]),
+ ('KHR-GL46', ['master', [include('gl46-master.txt'), exclude('gl46-test-issues.txt')]]),
+ ('KHR-GL45', ['master', [include('gl45-master.txt'), exclude('gl45-test-issues.txt')]]),
+ ('KHR-GL44', ['master', [include('gl44-master.txt'), exclude('gl44-test-issues.txt')]]),
+ ('KHR-GL43', ['master', [include('gl43-master.txt'), exclude('gl43-test-issues.txt')]]),
+ ('KHR-GL42', ['master', [include('gl42-master.txt'), exclude('gl42-test-issues.txt')]]),
+ ('KHR-GL41', ['master', [include('gl41-master.txt'), exclude('gl41-test-issues.txt')]]),
+ ('KHR-GL40', ['master', [include('gl40-master.txt'), exclude('gl40-test-issues.txt')]]),
('KHR-GL33', ['master', [include('gl33-master.txt'), exclude('gl33-test-issues.txt')]]),
('KHR-GL32', ['master', [include('gl32-master.txt'), exclude('gl32-test-issues.txt')]]),
('KHR-GL31', ['master', [include('gl31-master.txt'), exclude('gl31-test-issues.txt')]]),
--deqp-fraction-mandatory-caselist-file=<vulkancts>external/vulkancts/mustpass/master/vk-fraction-mandatory-tests.txt
+To specify file containing waived tests that are omitted only by specified vendor and renderer/device
+the following command line option may be used:
+
+ --deqp-waiver-file=<path>
+
No other command line options are allowed.
### Win32
NotSupported
QualityWarning
CompatibilityWarning
+ Waiver
Submission package can be verified using `external/vulkancts/scripts/verify_submission.py`
script. The script takes two arguments: path to extracted submission package
#include "tcuTestCase.hpp"
#include "tcuTestLog.hpp"
#include "tcuCommandLine.hpp"
+#include "tcuWaiverUtil.hpp"
#include "vkPlatform.hpp"
#include "vkPrograms.hpp"
#include "vktImagelessFramebufferTests.hpp"
#include "vktFragmentShaderInterlockTests.hpp"
#include "vktShaderClockTests.hpp"
+#include "vktShaderClockTests.hpp"
#include <vector>
#include <sstream>
const UniquePtr<vk::DebugReportRecorder> m_debugReportRecorder;
const UniquePtr<vk::RenderDocUtil> m_renderDoc;
+ vk::VkPhysicalDeviceProperties m_deviceProperties;
+ tcu::WaiverUtil m_waiverMechanism;
TestInstance* m_instance; //!< Current test case instance
};
return MovePtr<vk::Library>(testCtx.getPlatform().getVulkanPlatform().createLibrary());
}
+static vk::VkPhysicalDeviceProperties getPhysicalDeviceProperties(vkt::Context& context)
+{
+ const vk::InstanceInterface& vki = context.getInstanceInterface();
+ const vk::VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
+
+ vk::VkPhysicalDeviceProperties properties;
+ vki.getPhysicalDeviceProperties(physicalDevice, &properties);
+ return properties;
+}
+
TestCaseExecutor::TestCaseExecutor (tcu::TestContext& testCtx)
: m_prebuiltBinRegistry (testCtx.getArchive(), "vulkan/prebuilt")
, m_library (createLibrary(testCtx))
, m_renderDoc (testCtx.getCommandLine().isRenderDocEnabled()
? MovePtr<vk::RenderDocUtil>(new vk::RenderDocUtil())
: MovePtr<vk::RenderDocUtil>(DE_NULL))
+ , m_deviceProperties (getPhysicalDeviceProperties(m_context))
, m_instance (DE_NULL)
{
+ m_waiverMechanism.setup(testCtx.getCommandLine().getWaiverFileName(), "dEQP-VK",
+ m_deviceProperties.vendorID, m_deviceProperties.deviceID);
}
TestCaseExecutor::~TestCaseExecutor (void)
if (!vktCase)
TCU_THROW(InternalError, "Test node not an instance of vkt::TestCase");
+ if (m_waiverMechanism.isOnWaiverList(casePath))
+ throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
+
vktCase->checkSupport(m_context);
vktCase->delayedInit();
<option name="deqp-package" value="dEQP-VK"/>
<option name="deqp-caselist-file" value="vk-default.txt"/>
</test>
- <test class="com.drawelements.deqp.runner.DeqpTestRunner">
- <option name="deqp-package" value="dEQP-VK"/>
- <option name="deqp-caselist-file" value="vk-default-no-waivers.txt"/>
- </test>
<test class="com.drawelements.deqp.runner.DeqpTestRunner">
<option name="deqp-package" value="dEQP-VK"/>
<option name="deqp-caselist-file" value="vk-fraction-mandatory-tests.txt"/>
+++ /dev/null
-#
-# VK-GL-CTS Issue #336
-#
-# This occurs on some versions of Imagination Technologies G6200, G6230, G6400, and G6430
-# Rogue Series 6 GPU's.
-#
-# The affected GPU's are unable to correctly filter CEM corners with F32 textures, this
-# includes the ability to gather texels for texel gather instructions.
-#
-# An application using gather on an F32 texture would obtain incorrect texel values around
-# the corners of the cubemap.
-#
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.clamp_to_edge_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.repeat_mirrored_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.clamp_to_edge_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.repeat_mirrored_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.clamp_to_edge_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.repeat_mirrored_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.clamp_to_edge_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.repeat_mirrored_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mag_linear
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mag_linear
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.level_1
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.sparse_level_1
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.level_2
-dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.sparse_level_2
-
-
-#
-# VK-GL-CTS Issue #757
-#
-# This occurs on some versions of Broadcom's Videocore GPUs. On affected devices depth clipping
-# is incorrectly disabled when the viewport minDepth is equal to maxDepth.
-#
-dEQP-VK.draw.inverted_depth_ranges.nodepthclamp_deltazero
-
-#
-# VK-GL-CTS Issue #1356
-#
-# This occurs on NVIDIA Kepler GPUs. The affected GPUs are unable to reliably synchronize memory
-# accesses at device scope.
-#
-dEQP-VK.memory_model.*core11*.device.*
-
dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.base_level.sparse_level_1
dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.base_level.level_2
dEQP-VK.glsl.texture_gather.basic.cube.rgba8i.base_level.sparse_level_2
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.clamp_to_edge_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.repeat_mirrored_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.clamp_to_edge_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.repeat_mirrored_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.clamp_to_edge_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.repeat_mirrored_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.clamp_to_edge_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.repeat_mirrored_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge
dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_less.clamp_to_edge_repeat
dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_less.sparse_clamp_to_edge_repeat
dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_pot.compare_less.repeat_mirrored_repeat
dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_greater.sparse_repeat_mirrored_repeat
dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_greater.mirrored_repeat_clamp_to_edge
dEQP-VK.glsl.texture_gather.basic.cube.depth32f.no_corners.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mag_linear
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mag_linear
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.level_1
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.sparse_level_1
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.level_2
+dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.sparse_level_2
dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_pot.clamp_to_edge_repeat
dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_pot.sparse_clamp_to_edge_repeat
dEQP-VK.glsl.texture_gather.offset.min_required_offset.2d.rgba8.size_pot.repeat_mirrored_repeat
dEQP-VK.draw.inverted_depth_ranges.depthclamp_deltasmall
dEQP-VK.draw.inverted_depth_ranges.depthclamp_deltaone
dEQP-VK.draw.inverted_depth_ranges.depthclamp_depth_range_unrestricted
+dEQP-VK.draw.inverted_depth_ranges.nodepthclamp_deltazero
dEQP-VK.draw.inverted_depth_ranges.nodepthclamp_deltasmall
dEQP-VK.draw.inverted_depth_ranges.nodepthclamp_deltaone
dEQP-VK.draw.inverted_depth_ranges.nodepthclamp_depth_range_unrestricted
dEQP-VK.device_group.sfr_tessellated_linefill
dEQP-VK.device_group.afr_tessellated
dEQP-VK.device_group.afr_tessellated_linefill
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.buffer.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.buffer.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.buffer.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.image.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.image.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.image.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.workgroup.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.buffer.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.buffer.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.buffer.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.image.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.image.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.image.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.buffer.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.buffer.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.buffer.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.image.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.image.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.image.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.workgroup.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.buffer.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.buffer.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.buffer.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.image.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.image.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.image.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.workgroup.guard_nonlocal.buffer.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.workgroup.guard_nonlocal.image.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.workgroup.guard_nonlocal.workgroup.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.workgroup.guard_local.buffer.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.workgroup.guard_local.image.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.buffer.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.buffer.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.buffer.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.image.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.image.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.image.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.workgroup.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.buffer.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.buffer.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.buffer.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.image.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.image.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.image.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.buffer.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.buffer.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.buffer.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.image.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.image.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.image.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.workgroup.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.buffer.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.buffer.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.buffer.frag
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.image.comp
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.image.vert
+dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.image.frag
dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.workgroup.payload_nonlocal.buffer.guard_nonlocal.buffer.comp
dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.workgroup.payload_nonlocal.buffer.guard_nonlocal.image.comp
dEQP-VK.memory_model.message_passing.core11.u32.coherent.fence_fence.atomicwrite.workgroup.payload_nonlocal.buffer.guard_nonlocal.workgroup.comp
dEQP-VK.memory_model.message_passing.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.physbuffer.guard_local.physbuffer.comp
dEQP-VK.memory_model.message_passing.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.physbuffer.guard_local.physbuffer.vert
dEQP-VK.memory_model.message_passing.ext.u64.noncoherent.atomic_atomic.atomicrmw.subgroup.payload_local.physbuffer.guard_local.physbuffer.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.buffer.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.buffer.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.buffer.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.image.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.image.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.image.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_nonlocal.workgroup.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.buffer.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.buffer.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.buffer.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.image.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.image.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.buffer.guard_local.image.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.buffer.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.buffer.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.buffer.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.image.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.image.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.image.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_nonlocal.workgroup.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.buffer.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.buffer.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.buffer.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.image.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.image.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.image.guard_local.image.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.workgroup.guard_nonlocal.buffer.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.workgroup.guard_nonlocal.image.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.workgroup.guard_nonlocal.workgroup.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.workgroup.guard_local.buffer.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_nonlocal.workgroup.guard_local.image.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.buffer.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.buffer.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.buffer.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.image.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.image.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.image.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_nonlocal.workgroup.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.buffer.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.buffer.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.buffer.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.image.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.image.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.buffer.guard_local.image.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.buffer.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.buffer.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.buffer.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.image.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.image.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.image.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_nonlocal.workgroup.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.buffer.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.buffer.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.buffer.frag
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.image.comp
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.image.vert
+dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.device.payload_local.image.guard_local.image.frag
dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.workgroup.payload_nonlocal.buffer.guard_nonlocal.buffer.comp
dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.workgroup.payload_nonlocal.buffer.guard_nonlocal.image.comp
dEQP-VK.memory_model.write_after_read.core11.u32.coherent.fence_fence.atomicwrite.workgroup.payload_nonlocal.buffer.guard_nonlocal.workgroup.comp
--- /dev/null
+<?xml version="1.0" encoding="utf-8"?>
+<waiver_list>
+
+ <!--/* Copyright (C) 2020 The Khronos Group Inc
+ *
+ * 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.
+*/-->
+ <!--/*
+ Each <waiver> entry must contain three attributes: vendorName, vendorId and url.
+ Url should be a full path to gitlab issue(s).
+ Waiver tag should have one <description> child that describes issue.
+ Waiver tag should have one <device_list> child.
+ Device list should have one or more <d> elements containing device ids for which this waiver was created.
+ Waiver tag should contain one or more <t> elements containing test paths that should be waived.
+ String in <t> can use wildcard *.
+
+ <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+ <xs:element name="waiver_list">
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="waiver" maxOccurs="unbounded">
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="description" type="xs:string"/>
+ <xs:element name="device_list">
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="d" type="xs:integer" minOccurs="1" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="t" type="xs:string" minOccurs="1" maxOccurs="unbounded"/>
+ </xs:sequence>
+ <xs:attribute name="vendorName" type="xs:string" use="required"/>
+ <xs:attribute name="vendorId" type="xs:string" use="required"/>
+ <xs:attribute name="url" type="xs:string" use="required"/>
+ </xs:complexType>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ </xs:schema>
+*/-->
+
+ <waiver vendorName="Imagination Technologies" vendorId="0x1010" url="https://gitlab.khronos.org/Tracker/vk-gl-cts/issues/336">
+ <description>GPU's are unable to correctly filter CEM corners with F32 textures, this includes the ability to gather texels for texel gather instructions.</description>
+ <device_list>
+ <!--TODO: plase let me know for which deviceIds this waiver should be defined -->
+ <d>6200</d>
+ </device_list>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.clamp_to_edge_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_clamp_to_edge_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.repeat_mirrored_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_repeat_mirrored_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.mirrored_repeat_clamp_to_edge</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_less.sparse_mirrored_repeat_clamp_to_edge</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.clamp_to_edge_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_clamp_to_edge_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.repeat_mirrored_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_repeat_mirrored_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.mirrored_repeat_clamp_to_edge</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_pot.compare_greater.sparse_mirrored_repeat_clamp_to_edge</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.clamp_to_edge_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_clamp_to_edge_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.repeat_mirrored_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_repeat_mirrored_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.mirrored_repeat_clamp_to_edge</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_less.sparse_mirrored_repeat_clamp_to_edge</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.clamp_to_edge_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_clamp_to_edge_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.repeat_mirrored_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_repeat_mirrored_repeat</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.mirrored_repeat_clamp_to_edge</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.size_npot.compare_greater.sparse_mirrored_repeat_clamp_to_edge</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mag_linear</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mag_linear</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_nearest_mipmap_nearest_mag_linear</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_nearest_mipmap_nearest_mag_linear</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_nearest_mipmap_linear_mag_linear</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_nearest_mipmap_linear_mag_linear</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mipmap_nearest_mag_linear</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mipmap_nearest_mag_linear</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.min_linear_mipmap_linear_mag_linear</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.filter_mode.sparse_min_linear_mipmap_linear_mag_linear</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.level_1</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.sparse_level_1</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.level_2</t>
+ <t>dEQP-VK.glsl.texture_gather.basic.cube.depth32f.base_level.sparse_level_2</t>
+ </waiver>
+
+ <waiver vendorName="Broadcom" vendorId="0x14E4" url="https://gitlab.khronos.org/Tracker/vk-gl-cts/issues/757">
+ <description>On affected devices depth clipping is incorrectly disabled when the viewport minDepth is equal to maxDepth.</description>
+ <device_list>
+ <d>0x8E002214</d>
+ <d>0x001E43CB</d>
+ <d>0xBE485FD3</d>
+ </device_list>
+ <t>dEQP-VK.draw.inverted_depth_ranges.nodepthclamp_deltazero</t>
+ </waiver>
+
+ <waiver vendorName="NVIDIA" vendorId="0x10DE" url="https://gitlab.khronos.org/Tracker/vk-gl-cts/issues/1356">
+ <description>The affected GPUs are unable to reliably synchronize memory accesses at device scope.</description>
+ <device_list>
+ <d>0x0CE0</d>
+ <d>0x0E0D</d>
+ <d>0x0E16</d>
+ <d>0x0FA0</d>
+ <d>0x0FA7</d>
+ <d>0x0FC0</d>
+ <d>0x0FC1</d>
+ <d>0x0FC2</d>
+ <d>0x0FC4</d>
+ <d>0x0FC5</d>
+ <d>0x0FC6</d>
+ <d>0x0FC7</d>
+ <d>0x0FC8</d>
+ <d>0x0FC9</d>
+ <d>0x0FCA</d>
+ <d>0x0FCB</d>
+ <d>0x0FCC</d>
+ <d>0x0FCD</d>
+ <d>0x0FCE</d>
+ <d>0x0FCF</d>
+ <d>0x0FD0</d>
+ <d>0x0FD1</d>
+ <d>0x0FD2</d>
+ <d>0x0FD3</d>
+ <d>0x0FD4</d>
+ <d>0x0FD5</d>
+ <d>0x0FD6</d>
+ <d>0x0FD7</d>
+ <d>0x0FD8</d>
+ <d>0x0FD9</d>
+ <d>0x0FDA</d>
+ <d>0x0FDB</d>
+ <d>0x0FDC</d>
+ <d>0x0FDD</d>
+ <d>0x0FDE</d>
+ <d>0x0FDF</d>
+ <d>0x0FE0</d>
+ <d>0x0FE1</d>
+ <d>0x0FE2</d>
+ <d>0x0FE3</d>
+ <d>0x0FE4</d>
+ <d>0x0FE5</d>
+ <d>0x0FE6</d>
+ <d>0x0FE7</d>
+ <d>0x0FE8</d>
+ <d>0x0FE9</d>
+ <d>0x0FEA</d>
+ <d>0x0FEC</d>
+ <d>0x0FED</d>
+ <d>0x0FEE</d>
+ <d>0x0FEF</d>
+ <d>0x0FF0</d>
+ <d>0x0FF1</d>
+ <d>0x0FF2</d>
+ <d>0x0FF3</d>
+ <d>0x0FF5</d>
+ <d>0x0FF6</d>
+ <d>0x0FF7</d>
+ <d>0x0FF8</d>
+ <d>0x0FF9</d>
+ <d>0x0FFA</d>
+ <d>0x0FFB</d>
+ <d>0x0FFC</d>
+ <d>0x0FFD</d>
+ <d>0x0FFE</d>
+ <d>0x0FFF</d>
+ <d>0x1001</d>
+ <d>0x1003</d>
+ <d>0x1004</d>
+ <d>0x1005</d>
+ <d>0x1007</d>
+ <d>0x1008</d>
+ <d>0x100A</d>
+ <d>0x100B</d>
+ <d>0x100C</d>
+ <d>0x101E</d>
+ <d>0x101F</d>
+ <d>0x1020</d>
+ <d>0x1021</d>
+ <d>0x1022</d>
+ <d>0x1023</d>
+ <d>0x1024</d>
+ <d>0x1026</d>
+ <d>0x1027</d>
+ <d>0x1028</d>
+ <d>0x1029</d>
+ <d>0x102A</d>
+ <d>0x102B</d>
+ <d>0x102C</d>
+ <d>0x102D</d>
+ <d>0x102E</d>
+ <d>0x102F</d>
+ <d>0x1030</d>
+ <d>0x103A</d>
+ <d>0x103B</d>
+ <d>0x103C</d>
+ <d>0x103F</d>
+ <d>0x1180</d>
+ <d>0x1182</d>
+ <d>0x1183</d>
+ <d>0x1184</d>
+ <d>0x1185</d>
+ <d>0x1187</d>
+ <d>0x1188</d>
+ <d>0x1189</d>
+ <d>0x118A</d>
+ <d>0x118B</d>
+ <d>0x118C</d>
+ <d>0x118D</d>
+ <d>0x118E</d>
+ <d>0x118F</d>
+ <d>0x1191</d>
+ <d>0x1192</d>
+ <d>0x1193</d>
+ <d>0x1194</d>
+ <d>0x1195</d>
+ <d>0x1198</d>
+ <d>0x1199</d>
+ <d>0x119A</d>
+ <d>0x119D</d>
+ <d>0x119E</d>
+ <d>0x119F</d>
+ <d>0x11A0</d>
+ <d>0x11A1</d>
+ <d>0x11A2</d>
+ <d>0x11A3</d>
+ <d>0x11A4</d>
+ <d>0x11A5</d>
+ <d>0x11A7</d>
+ <d>0x11AA</d>
+ <d>0x11AC</d>
+ <d>0x11AD</d>
+ <d>0x11AE</d>
+ <d>0x11AF</d>
+ <d>0x11B0</d>
+ <d>0x11B1</d>
+ <d>0x11B4</d>
+ <d>0x11B6</d>
+ <d>0x11B7</d>
+ <d>0x11B8</d>
+ <d>0x11BA</d>
+ <d>0x11BB</d>
+ <d>0x11BC</d>
+ <d>0x11BD</d>
+ <d>0x11BE</d>
+ <d>0x11BF</d>
+ <d>0x11C0</d>
+ <d>0x11C1</d>
+ <d>0x11C2</d>
+ <d>0x11C3</d>
+ <d>0x11C4</d>
+ <d>0x11C5</d>
+ <d>0x11C6</d>
+ <d>0x11C7</d>
+ <d>0x11C8</d>
+ <d>0x11CB</d>
+ <d>0x11D0</d>
+ <d>0x11D1</d>
+ <d>0x11D2</d>
+ <d>0x11D3</d>
+ <d>0x11E0</d>
+ <d>0x11E1</d>
+ <d>0x11E2</d>
+ <d>0x11E3</d>
+ <d>0x11F0</d>
+ <d>0x11F8</d>
+ <d>0x11FA</d>
+ <d>0x11FC</d>
+ <d>0x11FF</d>
+ <d>0x1280</d>
+ <d>0x1281</d>
+ <d>0x1282</d>
+ <d>0x1283</d>
+ <d>0x1284</d>
+ <d>0x1285</d>
+ <d>0x1286</d>
+ <d>0x1287</d>
+ <d>0x1288</d>
+ <d>0x1289</d>
+ <d>0x128A</d>
+ <d>0x128B</d>
+ <d>0x1290</d>
+ <d>0x1291</d>
+ <d>0x1292</d>
+ <d>0x1293</d>
+ <d>0x1294</d>
+ <d>0x1295</d>
+ <d>0x1296</d>
+ <d>0x1297</d>
+ <d>0x1298</d>
+ <d>0x1299</d>
+ <d>0x129A</d>
+ <d>0x129B</d>
+ <d>0x12A0</d>
+ <d>0x12AD</d>
+ <d>0x12AE</d>
+ <d>0x12AF</d>
+ <d>0x12B0</d>
+ <d>0x12B1</d>
+ <d>0x12B9</d>
+ <d>0x12BA</d>
+ </device_list>
+ <t>dEQP-VK.memory_model.*core11*.device.*</t>
+ </waiver>
+
+</waiver_list>
\ No newline at end of file
VULKAN_MASTER_PKG = Package(module = VULKAN_MODULE, configurations = [
# Master
Configuration(name = "default",
- filters = [include("master.txt"),
- exclude("test-issues.txt"),
- exclude("excluded-tests.txt"),
- exclude("android-tests.txt"),
- exclude("waivers.txt")]),
- Configuration(name = "default-no-waivers",
filters = [include("master.txt"),
exclude("test-issues.txt"),
exclude("excluded-tests.txt"),
# EGL utilities
add_subdirectory(egl)
+# XE xml util
+add_subdirectory(xexml)
+
if (IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/randomshaders)
add_subdirectory(randomshaders)
endif ()
tcuAstcUtil.hpp
tcuRasterizationVerifier.cpp
tcuRasterizationVerifier.hpp
+ tcuWaiverUtil.cpp
+ tcuWaiverUtil.hpp
)
set(TCUTIL_LIBS
decpp
qphelper
dethread
+ xexml
${PNG_LIBRARY}
)
print(" Failed: %d/%d (%.1f%%)\n", result.numFailed, result.numExecuted, (result.numExecuted > 0 ? (100.0f * (float)result.numFailed / (float)result.numExecuted) : 0.0f));
print(" Not supported: %d/%d (%.1f%%)\n", result.numNotSupported, result.numExecuted, (result.numExecuted > 0 ? (100.0f * (float)result.numNotSupported / (float)result.numExecuted) : 0.0f));
print(" Warnings: %d/%d (%.1f%%)\n", result.numWarnings, result.numExecuted, (result.numExecuted > 0 ? (100.0f * (float)result.numWarnings / (float)result.numExecuted) : 0.0f));
+ print(" Waived: %d/%d (%.1f%%)\n", result.numWaived, result.numExecuted, (result.numExecuted > 0 ? (100.0f * (float)result.numWaived / (float)result.numExecuted) : 0.0f));
if (!result.isComplete)
print("Test run was ABORTED!\n");
}
DE_DECLARE_COMMAND_LINE_OPT(RenderDoc, bool);
DE_DECLARE_COMMAND_LINE_OPT(CaseFraction, std::vector<int>);
DE_DECLARE_COMMAND_LINE_OPT(CaseFractionMandatoryTests, std::string);
+DE_DECLARE_COMMAND_LINE_OPT(WaiverFile, std::string);
static void parseIntList (const char* src, std::vector<int>* dst)
{
<< Option<ShaderCacheTruncate> (DE_NULL, "deqp-shadercache-truncate", "Truncate shader cache before running tests", s_enableNames, "enable")
<< Option<RenderDoc> (DE_NULL, "deqp-renderdoc", "Enable RenderDoc frame markers", s_enableNames, "disable")
<< Option<CaseFraction> (DE_NULL, "deqp-fraction", "Run a fraction of the test cases (e.g. N,M means run group%M==N)", parseIntList, "")
- << Option<CaseFractionMandatoryTests> (DE_NULL, "deqp-fraction-mandatory-caselist-file", "Case list file that must be run for each fraction", "");
+ << Option<CaseFractionMandatoryTests> (DE_NULL, "deqp-fraction-mandatory-caselist-file", "Case list file that must be run for each fraction", "")
+ << Option<WaiverFile> (DE_NULL, "deqp-waiver-file", "Read waived tests from given file", "");
}
void registerLegacyOptions (de::cmdline::Parser& parser)
class CasePaths
{
public:
- CasePaths (const string& pathList);
- CasePaths (const vector<string>& pathList);
- bool matches (const string& caseName, bool allowPrefix=false) const;
+ CasePaths(const string& pathList);
+ CasePaths(const vector<string>& pathList);
+ bool matches(const string& caseName, bool allowPrefix = false) const;
private:
const vector<string> m_casePatterns;
}
// Match a single path component against a pattern component that may contain *-wildcards.
-static bool matchWildcards(string::const_iterator patternStart,
- string::const_iterator patternEnd,
- string::const_iterator pathStart,
- string::const_iterator pathEnd,
- bool allowPrefix)
+bool matchWildcards(string::const_iterator patternStart,
+ string::const_iterator patternEnd,
+ string::const_iterator pathStart,
+ string::const_iterator pathEnd,
+ bool allowPrefix)
{
string::const_iterator pattern = patternStart;
string::const_iterator path = pathStart;
int CommandLine::getOptimizationRecipe (void) const { return m_cmdLine.getOption<opt::Optimization>(); }
bool CommandLine::isSpirvOptimizationEnabled (void) const { return m_cmdLine.getOption<opt::OptimizeSpirv>(); }
bool CommandLine::isRenderDocEnabled (void) const { return m_cmdLine.getOption<opt::RenderDoc>(); }
+const char* CommandLine::getWaiverFileName (void) const { return m_cmdLine.getOption<opt::WaiverFile>().c_str(); }
const std::vector<int>& CommandLine::getCaseFraction (void) const { return m_cmdLine.getOption<opt::CaseFraction>(); }
const char* CommandLine::getCaseFractionMandatoryTests (void) const { return m_cmdLine.getOption<opt::CaseFractionMandatoryTests>().c_str(); }
const char* CommandLine::getArchiveDir (void) const { return m_cmdLine.getOption<opt::ArchiveDir>().c_str(); }
class CasePaths;
class Archive;
+// Match a single path component against a pattern component that may contain *-wildcards.
+bool matchWildcards(std::string::const_iterator patternStart,
+ std::string::const_iterator patternEnd,
+ std::string::const_iterator pathStart,
+ std::string::const_iterator pathEnd,
+ bool allowPrefix);
+
class CaseListFilter
{
public:
//! Enable RenderDoc frame markers (--deqp-renderdoc)
bool isRenderDocEnabled (void) const;
+ //! Get waiver file name (--deqp-waiver-file)
+ const char* getWaiverFileName (void) const;
+
//! Get case list fraction
const std::vector<int>& getCaseFraction (void) const;
case QP_TEST_RESULT_QUALITY_WARNING: return 30;
case QP_TEST_RESULT_COMPATIBILITY_WARNING: return 40;
case QP_TEST_RESULT_TIMEOUT: return 50;
+ case QP_TEST_RESULT_WAIVER: return 60;
case QP_TEST_RESULT_FAIL: return 100;
case QP_TEST_RESULT_RESOURCE_ERROR: return 110;
case QP_TEST_RESULT_INTERNAL_ERROR: return 120;
case QP_TEST_RESULT_NOT_SUPPORTED: m_status.numNotSupported += 1; break;
case QP_TEST_RESULT_QUALITY_WARNING: m_status.numWarnings += 1; break;
case QP_TEST_RESULT_COMPATIBILITY_WARNING: m_status.numWarnings += 1; break;
+ case QP_TEST_RESULT_WAIVER: m_status.numWaived += 1; break;
default: m_status.numFailed += 1; break;
}
numFailed = 0;
numNotSupported = 0;
numWarnings = 0;
+ numWaived = 0;
isComplete = false;
}
int numFailed; //!< Number of cases failed.
int numNotSupported; //!< Number of cases not supported.
int numWarnings; //!< Number of QualityWarning / CompatibilityWarning results.
+ int numWaived; //!< Number of waived tests.
bool isComplete; //!< Is run complete.
};
--- /dev/null
+/*-------------------------------------------------------------------------
+ * Vulkan CTS Framework
+ * --------------------
+ *
+ * Copyright (c) 2020 The Khronos Group Inc.
+ *
+ * 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 Waiver mechanism implementation.
+ *//*--------------------------------------------------------------------*/
+
+#include "tcuWaiverUtil.hpp"
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include "deString.h"
+#include "deStringUtil.hpp"
+#include "xeXMLParser.hpp"
+#include "tcuCommandLine.hpp"
+
+namespace tcu
+{
+
+// Base class for GL and VK waiver tree builders
+class WaiverTreeBuilder
+{
+public:
+
+ typedef WaiverUtil::WaiverComponent WaiverComponent;
+
+public:
+ WaiverTreeBuilder (const std::string& waiverFile,
+ const std::string& packageName,
+ const char* vendorTag,
+ const char* deviceTag,
+ std::vector<WaiverComponent>& waiverTree);
+
+ virtual ~WaiverTreeBuilder();
+
+ void build (void);
+
+protected:
+
+ // structure representing component during tree construction
+ struct BuilComponent
+ {
+ std::string name;
+ deUint32 parentIndex; // index in allComponents vector
+ std::vector<deUint32> childrenIndex; // index in allComponents vector
+
+ BuilComponent(std::string n, deUint32 p)
+ : name(std::move(n))
+ , parentIndex(p)
+ {}
+ };
+
+ // parse waiver.xml and read list of waived tests defined
+ // specificly for current device id and current vendor id
+ void readWaivedTestsFromXML (void);
+
+ // use list of paths to build a temporary tree which
+ // consists of BuilComponents that help with tree construction
+ void buildTreeFromPathList (void);
+
+ // use temporary tree to create final tree containing
+ // only things that are needed during searches
+ void constructFinalTree (void);
+
+ // helper methods used to identify if proper waiver for vendor was found
+ virtual bool matchVendor (const std::string& vendor) const = 0;
+
+ // helper methods used after waiver for current vendor was found to check
+ // if it is defined also for currend deviceId/renderer
+ virtual bool matchDevice (const std::string& device) const = 0;
+
+ // helper method used in buildTreeFromPathList; returns index
+ // of component having same ancestors as the component specified
+ // in the argument or 0 when build tree does not include this component
+ deUint32 findComponentInBuildTree(const std::vector<std::string>& pathComponents, deUint32 index) const;
+
+private:
+ const std::string& m_waiverFile;
+ const std::string& m_packageName;
+
+ const char* m_vendorTag;
+ const char* m_deviceTag;
+
+ // helper attributes used during construction
+ std::vector<std::string> m_testList;
+ std::vector<BuilComponent> m_buildTree;
+
+ // reference to vector containing final tree
+ std::vector<WaiverComponent>& m_finalTree;
+};
+
+WaiverTreeBuilder::WaiverTreeBuilder(const std::string& waiverFile,
+ const std::string& packageName,
+ const char* vendorTag,
+ const char* deviceTag,
+ std::vector<WaiverComponent>& waiverTree)
+ : m_waiverFile (waiverFile)
+ , m_packageName (packageName)
+ , m_vendorTag (vendorTag)
+ , m_deviceTag (deviceTag)
+ , m_finalTree (waiverTree)
+{
+}
+
+WaiverTreeBuilder::~WaiverTreeBuilder()
+{
+}
+
+void WaiverTreeBuilder::build(void)
+{
+ readWaivedTestsFromXML();
+ buildTreeFromPathList();
+ constructFinalTree();
+}
+
+void WaiverTreeBuilder::readWaivedTestsFromXML()
+{
+ std::ifstream iStream(m_waiverFile);
+ if (!iStream.is_open())
+ return;
+
+ // get whole waiver file content
+ std::stringstream buffer;
+ buffer << iStream.rdbuf();
+ std::string wholeContent = buffer.str();
+
+ // feed parser with xml content
+ xe::xml::Parser xmlParser;
+ xmlParser.feed(reinterpret_cast<const deUint8*>(wholeContent.c_str()), static_cast<int>(wholeContent.size()));
+ xmlParser.advance();
+
+ // first we find matching vendor, then search for matching device/renderer and then memorize cases
+ bool vendorFound = false;
+ bool deviceFound = false;
+ bool scanDevice = false;
+ bool memorizeCase = false;
+ std::vector<std::string> waiverTestList;
+
+ while (true)
+ {
+ // we are grabing elements one by one - depth-first traversal in pre-order
+ xe::xml::Element currElement = xmlParser.getElement();
+
+ // stop if there is parsing error or we didnt found
+ // waiver for current vendor id and device id/renderer
+ if (currElement == xe::xml::ELEMENT_INCOMPLETE ||
+ currElement == xe::xml::ELEMENT_END_OF_STRING)
+ break;
+
+ const char* elemName = xmlParser.getElementName();
+ switch (currElement)
+ {
+ case xe::xml::ELEMENT_START:
+ if (vendorFound)
+ {
+ if (!deviceFound)
+ {
+ // if we found proper vendor and are reading deviceIds/rendererers list then allow it
+ scanDevice = deStringEqual(elemName, m_deviceTag); // e.g. "d"
+ if (scanDevice)
+ break;
+ }
+
+ // if we found waiver for current vendor and are reading test case names then allow it
+ memorizeCase = deStringEqual(elemName, "t");
+ break;
+ }
+
+ // we are searching for waiver definition for current vendor, till we find
+ // it we skip everythingh; we also skip tags that we don't need eg. description
+ if (!deStringEqual(elemName, "waiver"))
+ break;
+
+ // we found waiver tag, check if it is deffined for current vendor
+ waiverTestList.clear();
+ if (xmlParser.hasAttribute(m_vendorTag))
+ vendorFound = matchVendor(xmlParser.getAttribute(m_vendorTag));
+ break;
+
+ case xe::xml::ELEMENT_DATA:
+ if (scanDevice)
+ {
+ // check if device read from xml matches current device/renderer
+ std::string waivedDevice;
+ xmlParser.getDataStr(waivedDevice);
+ deviceFound = matchDevice(waivedDevice);
+ }
+ else if (memorizeCase)
+ {
+ // memorize whats betwean <t></t> tags when case name starts with current package name
+ // note: waiver tree is constructed per package
+ std::string waivedCaseName;
+ xmlParser.getDataStr(waivedCaseName);
+ if (waivedCaseName.find(m_packageName) == 0)
+ waiverTestList.push_back(waivedCaseName);
+ }
+ break;
+
+ case xe::xml::ELEMENT_END:
+ memorizeCase = false;
+ scanDevice = false;
+ if (deStringEqual(elemName, "waiver"))
+ {
+ // when we found proper waiver we can copy memorized cases
+ if(vendorFound && deviceFound)
+ m_testList.insert(m_testList.end(), waiverTestList.begin(), waiverTestList.end());
+ vendorFound = false;
+ deviceFound = false;
+ }
+ break;
+
+ default:
+ DE_ASSERT(false);
+ }
+
+ xmlParser.advance();
+ }
+}
+
+deUint32 WaiverTreeBuilder::findComponentInBuildTree(const std::vector<std::string>& pathComponents, deUint32 index) const
+{
+ const std::string& checkedName = pathComponents[index];
+
+ // check if same component is already in the build tree; we start from 1 - skiping root
+ for (deUint32 componentIndex = 1 ; componentIndex < m_buildTree.size() ; ++componentIndex)
+ {
+ const BuilComponent& componentInTree = m_buildTree[componentIndex];
+ if (componentInTree.name != checkedName)
+ continue;
+
+ // names match so we need to make sure that all their ancestors match too;
+ deUint32 reverseLevel = index;
+ deUint32 ancestorInTreeIndex = componentInTree.parentIndex;
+
+ // if this component is the next after root then there is no ancestors to check
+ if (reverseLevel == 1)
+ return componentIndex;
+
+ while (--reverseLevel > 0)
+ {
+ // names dont match - we can move to searching other build tree items
+ if (pathComponents[reverseLevel] != m_buildTree[ancestorInTreeIndex].name)
+ break;
+
+ // when previous path component matches ancestor name then we need do check earlier path component
+ ancestorInTreeIndex = m_buildTree[ancestorInTreeIndex].parentIndex;
+
+ // we reached root
+ if (ancestorInTreeIndex == 0)
+ {
+ // if next level would be root then ancestors match
+ if (reverseLevel == 1)
+ return componentIndex;
+ // if next level is not root then ancestors dont match
+ break;
+ }
+ }
+ }
+
+ // searched path component is not in the tree
+ return 0;
+}
+
+void WaiverTreeBuilder::buildTreeFromPathList(void)
+{
+ if (m_testList.empty())
+ return;
+
+ deUint32 parentIndex = 0;
+
+ // construct root node
+ m_buildTree.emplace_back("root", DE_NULL);
+
+ for (const auto& path : m_testList)
+ {
+ const std::vector<std::string> pathComponents = de::splitString(path, '.');
+
+ // first component is parented to root
+ parentIndex = 0;
+
+ // iterate over all components of current path, but skip first one (e.g. "dEQP-VK", "KHR-GLES31")
+ for (deUint32 level = 1 ; level < pathComponents.size() ; ++level)
+ {
+ // check if same component is already in the tree and we dont need to add it
+ deUint32 componentIndex = findComponentInBuildTree(pathComponents, level);
+ if (componentIndex)
+ {
+ parentIndex = componentIndex;
+ continue;
+ }
+
+ // component is not in the tree, add it
+ const std::string componentName = pathComponents[level];
+ m_buildTree.emplace_back(componentName, parentIndex);
+
+ // add current component as a child to its parent and assume
+ // that this component will be parent of next component
+ componentIndex = static_cast<deUint32>(m_buildTree.size() - 1);
+ m_buildTree[parentIndex].childrenIndex.push_back(componentIndex);
+ parentIndex = componentIndex;
+ }
+ }
+}
+
+void WaiverTreeBuilder::constructFinalTree(void)
+{
+ if (m_buildTree.empty())
+ return;
+
+ // translate vector of BuilComponents to vector of WaiverComponents
+ m_finalTree.resize(m_buildTree.size());
+ for (deUint32 i = 0; i < m_finalTree.size(); ++i)
+ {
+ BuilComponent& buildCmponent = m_buildTree[i];
+ WaiverComponent& waiverComponent = m_finalTree[i];
+
+ waiverComponent.name = std::move(buildCmponent.name);
+ waiverComponent.children.resize(buildCmponent.childrenIndex.size());
+
+ // set pointers for children
+ for (deUint32 j = 0; j < buildCmponent.childrenIndex.size(); ++j)
+ {
+ deUint32 childIndexInTree = buildCmponent.childrenIndex[j];
+ waiverComponent.children[j] = &m_finalTree[childIndexInTree];
+ }
+ }
+}
+
+// Class that builds a tree out of waiver definitions for OpenGL tests.
+// Most of functionalities are shared betwean VK and GL builders and they
+// were extracted to WaiverTreeBuilder base class.
+class GLWaiverTreeBuilder : public WaiverTreeBuilder
+{
+public:
+ GLWaiverTreeBuilder (const std::string& waiverFile,
+ const std::string& packageName,
+ const std::string& currentVendor,
+ const std::string& currentRenderer,
+ std::vector<WaiverComponent>& waiverTree);
+
+ bool matchVendor (const std::string& vendor) const override;
+ bool matchDevice (const std::string& device) const override;
+
+private:
+
+ const std::string m_currentVendor;
+ const std::string m_currentRenderer;
+};
+
+GLWaiverTreeBuilder::GLWaiverTreeBuilder(const std::string& waiverFile,
+ const std::string& packageName,
+ const std::string& currentVendor,
+ const std::string& currentRenderer,
+ std::vector<WaiverComponent>& waiverTree)
+ : WaiverTreeBuilder (waiverFile, packageName, "vendor", "r", waiverTree)
+ , m_currentVendor (currentVendor)
+ , m_currentRenderer (currentRenderer)
+{
+}
+
+bool GLWaiverTreeBuilder::matchVendor(const std::string& vendor) const
+{
+ return m_currentVendor == vendor;
+}
+
+bool GLWaiverTreeBuilder::matchDevice(const std::string& device) const
+{
+ // make sure that renderer name in .xml is not within "", those extra characters should be removed
+ DE_ASSERT(device[0] != '\"');
+
+ return tcu::matchWildcards(device.cbegin(),
+ device.cend(),
+ m_currentRenderer.cbegin(),
+ m_currentRenderer.cend(),
+ false);
+}
+
+// Class that builds a tree out of waiver definitions for Vulkan tests.
+// Most of functionalities are shared betwean VK and GL builders and they
+// were extracted to WaiverTreeBuilder base class.
+class VKWaiverTreeBuilder : public WaiverTreeBuilder
+{
+public:
+ VKWaiverTreeBuilder (const std::string& waiverFile,
+ const std::string& packageName,
+ const deUint32 currentVendor,
+ const deUint32 currentRenderer,
+ std::vector<WaiverComponent>& waiverTree);
+
+ bool matchVendor (const std::string& vendor) const override;
+ bool matchDevice (const std::string& device) const override;
+
+private:
+
+ const deUint32 m_currentVendorId;
+ const deUint32 m_currentDeviceId;
+};
+
+VKWaiverTreeBuilder::VKWaiverTreeBuilder(const std::string& waiverFile,
+ const std::string& packageName,
+ const deUint32 currentVendor,
+ const deUint32 currentRenderer,
+ std::vector<WaiverComponent>& waiverTree)
+ : WaiverTreeBuilder(waiverFile, packageName, "vendorId", "d", waiverTree)
+ , m_currentVendorId(currentVendor)
+ , m_currentDeviceId(currentRenderer)
+{
+}
+
+bool VKWaiverTreeBuilder::matchVendor(const std::string& vendor) const
+{
+ return (m_currentVendorId == static_cast<deUint32>(std::stoul(vendor, 0, 0)));
+}
+
+bool VKWaiverTreeBuilder::matchDevice(const std::string& device) const
+{
+ return (m_currentDeviceId == static_cast<deUint32>(std::stoul(device, 0, 0)));
+}
+
+void WaiverUtil::setup(const std::string waiverFile, std::string packageName, deUint32 vendorId, deUint32 deviceId)
+{
+ VKWaiverTreeBuilder(waiverFile, packageName, vendorId, deviceId, m_waiverTree).build();
+}
+
+void WaiverUtil::setup(const std::string waiverFile, std::string packageName, std::string vendor, std::string renderer)
+{
+ GLWaiverTreeBuilder(waiverFile, packageName, vendor, renderer, m_waiverTree).build();
+}
+
+bool WaiverUtil::isOnWaiverList(const std::string& casePath) const
+{
+ if (m_waiverTree.empty())
+ return false;
+
+ // skip root e.g. "dEQP-VK"
+ size_t firstDotPos = casePath.find('.');
+ std::string::const_iterator componentStart = casePath.cbegin() + firstDotPos + 1;
+ std::string::const_iterator componentEnd = componentStart;
+ std::string::const_iterator pathEnd = casePath.cend();
+ const WaiverComponent* waiverComponent = m_waiverTree.data();
+
+ // check path component by component
+ while (true)
+ {
+ // find the last character of next component
+ ++componentEnd;
+ for (; componentEnd < pathEnd ; ++componentEnd)
+ {
+ if (*componentEnd == '.')
+ break;
+ }
+
+ // check if one of children has the same component name
+ for (const auto& c : waiverComponent->children)
+ {
+ bool matchFound = tcu::matchWildcards(c->name.cbegin(),
+ c->name.cend(),
+ componentStart,
+ componentEnd,
+ false);
+
+ // current waiver component matches curent path component - go to next component
+ if (matchFound)
+ {
+ waiverComponent = c;
+ break;
+ }
+ }
+
+ // we checked all components - if our pattern was a leaf then this test should be waived
+ if (componentEnd == pathEnd)
+ return waiverComponent->children.empty();
+
+ // go to next test path component
+ componentStart = componentEnd + 1;
+ }
+ return false;
+}
+
+} // vk
--- /dev/null
+#ifndef _TCUWAIVERUTIL_HPP
+#define _TCUWAIVERUTIL_HPP
+/*-------------------------------------------------------------------------
+ * Vulkan CTS Framework
+ * --------------------
+ *
+ * Copyright (c) 2020 The Khronos Group Inc.
+ *
+ * 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 Waiver mechanism implementation.
+ *//*--------------------------------------------------------------------*/
+
+#include "deDefs.h"
+#include <string>
+#include <vector>
+
+namespace tcu
+{
+
+class WaiverUtil
+{
+public:
+ WaiverUtil () = default;
+
+ void setup (const std::string waiverFile, std::string packageName, deUint32 vendorId, deUint32 deviceId);
+ void setup (const std::string waiverFile, std::string packageName, std::string vendor, std::string renderer);
+
+ bool isOnWaiverList (const std::string& casePath) const;
+
+public:
+
+ struct WaiverComponent
+ {
+ std::string name;
+ std::vector<WaiverComponent*> children;
+ };
+
+private:
+
+ std::vector<WaiverComponent> m_waiverTree;
+};
+
+} // tcu
+
+#endif // _TCUWAIVERUTIL_HPP
{ QP_TEST_RESULT_INTERNAL_ERROR, "InternalError" },
{ QP_TEST_RESULT_CRASH, "Crash" },
{ QP_TEST_RESULT_TIMEOUT, "Timeout" },
+ { QP_TEST_RESULT_WAIVER, "Waiver" },
/* Add new values here if needed, remember to update qpTestResult enumeration. */
QP_TEST_RESULT_INTERNAL_ERROR, /*!< Error occurred within Tester Core */
QP_TEST_RESULT_CRASH, /*!< Crash occurred in test execution. */
QP_TEST_RESULT_TIMEOUT, /*!< Timeout occurred in test execution. */
+ QP_TEST_RESULT_WAIVER, /*!< Status code reported by waived test. */
QP_TEST_RESULT_LAST
} qpTestResult;
--- /dev/null
+# XML parser
+
+set(XEXML_SRCS
+ xeDefs.cpp
+ xeDefs.hpp
+ xeXMLParser.cpp
+ xeXMLParser.hpp
+ )
+
+set(XEXML_LIBS
+ decpp
+ deutil
+ debase
+ )
+
+add_library(xexml STATIC ${XEXML_SRCS})
+target_link_libraries(xexml ${XEXML_LIBS})
+
--- /dev/null
+/*-------------------------------------------------------------------------
+ * 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 Executor base definitions.
+ *//*--------------------------------------------------------------------*/
+
+#include "xeDefs.hpp"
+
+#include <sstream>
+
+namespace xe
+{
+
+static std::string formatError (const char* message, const char* expr, const char* file, int line)
+{
+ std::ostringstream msg;
+ msg << (message ? message : "Runtime check failed") << ": ";
+ if (expr)
+ msg << '\'' << expr << '\'';
+ msg << " at " << file << ":" << line;
+ return msg.str();
+}
+
+Error::Error (const char* message, const char* expr, const char* file, int line)
+ : std::runtime_error(formatError(message, expr, file, line))
+{
+}
+
+} // xe
--- /dev/null
+#ifndef _XEDEFS_HPP
+#define _XEDEFS_HPP
+/*-------------------------------------------------------------------------
+ * 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 Executor base definitions.
+ *//*--------------------------------------------------------------------*/
+
+#include "deDefs.hpp"
+
+#include <string>
+#include <stdexcept>
+
+namespace xe
+{
+
+class Error : public std::runtime_error
+{
+public:
+ Error (const std::string& message) : std::runtime_error(message) {}
+ Error (const char* message, const char* expr, const char* file, int line);
+};
+
+class ParseError : public Error
+{
+public:
+ ParseError (const std::string& message) : Error(message) {}
+};
+
+} // xe
+
+#define XE_FAIL(MSG) throw xe::Error(MSG, "", __FILE__, __LINE__)
+#define XE_CHECK(X) do { if ((!deGetFalse() && (X)) ? DE_FALSE : DE_TRUE) throw xe::Error(NULL, #X, __FILE__, __LINE__); } while(deGetFalse())
+#define XE_CHECK_MSG(X, MSG) do { if ((!deGetFalse() && (X)) ? DE_FALSE : DE_TRUE) throw xe::Error(MSG, #X, __FILE__, __LINE__); } while(deGetFalse())
+
+#endif // _XEDEFS_HPP
--- /dev/null
+/*-------------------------------------------------------------------------
+ * 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 XML Parser.
+ *//*--------------------------------------------------------------------*/
+
+#include "xeXMLParser.hpp"
+#include "deInt32.h"
+
+namespace xe
+{
+namespace xml
+{
+
+enum
+{
+ TOKENIZER_INITIAL_BUFFER_SIZE = 1024
+};
+
+static inline bool isIdentifierStartChar (int ch)
+{
+ return de::inRange<int>(ch, 'a', 'z') || de::inRange<int>(ch, 'A', 'Z');
+}
+
+static inline bool isIdentifierChar (int ch)
+{
+ return isIdentifierStartChar(ch) || de::inRange<int>(ch, '0', '9') || (ch == '-') || (ch == '_');
+}
+
+static inline bool isWhitespaceChar (int ch)
+{
+ return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
+}
+
+static int getNextBufferSize (int curSize, int minNewSize)
+{
+ return de::max(curSize*2, 1<<deLog2Ceil32(minNewSize));
+}
+
+Tokenizer::Tokenizer (void)
+ : m_curToken (TOKEN_INCOMPLETE)
+ , m_curTokenLen (0)
+ , m_state (STATE_DATA)
+ , m_buf (TOKENIZER_INITIAL_BUFFER_SIZE)
+{
+}
+
+Tokenizer::~Tokenizer (void)
+{
+}
+
+void Tokenizer::clear (void)
+{
+ m_curToken = TOKEN_INCOMPLETE;
+ m_curTokenLen = 0;
+ m_state = STATE_DATA;
+ m_buf.clear();
+}
+
+void Tokenizer::error (const std::string& what)
+{
+ throw ParseError(what);
+}
+
+void Tokenizer::feed (const deUint8* bytes, int numBytes)
+{
+ // Grow buffer if necessary.
+ if (m_buf.getNumFree() < numBytes)
+ {
+ m_buf.resize(getNextBufferSize(m_buf.getSize(), m_buf.getNumElements()+numBytes));
+ }
+
+ // Append to front.
+ m_buf.pushFront(bytes, numBytes);
+
+ // If we haven't parsed complete token, re-try after data feed.
+ if (m_curToken == TOKEN_INCOMPLETE)
+ advance();
+}
+
+int Tokenizer::getChar (int offset) const
+{
+ DE_ASSERT(de::inRange(offset, 0, m_buf.getNumElements()));
+
+ if (offset < m_buf.getNumElements())
+ return m_buf.peekBack(offset);
+ else
+ return END_OF_BUFFER;
+}
+
+void Tokenizer::advance (void)
+{
+ if (m_curToken != TOKEN_INCOMPLETE)
+ {
+ // Parser should not try to advance beyond end of string.
+ DE_ASSERT(m_curToken != TOKEN_END_OF_STRING);
+
+ // If current token is tag end, change state to data.
+ if (m_curToken == TOKEN_TAG_END ||
+ m_curToken == TOKEN_EMPTY_ELEMENT_END ||
+ m_curToken == TOKEN_PROCESSING_INSTRUCTION_END ||
+ m_curToken == TOKEN_COMMENT ||
+ m_curToken == TOKEN_ENTITY)
+ m_state = STATE_DATA;
+
+ // Advance buffer by length of last token.
+ m_buf.popBack(m_curTokenLen);
+
+ // Reset state.
+ m_curToken = TOKEN_INCOMPLETE;
+ m_curTokenLen = 0;
+
+ // If we hit end of string here, report it as end of string.
+ if (getChar(0) == END_OF_STRING)
+ {
+ m_curToken = TOKEN_END_OF_STRING;
+ m_curTokenLen = 1;
+ return;
+ }
+ }
+
+ int curChar = getChar(m_curTokenLen);
+
+ for (;;)
+ {
+ if (m_state == STATE_DATA)
+ {
+ // Advance until we hit end of buffer or tag start and treat that as data token.
+ if (curChar == END_OF_STRING || curChar == (int)END_OF_BUFFER || curChar == '<' || curChar == '&')
+ {
+ if (curChar == '<')
+ m_state = STATE_TAG;
+ else if (curChar == '&')
+ m_state = STATE_ENTITY;
+
+ if (m_curTokenLen > 0)
+ {
+ // Report data token.
+ m_curToken = TOKEN_DATA;
+ return;
+ }
+ else if (curChar == END_OF_STRING || curChar == (int)END_OF_BUFFER)
+ {
+ // Just return incomplete token, no data parsed.
+ return;
+ }
+ else
+ {
+ DE_ASSERT(m_state == STATE_TAG || m_state == STATE_ENTITY);
+ continue;
+ }
+ }
+ }
+ else
+ {
+ // Eat all whitespace if present.
+ if (m_curTokenLen == 0)
+ {
+ while (isWhitespaceChar(curChar))
+ {
+ m_buf.popBack();
+ curChar = getChar(0);
+ }
+ }
+
+ // Handle end of string / buffer.
+ if (curChar == END_OF_STRING)
+ error("Unexpected end of string");
+ else if (curChar == (int)END_OF_BUFFER)
+ {
+ DE_ASSERT(m_curToken == TOKEN_INCOMPLETE);
+ return;
+ }
+
+ if (m_curTokenLen == 0)
+ {
+ // Expect start of identifier, value or special tag token.
+ if (curChar == '\'' || curChar == '"')
+ m_state = STATE_VALUE;
+ else if (isIdentifierStartChar(curChar))
+ m_state = STATE_IDENTIFIER;
+ else if (curChar == '<' || curChar == '?' || curChar == '/')
+ m_state = STATE_TAG;
+ else if (curChar == '&')
+ DE_ASSERT(m_state == STATE_ENTITY);
+ else if (curChar == '=')
+ {
+ m_curToken = TOKEN_EQUAL;
+ m_curTokenLen = 1;
+ return;
+ }
+ else if (curChar == '>')
+ {
+ m_curToken = TOKEN_TAG_END;
+ m_curTokenLen = 1;
+ return;
+ }
+ else
+ error("Unexpected character");
+ }
+ else if (m_state == STATE_IDENTIFIER)
+ {
+ if (!isIdentifierChar(curChar))
+ {
+ m_curToken = TOKEN_IDENTIFIER;
+ return;
+ }
+ }
+ else if (m_state == STATE_VALUE)
+ {
+ // \todo [2012-06-07 pyry] Escapes.
+ if (curChar == '\'' || curChar == '"')
+ {
+ // \todo [2012-10-17 pyry] Should we actually do the check against getChar(0)?
+ if (curChar != getChar(0))
+ error("Mismatched quote");
+ m_curToken = TOKEN_STRING;
+ m_curTokenLen += 1;
+ return;
+ }
+ }
+ else if (m_state == STATE_COMMENT)
+ {
+ DE_ASSERT(m_curTokenLen >= 2); // 2 characters have been parsed if we are in comment state.
+
+ if (m_curTokenLen <= 3)
+ {
+ if (curChar != '-')
+ error("Invalid comment start");
+ }
+ else
+ {
+ int prev2 = m_curTokenLen > 5 ? getChar(m_curTokenLen-2) : 0;
+ int prev1 = m_curTokenLen > 4 ? getChar(m_curTokenLen-1) : 0;
+
+ if (prev2 == '-' && prev1 == '-')
+ {
+ if (curChar != '>')
+ error("Invalid comment end");
+ m_curToken = TOKEN_COMMENT;
+ m_curTokenLen += 1;
+ return;
+ }
+ }
+ }
+ else if (m_state == STATE_ENTITY)
+ {
+ if (m_curTokenLen >= 1)
+ {
+ if (curChar == ';')
+ {
+ m_curToken = TOKEN_ENTITY;
+ m_curTokenLen += 1;
+ return;
+ }
+ else if (!de::inRange<int>(curChar, '0', '9') &&
+ !de::inRange<int>(curChar, 'a', 'z') &&
+ !de::inRange<int>(curChar, 'A', 'Z'))
+ error("Invalid entity");
+ }
+ }
+ else
+ {
+ // Special tokens are at most 2 characters.
+ DE_ASSERT(m_state == STATE_TAG && m_curTokenLen == 1);
+
+ int prevChar = getChar(m_curTokenLen-1);
+
+ if (prevChar == '<')
+ {
+ // Tag start.
+ if (curChar == '/')
+ {
+ m_curToken = TOKEN_END_TAG_START;
+ m_curTokenLen = 2;
+ return;
+ }
+ else if (curChar == '?')
+ {
+ m_curToken = TOKEN_PROCESSING_INSTRUCTION_START;
+ m_curTokenLen = 2;
+ return;
+ }
+ else if (curChar == '!')
+ {
+ m_state = STATE_COMMENT;
+ }
+ else
+ {
+ m_curToken = TOKEN_TAG_START;
+ m_curTokenLen = 1;
+ return;
+ }
+ }
+ else if (prevChar == '?')
+ {
+ if (curChar != '>')
+ error("Invalid processing instruction end");
+ m_curToken = TOKEN_PROCESSING_INSTRUCTION_END;
+ m_curTokenLen = 2;
+ return;
+ }
+ else if (prevChar == '/')
+ {
+ if (curChar != '>')
+ error("Invalid empty element end");
+ m_curToken = TOKEN_EMPTY_ELEMENT_END;
+ m_curTokenLen = 2;
+ return;
+ }
+ else
+ error("Could not parse special token");
+ }
+ }
+
+ m_curTokenLen += 1;
+ curChar = getChar(m_curTokenLen);
+ }
+}
+
+void Tokenizer::getString (std::string& dst) const
+{
+ DE_ASSERT(m_curToken == TOKEN_STRING);
+ dst.resize(m_curTokenLen-2);
+ for (int ndx = 0; ndx < m_curTokenLen-2; ndx++)
+ dst[ndx] = m_buf.peekBack(ndx+1);
+}
+
+Parser::Parser (void)
+ : m_element (ELEMENT_INCOMPLETE)
+ , m_state (STATE_DATA)
+{
+}
+
+Parser::~Parser (void)
+{
+}
+
+void Parser::clear (void)
+{
+ m_tokenizer.clear();
+ m_elementName.clear();
+ m_attributes.clear();
+ m_attribName.clear();
+ m_entityValue.clear();
+
+ m_element = ELEMENT_INCOMPLETE;
+ m_state = STATE_DATA;
+}
+
+void Parser::error (const std::string& what)
+{
+ throw ParseError(what);
+}
+
+void Parser::feed (const deUint8* bytes, int numBytes)
+{
+ m_tokenizer.feed(bytes, numBytes);
+
+ if (m_element == ELEMENT_INCOMPLETE)
+ advance();
+}
+
+void Parser::advance (void)
+{
+ if (m_element == ELEMENT_START)
+ m_attributes.clear();
+
+ // \note No token is advanced when element end is reported.
+ if (m_state == STATE_YIELD_EMPTY_ELEMENT_END)
+ {
+ DE_ASSERT(m_element == ELEMENT_START);
+ m_element = ELEMENT_END;
+ m_state = STATE_DATA;
+ return;
+ }
+
+ if (m_element != ELEMENT_INCOMPLETE)
+ {
+ m_tokenizer.advance();
+ m_element = ELEMENT_INCOMPLETE;
+ }
+
+ for (;;)
+ {
+ Token curToken = m_tokenizer.getToken();
+
+ // Skip comments.
+ while (curToken == TOKEN_COMMENT)
+ {
+ m_tokenizer.advance();
+ curToken = m_tokenizer.getToken();
+ }
+
+ if (curToken == TOKEN_INCOMPLETE)
+ {
+ DE_ASSERT(m_element == ELEMENT_INCOMPLETE);
+ return;
+ }
+
+ switch (m_state)
+ {
+ case STATE_ENTITY:
+ m_state = STATE_DATA;
+ // Fall-through
+
+ case STATE_DATA:
+ switch (curToken)
+ {
+ case TOKEN_DATA:
+ m_element = ELEMENT_DATA;
+ return;
+
+ case TOKEN_END_OF_STRING:
+ m_element = ELEMENT_END_OF_STRING;
+ return;
+
+ case TOKEN_TAG_START:
+ m_state = STATE_START_TAG_OPEN;
+ break;
+
+ case TOKEN_END_TAG_START:
+ m_state = STATE_END_TAG_OPEN;
+ break;
+
+ case TOKEN_PROCESSING_INSTRUCTION_START:
+ m_state = STATE_IN_PROCESSING_INSTRUCTION;
+ break;
+
+ case TOKEN_ENTITY:
+ m_state = STATE_ENTITY;
+ m_element = ELEMENT_DATA;
+ parseEntityValue();
+ return;
+
+ default:
+ error("Unexpected token");
+ }
+ break;
+
+ case STATE_IN_PROCESSING_INSTRUCTION:
+ if (curToken == TOKEN_PROCESSING_INSTRUCTION_END)
+ m_state = STATE_DATA;
+ else
+ if (curToken != TOKEN_IDENTIFIER && curToken != TOKEN_EQUAL && curToken != TOKEN_STRING)
+ error("Unexpected token in processing instruction");
+ break;
+
+ case STATE_START_TAG_OPEN:
+ if (curToken != TOKEN_IDENTIFIER)
+ error("Expected identifier");
+ m_tokenizer.getTokenStr(m_elementName);
+ m_state = STATE_ATTRIBUTE_LIST;
+ break;
+
+ case STATE_END_TAG_OPEN:
+ if (curToken != TOKEN_IDENTIFIER)
+ error("Expected identifier");
+ m_tokenizer.getTokenStr(m_elementName);
+ m_state = STATE_EXPECTING_END_TAG_CLOSE;
+ break;
+
+ case STATE_EXPECTING_END_TAG_CLOSE:
+ if (curToken != TOKEN_TAG_END)
+ error("Expected tag end");
+ m_state = STATE_DATA;
+ m_element = ELEMENT_END;
+ return;
+
+ case STATE_ATTRIBUTE_LIST:
+ if (curToken == TOKEN_IDENTIFIER)
+ {
+ m_tokenizer.getTokenStr(m_attribName);
+ m_state = STATE_EXPECTING_ATTRIBUTE_EQ;
+ }
+ else if (curToken == TOKEN_EMPTY_ELEMENT_END)
+ {
+ m_state = STATE_YIELD_EMPTY_ELEMENT_END;
+ m_element = ELEMENT_START;
+ return;
+ }
+ else if (curToken == TOKEN_TAG_END)
+ {
+ m_state = STATE_DATA;
+ m_element = ELEMENT_START;
+ return;
+ }
+ else
+ error("Unexpected token");
+ break;
+
+ case STATE_EXPECTING_ATTRIBUTE_EQ:
+ if (curToken != TOKEN_EQUAL)
+ error("Expected '='");
+ m_state = STATE_EXPECTING_ATTRIBUTE_VALUE;
+ break;
+
+ case STATE_EXPECTING_ATTRIBUTE_VALUE:
+ if (curToken != TOKEN_STRING)
+ error("Expected value");
+ if (hasAttribute(m_attribName.c_str()))
+ error("Duplicate attribute");
+
+ m_tokenizer.getString(m_attributes[m_attribName]);
+ m_state = STATE_ATTRIBUTE_LIST;
+ break;
+
+ default:
+ DE_ASSERT(false);
+ }
+
+ m_tokenizer.advance();
+ }
+}
+
+static char getEntityValue (const std::string& entity)
+{
+ static const struct
+ {
+ const char* name;
+ char value;
+ } s_entities[] =
+ {
+ { "<", '<' },
+ { ">", '>' },
+ { "&", '&' },
+ { "'", '\''},
+ { """, '"' },
+ };
+
+ for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(s_entities); ndx++)
+ {
+ if (entity == s_entities[ndx].name)
+ return s_entities[ndx].value;
+ }
+
+ return 0;
+}
+
+void Parser::parseEntityValue (void)
+{
+ DE_ASSERT(m_state == STATE_ENTITY && m_tokenizer.getToken() == TOKEN_ENTITY);
+
+ std::string entity;
+ m_tokenizer.getTokenStr(entity);
+
+ const char value = getEntityValue(entity);
+ if (value == 0)
+ error("Invalid entity '" + entity + "'");
+
+ m_entityValue.resize(1);
+ m_entityValue[0] = value;
+}
+
+} // xml
+} // xe
--- /dev/null
+#ifndef _XEXMLPARSER_HPP
+#define _XEXMLPARSER_HPP
+/*-------------------------------------------------------------------------
+ * 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 XML Parser.
+ *
+ * \todo [2012-06-07 pyry] Not supported / handled properly:
+ * - xml namespaces (<ns:Element>)
+ * - backslash escapes in strings
+ * - " -style escapes
+ * - utf-8
+ *//*--------------------------------------------------------------------*/
+
+#include "xeDefs.hpp"
+#include "deRingBuffer.hpp"
+
+#include <string>
+#include <map>
+
+namespace xe
+{
+namespace xml
+{
+
+enum Token
+{
+ TOKEN_INCOMPLETE = 0, //!< Not enough data to determine token.
+ TOKEN_END_OF_STRING, //!< End of document string.
+ TOKEN_DATA, //!< Block of data (anything outside tags).
+ TOKEN_COMMENT, //!< <!-- comment -->
+ TOKEN_IDENTIFIER, //!< Identifier (in tags).
+ TOKEN_STRING, //!< String (in tags).
+ TOKEN_TAG_START, //!< <
+ TOKEN_TAG_END, //!< >
+ TOKEN_END_TAG_START, //!< </
+ TOKEN_EMPTY_ELEMENT_END, //!< />
+ TOKEN_PROCESSING_INSTRUCTION_START, //!< <?
+ TOKEN_PROCESSING_INSTRUCTION_END, //!< ?>
+ TOKEN_EQUAL, //!< =
+ TOKEN_ENTITY, //!< Entity reference, such as &
+
+ TOKEN_LAST
+};
+
+enum Element
+{
+ ELEMENT_INCOMPLETE = 0, //!< Incomplete element.
+ ELEMENT_START, //!< Element start.
+ ELEMENT_END, //!< Element end.
+ ELEMENT_DATA, //!< Data element.
+ ELEMENT_END_OF_STRING, //!< End of document string.
+
+ ELEMENT_LAST
+};
+
+const char* getTokenName (Token token);
+
+// \todo [2012-10-17 pyry] Add line number etc.
+class ParseError : public xe::ParseError
+{
+public:
+ ParseError (const std::string& message) : xe::ParseError(message) {}
+};
+
+class Tokenizer
+{
+public:
+ Tokenizer (void);
+ ~Tokenizer (void);
+
+ void clear (void); //!< Resets tokenizer to initial state.
+
+ void feed (const deUint8* bytes, int numBytes);
+ void advance (void);
+
+ Token getToken (void) const { return m_curToken; }
+ int getTokenLen (void) const { return m_curTokenLen; }
+ deUint8 getTokenByte (int offset) const { DE_ASSERT(m_curToken != TOKEN_INCOMPLETE && m_curToken != TOKEN_END_OF_STRING); return m_buf.peekBack(offset); }
+ void getTokenStr (std::string& dst) const;
+ void appendTokenStr (std::string& dst) const;
+
+ void getString (std::string& dst) const;
+
+private:
+ Tokenizer (const Tokenizer& other);
+ Tokenizer& operator= (const Tokenizer& other);
+
+ int getChar (int offset) const;
+
+ void error (const std::string& what);
+
+ enum State
+ {
+ STATE_DATA = 0,
+ STATE_TAG,
+ STATE_IDENTIFIER,
+ STATE_VALUE,
+ STATE_COMMENT,
+ STATE_ENTITY,
+
+ STATE_LAST
+ };
+
+ enum
+ {
+ END_OF_STRING = 0, //!< End of string (0).
+ END_OF_BUFFER = 0xffffffff //!< End of current data buffer.
+ };
+
+ Token m_curToken; //!< Current token.
+ int m_curTokenLen; //!< Length of current token.
+
+ State m_state; //!< Tokenization state.
+
+ de::RingBuffer<deUint8> m_buf;
+};
+
+class Parser
+{
+public:
+ typedef std::map<std::string, std::string> AttributeMap;
+ typedef AttributeMap::const_iterator AttributeIter;
+
+ Parser (void);
+ ~Parser (void);
+
+ void clear (void); //!< Resets parser to initial state.
+
+ void feed (const deUint8* bytes, int numBytes);
+ void advance (void);
+
+ Element getElement (void) const { return m_element; }
+
+ // For ELEMENT_START / ELEMENT_END.
+ const char* getElementName (void) const { return m_elementName.c_str(); }
+
+ // For ELEMENT_START.
+ bool hasAttribute (const char* name) const { return m_attributes.find(name) != m_attributes.end(); }
+ const char* getAttribute (const char* name) const { return m_attributes.find(name)->second.c_str(); }
+ const AttributeMap& attributes (void) const { return m_attributes; }
+
+ // For ELEMENT_DATA.
+ int getDataSize (void) const;
+ deUint8 getDataByte (int offset) const;
+ void getDataStr (std::string& dst) const;
+ void appendDataStr (std::string& dst) const;
+
+private:
+ Parser (const Parser& other);
+ Parser& operator= (const Parser& other);
+
+ void parseEntityValue (void);
+
+ void error (const std::string& what);
+
+ enum State
+ {
+ STATE_DATA = 0, //!< Initial state - assuming data or tag open.
+ STATE_ENTITY, //!< Parsed entity is stored - overrides data.
+ STATE_IN_PROCESSING_INSTRUCTION, //!< In processing instruction.
+ STATE_START_TAG_OPEN, //!< Start tag open.
+ STATE_END_TAG_OPEN, //!< End tag open.
+ STATE_EXPECTING_END_TAG_CLOSE, //!< Expecting end tag close.
+ STATE_ATTRIBUTE_LIST, //!< Expecting attribute list.
+ STATE_EXPECTING_ATTRIBUTE_EQ, //!< Got attribute name, expecting =.
+ STATE_EXPECTING_ATTRIBUTE_VALUE, //!< Expecting attribute value.
+ STATE_YIELD_EMPTY_ELEMENT_END, //!< Empty element: start has been reported but not end.
+
+ STATE_LAST
+ };
+
+ Tokenizer m_tokenizer;
+
+ Element m_element;
+ std::string m_elementName;
+ AttributeMap m_attributes;
+
+ State m_state;
+ std::string m_attribName;
+ std::string m_entityValue; //!< Data override, such as entity value.
+};
+
+// Inline implementations
+
+inline void Tokenizer::getTokenStr (std::string& dst) const
+{
+ DE_ASSERT(m_curToken != TOKEN_INCOMPLETE && m_curToken != TOKEN_END_OF_STRING);
+ dst.resize(m_curTokenLen);
+ for (int ndx = 0; ndx < m_curTokenLen; ndx++)
+ dst[ndx] = m_buf.peekBack(ndx);
+}
+
+inline void Tokenizer::appendTokenStr (std::string& dst) const
+{
+ DE_ASSERT(m_curToken != TOKEN_INCOMPLETE && m_curToken != TOKEN_END_OF_STRING);
+
+ size_t oldLen = dst.size();
+ dst.resize(oldLen+m_curTokenLen);
+
+ for (int ndx = 0; ndx < m_curTokenLen; ndx++)
+ dst[oldLen+ndx] = m_buf.peekBack(ndx);
+}
+
+inline int Parser::getDataSize (void) const
+{
+ if (m_state != STATE_ENTITY)
+ return m_tokenizer.getTokenLen();
+ else
+ return (int)m_entityValue.size();
+}
+
+inline deUint8 Parser::getDataByte (int offset) const
+{
+ if (m_state != STATE_ENTITY)
+ return m_tokenizer.getTokenByte(offset);
+ else
+ return (deUint8)m_entityValue[offset];
+}
+
+inline void Parser::getDataStr (std::string& dst) const
+{
+ if (m_state != STATE_ENTITY)
+ return m_tokenizer.getTokenStr(dst);
+ else
+ dst = m_entityValue;
+}
+
+inline void Parser::appendDataStr (std::string& dst) const
+{
+ if (m_state != STATE_ENTITY)
+ return m_tokenizer.appendTokenStr(dst);
+ else
+ dst += m_entityValue;
+}
+
+} // xml
+} // xe
+
+#endif // _XEXMLPARSER_HPP
#include "es2aAccuracyTests.hpp"
#include "es2sStressTests.hpp"
#include "tcuTestLog.hpp"
+#include "tcuTestContext.hpp"
+#include "tcuWaiverUtil.hpp"
+#include "tcuCommandLine.hpp"
+#include "gluContextInfo.hpp"
#include "gluRenderContext.hpp"
#include "gluStateReset.hpp"
#include "glwFunctions.hpp"
class TestCaseWrapper : public tcu::TestCaseExecutor
{
public:
- TestCaseWrapper (TestPackage& package);
+ TestCaseWrapper (TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism);
~TestCaseWrapper (void);
void init (tcu::TestCase* testCase, const std::string& path);
private:
TestPackage& m_testPackage;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
-TestCaseWrapper::TestCaseWrapper (TestPackage& package)
+TestCaseWrapper::TestCaseWrapper (TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism)
: m_testPackage(package)
+ , m_waiverMechanism(waiverMechanism)
{
}
{
}
-void TestCaseWrapper::init (tcu::TestCase* testCase, const std::string&)
+void TestCaseWrapper::init (tcu::TestCase* testCase, const std::string& path)
{
+ if (m_waiverMechanism->isOnWaiverList(path))
+ throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
+
testCase->init();
}
: tcu::TestPackage (testCtx, "dEQP-GLES2", "dEQP OpenGL ES 2.0 Tests")
, m_archive (testCtx.getRootArchive(), "gles2/")
, m_context (DE_NULL)
+ , m_waiverMechanism(new tcu::WaiverUtil)
{
}
// Create context
m_context = new Context(m_testCtx);
+ // Setup waiver mechanism
+ if (m_testCtx.getCommandLine().getRunMode() == tcu::RUNMODE_EXECUTE)
+ {
+ const glu::ContextInfo& contextInfo = m_context->getContextInfo();
+ m_waiverMechanism->setup(m_context->getTestContext().getCommandLine().getWaiverFileName(), m_name,
+ contextInfo.getString(GL_VENDOR), contextInfo.getString(GL_RENDERER));
+ }
+
// Add main test groups
addChild(new InfoTests (*m_context));
addChild(new CapabilityTests (*m_context));
tcu::TestCaseExecutor* TestPackage::createExecutor (void) const
{
- return new TestCaseWrapper(const_cast<TestPackage&>(*this));
+ return new TestCaseWrapper(const_cast<TestPackage&>(*this), m_waiverMechanism);
}
} // gles2
#include "tcuTestPackage.hpp"
#include "tes2Context.hpp"
#include "tcuResource.hpp"
+#include "deSharedPtr.hpp"
+
+namespace tcu
+{
+ class WaiverUtil;
+};
namespace deqp
{
private:
tcu::ResourcePrefix m_archive;
Context* m_context;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
} // gles2
#include "es3sStressTests.hpp"
#include "es3pPerformanceTests.hpp"
#include "tcuTestLog.hpp"
+#include "tcuWaiverUtil.hpp"
+#include "tcuCommandLine.hpp"
+#include "gluContextInfo.hpp"
#include "gluRenderContext.hpp"
#include "gluStateReset.hpp"
#include "glwFunctions.hpp"
class TestCaseWrapper : public tcu::TestCaseExecutor
{
public:
- TestCaseWrapper (TestPackage& package);
+ TestCaseWrapper (TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism);
~TestCaseWrapper (void);
void init (tcu::TestCase* testCase, const std::string& path);
private:
TestPackage& m_testPackage;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
-TestCaseWrapper::TestCaseWrapper (TestPackage& package)
+TestCaseWrapper::TestCaseWrapper (TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism)
: m_testPackage(package)
+ , m_waiverMechanism(waiverMechanism)
{
}
{
}
-void TestCaseWrapper::init (tcu::TestCase* testCase, const std::string&)
+void TestCaseWrapper::init (tcu::TestCase* testCase, const std::string& path)
{
+ if (m_waiverMechanism->isOnWaiverList(path))
+ throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
+
testCase->init();
}
// Create context
m_context = new Context(m_testCtx);
+ // Setup waiver mechanism
+ if (m_testCtx.getCommandLine().getRunMode() == tcu::RUNMODE_EXECUTE)
+ {
+ const glu::ContextInfo& contextInfo = m_context->getContextInfo();
+ m_waiverMechanism->setup(m_context->getTestContext().getCommandLine().getWaiverFileName(), m_name,
+ contextInfo.getString(GL_VENDOR), contextInfo.getString(GL_RENDERER));
+ }
+
// Add main test groups
addChild(new InfoTests (*m_context));
addChild(new Functional::FunctionalTests (*m_context));
tcu::TestCaseExecutor* TestPackage::createExecutor (void) const
{
- return new TestCaseWrapper(const_cast<TestPackage&>(*this));
+ return new TestCaseWrapper(const_cast<TestPackage&>(*this), m_waiverMechanism);
}
} // gles3
#include "tcuTestPackage.hpp"
#include "tes3Context.hpp"
#include "tcuResource.hpp"
+#include "deSharedPtr.hpp"
+
+namespace tcu
+{
+ class WaiverUtil;
+};
namespace deqp
{
private:
tcu::ResourcePrefix m_archive;
Context* m_context;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
} // gles3
#include "es31sStressTests.hpp"
#include "gluStateReset.hpp"
#include "gluRenderContext.hpp"
+#include "gluContextInfo.hpp"
#include "tcuTestLog.hpp"
+#include "tcuCommandLine.hpp"
+#include "tcuWaiverUtil.hpp"
+#include "glwEnums.hpp"
namespace deqp
{
class TestCaseWrapper : public tcu::TestCaseExecutor
{
public:
- TestCaseWrapper (TestPackage& package);
+ TestCaseWrapper (TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism);
~TestCaseWrapper (void);
void init (tcu::TestCase* testCase, const std::string& path);
private:
TestPackage& m_testPackage;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
-TestCaseWrapper::TestCaseWrapper (TestPackage& package)
- : m_testPackage(package)
+TestCaseWrapper::TestCaseWrapper (TestPackage& package, de::SharedPtr<tcu::WaiverUtil> waiverMechanism)
+ : m_testPackage (package)
+ , m_waiverMechanism (waiverMechanism)
{
}
{
}
-void TestCaseWrapper::init (tcu::TestCase* testCase, const std::string&)
+void TestCaseWrapper::init (tcu::TestCase* testCase, const std::string& path)
{
+ if (m_waiverMechanism->isOnWaiverList(path))
+ throw tcu::TestException("Waived test", QP_TEST_RESULT_WAIVER);
+
testCase->init();
}
: tcu::TestPackage (testCtx, "dEQP-GLES31", "dEQP OpenGL ES 3.1 Tests")
, m_archive (testCtx.getRootArchive(), "gles31/")
, m_context (DE_NULL)
+ , m_waiverMechanism (new tcu::WaiverUtil)
{
}
// Create context
m_context = new Context(m_testCtx);
+ // Setup waiver mechanism
+ if (m_testCtx.getCommandLine().getRunMode() == tcu::RUNMODE_EXECUTE)
+ {
+ const glu::ContextInfo& contextInfo = m_context->getContextInfo();
+ m_waiverMechanism->setup(m_context->getTestContext().getCommandLine().getWaiverFileName(),
+ m_name,
+ contextInfo.getString(GL_VENDOR),
+ contextInfo.getString(GL_RENDERER));
+ }
+
// Add main test groups
addChild(new InfoTests (*m_context));
addChild(new Functional::FunctionalTests (*m_context));
tcu::TestCaseExecutor* TestPackage::createExecutor (void) const
{
- return new TestCaseWrapper(const_cast<TestPackage&>(*this));
+ return new TestCaseWrapper(const_cast<TestPackage&>(*this), m_waiverMechanism);
}
} // gles31
#include "tcuTestPackage.hpp"
#include "tes31Context.hpp"
#include "tcuResource.hpp"
+#include "deSharedPtr.hpp"
+
+namespace tcu
+{
+ class WaiverUtil;
+};
namespace deqp
{
private:
tcu::ResourcePrefix m_archive;
Context* m_context;
+ de::SharedPtr<tcu::WaiverUtil> m_waiverMechanism;
};
} // gles31
projects / platform / upstream / VK-GL-CTS.git / commitdiff