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 34 using namespace glu; 35 36 namespace glcts 37 { 38 39 class ExposedExtensionsTest : public deqp::TestCase 40 { 41 public: 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 52 private: 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 */ 67 ExposedExtensionsTest::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 79 ExposedExtensionsTest::~ExposedExtensionsTest(void) 80 { 81 } 82 83 /** Tears down any GL objects set up to run the test. */ 84 void ExposedExtensionsTest::deinit(void) 85 { 86 } 87 88 /** Stub init method */ 89 void 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 */ 97 tcu::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 148 ExposedExtensionsTests::ExposedExtensionsTests(deqp::Context& context) 149 : TestCaseGroup(context, "exposed_extensions", "Verifies exposed extensions") 150 { 151 } 152 153 void 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