1/*------------------------------------------------------------------------- 2 * OpenGL Conformance Test Suite 3 * ----------------------------- 4 * 5 * Copyright (c) 2017 The Khronos Group Inc. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 */ /*! 20 * \file glcExtensionsExposeTests.cpp 21 * \brief Test that check if specified substring is not in extension name. 22 */ /*--------------------------------------------------------------------*/ 23 24#include "glcExposedExtensionsTests.hpp" 25#include "gluContextInfo.hpp" 26#include "gluDefs.hpp" 27#include "glwEnums.hpp" 28#include "glwFunctions.hpp" 29#include "tcuCommandLine.hpp" 30#include "tcuTestLog.hpp" 31#include <string> 32#include <vector> 33 34using namespace glu; 35 36namespace glcts 37{ 38 39class ExposedExtensionsTest : public deqp::TestCase 40{ 41public: 42 /* Public methods */ 43 ExposedExtensionsTest(deqp::Context& context, std::string notAllowedSubstring, 44 const std::vector<std::string>* allowedExceptions = NULL); 45 46 virtual ~ExposedExtensionsTest(void); 47 48 void deinit(void); 49 void init(void); 50 tcu::TestNode::IterateResult iterate(void); 51 52private: 53 /* Private members */ 54 std::string m_notAllowedSubstring; 55 std::vector<std::string> m_allowedExceptions; 56}; 57 58/** Constructor. 59 * 60 * @param context Rendering context 61 * @param name Test name 62 * @param description Test description 63 * @param notAllowedSubstring Substring that should not be found in extension name. 64 * @param allowedExceptions List of exceptions that are allowed even despite 65 * containing notAllowedFraze. 66 */ 67ExposedExtensionsTest::ExposedExtensionsTest(deqp::Context& context, std::string notAllowedSubstring, 68 const std::vector<std::string>* allowedExceptions) 69 : deqp::TestCase(context, "validate_extensions", "Test verifies if extensions with " 70 "specified phrase are not exposed.") 71 , m_notAllowedSubstring(notAllowedSubstring) 72{ 73 if (allowedExceptions) 74 { 75 m_allowedExceptions = *allowedExceptions; 76 } 77} 78 79ExposedExtensionsTest::~ExposedExtensionsTest(void) 80{ 81} 82 83/** Tears down any GL objects set up to run the test. */ 84void ExposedExtensionsTest::deinit(void) 85{ 86} 87 88/** Stub init method */ 89void ExposedExtensionsTest::init(void) 90{ 91} 92 93/** Executes test iteration. 94 * 95 * @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed. 96 */ 97tcu::TestNode::IterateResult ExposedExtensionsTest::iterate(void) 98{ 99 typedef std::vector<std::string> string_vector; 100 const string_vector& extensions = m_context.getContextInfo().getExtensions(); 101 string_vector::const_iterator currExtension = extensions.begin(); 102 bool allExceptionsAreValid = true; 103 104 while (currExtension != extensions.end()) 105 { 106 // If the current extension does not contain not allowed substring then continue 107 if (currExtension->find(m_notAllowedSubstring) == std::string::npos) 108 { 109 ++currExtension; 110 continue; 111 } 112 113 // Check if current extension is one of allowed exceptions 114 bool currExtensionIsNotAnException = true; 115 string_vector::const_iterator exception = m_allowedExceptions.begin(); 116 while (exception != m_allowedExceptions.end()) 117 { 118 if ((*exception).compare(*currExtension) == 0) 119 { 120 currExtensionIsNotAnException = false; 121 break; 122 } 123 ++exception; 124 } 125 126 // Current exception is not on allowed exceptions list, test will fail 127 // but other exceptions will be checked to log all not allowed extensions 128 if (currExtensionIsNotAnException) 129 { 130 m_testCtx.getLog() << tcu::TestLog::Message << "Implementations should not expose " << *currExtension 131 << tcu::TestLog::EndMessage; 132 allExceptionsAreValid = false; 133 } 134 135 ++currExtension; 136 } 137 138 if (allExceptionsAreValid) 139 { 140 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 141 return STOP; 142 } 143 144 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); 145 return STOP; 146} 147 148ExposedExtensionsTests::ExposedExtensionsTests(deqp::Context& context) 149 : TestCaseGroup(context, "exposed_extensions", "Verifies exposed extensions") 150{ 151} 152 153void ExposedExtensionsTests::init(void) 154{ 155 if (isContextTypeES(m_context.getRenderContext().getType())) 156 { 157 addChild(new ExposedExtensionsTest(m_context, "ARB")); 158 } 159 else 160 { 161 std::vector<std::string> allowedExtensions(1, "GL_OES_EGL_image"); 162 addChild(new glcts::ExposedExtensionsTest(getContext(), "OES", &allowedExtensions)); 163 } 164} 165 166} /* glcts namespace */ 167