diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles30001TestSuite.cpp b/graphic/vkgl/src/khrgles3/ActsKhrgles30001TestSuite.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3cf60aa8c0b45c53c3c381ccab7c7f086991894b
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles30001TestSuite.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include <ctime>
+#include "Khrgles3BaseFunc.h"
+#include "ActsKhrgles30001TestSuite.h"
+
+namespace OHOS {
+    using namespace std;
+    using namespace testing::ext;
+
+    time_t ActsKhrgles30001TestSuite::starttime;
+    time_t ActsKhrgles30001TestSuite::endtime;
+    FuncRunResult ActsKhrgles30001TestSuite::runResult;
+
+    // Preset action of the test suite, which is executed before the first test case
+    void ActsKhrgles30001TestSuite::SetUpTestCase(void)
+    {
+        time(&starttime);
+        RegistPackage();
+        runResult.numPassed = 0;
+        runResult.numFailed = 0;
+        runResult.numNotSupported = 0;
+        runResult.numWarnings = 0;
+        runResult.numWaived = 0;
+    }
+    // Test suite cleanup action, which is executed after the last test case
+    void ActsKhrgles30001TestSuite::TearDownTestCase(void)
+    {
+        time(&endtime);
+        printf("Test run totals --- Passed[%d]\n", runResult.numPassed);
+        printf("Test run totals --- Failed[%d]\n", runResult.numFailed);
+        printf("Test run totals --- Notsupport[%d]\n", runResult.numNotSupported);
+        printf("Test run totals --- Warnings[%d]\n", runResult.numWarnings);
+        printf("Test run totals --- Waved[%d]\n", runResult.numWaived);
+        printf("testmain end --- COST TIME[%lld]\n", (endtime-starttime));
+    }
+    // Preset action of the test case
+    void ActsKhrgles30001TestSuite::SetUp()
+    {
+    }
+    // Cleanup action of the test case
+    void ActsKhrgles30001TestSuite::TearDown()
+    {
+    }
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles30001TestSuite.h b/graphic/vkgl/src/khrgles3/ActsKhrgles30001TestSuite.h
new file mode 100644
index 0000000000000000000000000000000000000000..989e656a65c2c09442d8b844d75ea51c56bb658d
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles30001TestSuite.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#ifndef KHRGLES3_TESTCASE_H
+#define KHRGLES3_TESTCASE_H
+
+#include <gtest/gtest.h>
+#include "Khrgles3BaseFunc.h"
+
+namespace OHOS {
+    class ActsKhrgles30001TestSuite : public testing::Test {
+    public:
+        static time_t starttime;
+        static time_t endtime;
+        static FuncRunResult runResult;
+    protected:
+        // Preset action of the test suite, which is executed before the first test case
+        static void SetUpTestCase(void);
+        // Test suite cleanup action, which is executed after the last test case
+        static void TearDownTestCase(void);
+        // Preset action of the test case
+        virtual void SetUp();
+        // Cleanup action of the test case
+        virtual void TearDown();
+    };
+} // namespace OHOS
+
+#endif // KHRGLES3_TESTCASE_H
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles30002TestSuite.cpp b/graphic/vkgl/src/khrgles3/ActsKhrgles30002TestSuite.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2c9c214c45cbe56c27073310d1b177517a771e63
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles30002TestSuite.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include <ctime>
+#include "Khrgles3BaseFunc.h"
+#include "ActsKhrgles30002TestSuite.h"
+
+namespace OHOS {
+    using namespace std;
+    using namespace testing::ext;
+
+    time_t ActsKhrgles30002TestSuite::starttime;
+    time_t ActsKhrgles30002TestSuite::endtime;
+    FuncRunResult ActsKhrgles30002TestSuite::runResult;
+
+    // Preset action of the test suite, which is executed before the first test case
+    void ActsKhrgles30002TestSuite::SetUpTestCase(void)
+    {
+        time(&starttime);
+        RegistPackage();
+        runResult.numPassed = 0;
+        runResult.numFailed = 0;
+        runResult.numNotSupported = 0;
+        runResult.numWarnings = 0;
+        runResult.numWaived = 0;
+    }
+    // Test suite cleanup action, which is executed after the last test case
+    void ActsKhrgles30002TestSuite::TearDownTestCase(void)
+    {
+        time(&endtime);
+        printf("Test run totals --- Passed[%d]\n", runResult.numPassed);
+        printf("Test run totals --- Failed[%d]\n", runResult.numFailed);
+        printf("Test run totals --- Notsupport[%d]\n", runResult.numNotSupported);
+        printf("Test run totals --- Warnings[%d]\n", runResult.numWarnings);
+        printf("Test run totals --- Waved[%d]\n", runResult.numWaived);
+        printf("testmain end --- COST TIME[%lld]\n", (endtime-starttime));
+    }
+    // Preset action of the test case
+    void ActsKhrgles30002TestSuite::SetUp()
+    {
+    }
+    // Cleanup action of the test case
+    void ActsKhrgles30002TestSuite::TearDown()
+    {
+    }
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles30002TestSuite.h b/graphic/vkgl/src/khrgles3/ActsKhrgles30002TestSuite.h
new file mode 100644
index 0000000000000000000000000000000000000000..a61e5aec0ff12b41cae6031e395ac2e5bc23e003
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles30002TestSuite.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#ifndef KHRGLES3_TESTCASE_H
+#define KHRGLES3_TESTCASE_H
+
+#include <gtest/gtest.h>
+#include "Khrgles3BaseFunc.h"
+
+namespace OHOS {
+    class ActsKhrgles30002TestSuite : public testing::Test {
+    public:
+        static time_t starttime;
+        static time_t endtime;
+        static FuncRunResult runResult;
+    protected:
+        // Preset action of the test suite, which is executed before the first test case
+        static void SetUpTestCase(void);
+        // Test suite cleanup action, which is executed after the last test case
+        static void TearDownTestCase(void);
+        // Preset action of the test case
+        virtual void SetUp();
+        // Cleanup action of the test case
+        virtual void TearDown();
+    };
+} // namespace OHOS
+
+#endif // KHRGLES3_TESTCASE_H
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles30003TestSuite.cpp b/graphic/vkgl/src/khrgles3/ActsKhrgles30003TestSuite.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..1c7402d709a0d66f6e6573012486e3e09beb7e84
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles30003TestSuite.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include <ctime>
+#include "Khrgles3BaseFunc.h"
+#include "ActsKhrgles30003TestSuite.h"
+
+namespace OHOS {
+    using namespace std;
+    using namespace testing::ext;
+
+    time_t ActsKhrgles30003TestSuite::starttime;
+    time_t ActsKhrgles30003TestSuite::endtime;
+    FuncRunResult ActsKhrgles30003TestSuite::runResult;
+
+    // Preset action of the test suite, which is executed before the first test case
+    void ActsKhrgles30003TestSuite::SetUpTestCase(void)
+    {
+        time(&starttime);
+        RegistPackage();
+        runResult.numPassed = 0;
+        runResult.numFailed = 0;
+        runResult.numNotSupported = 0;
+        runResult.numWarnings = 0;
+        runResult.numWaived = 0;
+    }
+    // Test suite cleanup action, which is executed after the last test case
+    void ActsKhrgles30003TestSuite::TearDownTestCase(void)
+    {
+        time(&endtime);
+        printf("Test run totals --- Passed[%d]\n", runResult.numPassed);
+        printf("Test run totals --- Failed[%d]\n", runResult.numFailed);
+        printf("Test run totals --- Notsupport[%d]\n", runResult.numNotSupported);
+        printf("Test run totals --- Warnings[%d]\n", runResult.numWarnings);
+        printf("Test run totals --- Waved[%d]\n", runResult.numWaived);
+        printf("testmain end --- COST TIME[%lld]\n", (endtime-starttime));
+    }
+    // Preset action of the test case
+    void ActsKhrgles30003TestSuite::SetUp()
+    {
+    }
+    // Cleanup action of the test case
+    void ActsKhrgles30003TestSuite::TearDown()
+    {
+    }
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles30003TestSuite.h b/graphic/vkgl/src/khrgles3/ActsKhrgles30003TestSuite.h
new file mode 100644
index 0000000000000000000000000000000000000000..174469fe18c565e06fe8e9f514f06dc7dfadd656
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles30003TestSuite.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#ifndef KHRGLES3_TESTCASE_H
+#define KHRGLES3_TESTCASE_H
+
+#include <gtest/gtest.h>
+#include "Khrgles3BaseFunc.h"
+
+namespace OHOS {
+    class ActsKhrgles30003TestSuite : public testing::Test {
+    public:
+        static time_t starttime;
+        static time_t endtime;
+        static FuncRunResult runResult;
+    protected:
+        // Preset action of the test suite, which is executed before the first test case
+        static void SetUpTestCase(void);
+        // Test suite cleanup action, which is executed after the last test case
+        static void TearDownTestCase(void);
+        // Preset action of the test case
+        virtual void SetUp();
+        // Cleanup action of the test case
+        virtual void TearDown();
+    };
+} // namespace OHOS
+
+#endif // KHRGLES3_TESTCASE_H
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles30004TestSuite.cpp b/graphic/vkgl/src/khrgles3/ActsKhrgles30004TestSuite.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..02f69c1c465d4f0394764a524cbffe6dba6f75e6
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles30004TestSuite.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include <ctime>
+#include "Khrgles3BaseFunc.h"
+#include "ActsKhrgles30004TestSuite.h"
+
+namespace OHOS {
+    using namespace std;
+    using namespace testing::ext;
+
+    time_t ActsKhrgles30004TestSuite::starttime;
+    time_t ActsKhrgles30004TestSuite::endtime;
+    FuncRunResult ActsKhrgles30004TestSuite::runResult;
+
+    // Preset action of the test suite, which is executed before the first test case
+    void ActsKhrgles30004TestSuite::SetUpTestCase(void)
+    {
+        time(&starttime);
+        RegistPackage();
+        runResult.numPassed = 0;
+        runResult.numFailed = 0;
+        runResult.numNotSupported = 0;
+        runResult.numWarnings = 0;
+        runResult.numWaived = 0;
+    }
+    // Test suite cleanup action, which is executed after the last test case
+    void ActsKhrgles30004TestSuite::TearDownTestCase(void)
+    {
+        time(&endtime);
+        printf("Test run totals --- Passed[%d]\n", runResult.numPassed);
+        printf("Test run totals --- Failed[%d]\n", runResult.numFailed);
+        printf("Test run totals --- Notsupport[%d]\n", runResult.numNotSupported);
+        printf("Test run totals --- Warnings[%d]\n", runResult.numWarnings);
+        printf("Test run totals --- Waved[%d]\n", runResult.numWaived);
+        printf("testmain end --- COST TIME[%lld]\n", (endtime-starttime));
+    }
+    // Preset action of the test case
+    void ActsKhrgles30004TestSuite::SetUp()
+    {
+    }
+    // Cleanup action of the test case
+    void ActsKhrgles30004TestSuite::TearDown()
+    {
+    }
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles30004TestSuite.h b/graphic/vkgl/src/khrgles3/ActsKhrgles30004TestSuite.h
new file mode 100644
index 0000000000000000000000000000000000000000..4d3bb2e64d2db31982faf6bb5e6389835a5a54aa
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles30004TestSuite.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#ifndef KHRGLES3_TESTCASE_H
+#define KHRGLES3_TESTCASE_H
+
+#include <gtest/gtest.h>
+#include "Khrgles3BaseFunc.h"
+
+namespace OHOS {
+    class ActsKhrgles30004TestSuite : public testing::Test {
+    public:
+        static time_t starttime;
+        static time_t endtime;
+        static FuncRunResult runResult;
+    protected:
+        // Preset action of the test suite, which is executed before the first test case
+        static void SetUpTestCase(void);
+        // Test suite cleanup action, which is executed after the last test case
+        static void TearDownTestCase(void);
+        // Preset action of the test case
+        virtual void SetUp();
+        // Cleanup action of the test case
+        virtual void TearDown();
+    };
+} // namespace OHOS
+
+#endif // KHRGLES3_TESTCASE_H
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles30005TestSuite.cpp b/graphic/vkgl/src/khrgles3/ActsKhrgles30005TestSuite.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e5c2298d518379abb9c39c94cb9521a9a164f778
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles30005TestSuite.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include <ctime>
+#include "Khrgles3BaseFunc.h"
+#include "ActsKhrgles30005TestSuite.h"
+
+namespace OHOS {
+    using namespace std;
+    using namespace testing::ext;
+
+    time_t ActsKhrgles30005TestSuite::starttime;
+    time_t ActsKhrgles30005TestSuite::endtime;
+    FuncRunResult ActsKhrgles30005TestSuite::runResult;
+
+    // Preset action of the test suite, which is executed before the first test case
+    void ActsKhrgles30005TestSuite::SetUpTestCase(void)
+    {
+        time(&starttime);
+        RegistPackage();
+        runResult.numPassed = 0;
+        runResult.numFailed = 0;
+        runResult.numNotSupported = 0;
+        runResult.numWarnings = 0;
+        runResult.numWaived = 0;
+    }
+    // Test suite cleanup action, which is executed after the last test case
+    void ActsKhrgles30005TestSuite::TearDownTestCase(void)
+    {
+        time(&endtime);
+        printf("Test run totals --- Passed[%d]\n", runResult.numPassed);
+        printf("Test run totals --- Failed[%d]\n", runResult.numFailed);
+        printf("Test run totals --- Notsupport[%d]\n", runResult.numNotSupported);
+        printf("Test run totals --- Warnings[%d]\n", runResult.numWarnings);
+        printf("Test run totals --- Waved[%d]\n", runResult.numWaived);
+        printf("testmain end --- COST TIME[%lld]\n", (endtime-starttime));
+    }
+    // Preset action of the test case
+    void ActsKhrgles30005TestSuite::SetUp()
+    {
+    }
+    // Cleanup action of the test case
+    void ActsKhrgles30005TestSuite::TearDown()
+    {
+    }
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles30005TestSuite.h b/graphic/vkgl/src/khrgles3/ActsKhrgles30005TestSuite.h
new file mode 100644
index 0000000000000000000000000000000000000000..4c6bef9c8cd4af7dc4cc110efab3e25f36642c48
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles30005TestSuite.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#ifndef KHRGLES3_TESTCASE_H
+#define KHRGLES3_TESTCASE_H
+
+#include <gtest/gtest.h>
+#include "Khrgles3BaseFunc.h"
+
+namespace OHOS {
+    class ActsKhrgles30005TestSuite : public testing::Test {
+    public:
+        static time_t starttime;
+        static time_t endtime;
+        static FuncRunResult runResult;
+    protected:
+        // Preset action of the test suite, which is executed before the first test case
+        static void SetUpTestCase(void);
+        // Test suite cleanup action, which is executed after the last test case
+        static void TearDownTestCase(void);
+        // Preset action of the test case
+        virtual void SetUp();
+        // Cleanup action of the test case
+        virtual void TearDown();
+    };
+} // namespace OHOS
+
+#endif // KHRGLES3_TESTCASE_H
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles3TestSuite.cpp b/graphic/vkgl/src/khrgles3/ActsKhrgles3TestSuite.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f70b6ee16882838dc7611b535c3e5ad4b5eacf9b
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles3TestSuite.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include <ctime>
+#include "Khrgles3BaseFunc.h"
+#include "ActsKhrgles3TestSuite.h"
+
+namespace OHOS {
+    using namespace std;
+    using namespace testing::ext;
+
+    time_t ActsKhrgles3TestSuite::starttime;
+    time_t ActsKhrgles3TestSuite::endtime;
+    FuncRunResult ActsKhrgles3TestSuite::runResult;
+
+    // Preset action of the test suite, which is executed before the first test case
+    void ActsKhrgles3TestSuite::SetUpTestCase(void)
+    {
+        time(&starttime);
+        RegistPackage();
+        runResult.numPassed = 0;
+        runResult.numFailed = 0;
+        runResult.numNotSupported = 0;
+        runResult.numWarnings = 0;
+        runResult.numWaived = 0;
+    }
+    // Test suite cleanup action, which is executed after the last test case
+    void ActsKhrgles3TestSuite::TearDownTestCase(void)
+    {
+        time(&endtime);
+        printf("Test run totals --- Passed[%d]\n", runResult.numPassed);
+        printf("Test run totals --- Failed[%d]\n", runResult.numFailed);
+        printf("Test run totals --- Notsupport[%d]\n", runResult.numNotSupported);
+        printf("Test run totals --- Warnings[%d]\n", runResult.numWarnings);
+        printf("Test run totals --- Waved[%d]\n", runResult.numWaived);
+        printf("testmain end --- COST TIME[%lld]\n", (endtime-starttime));
+    }
+    // Preset action of the test case
+    void ActsKhrgles3TestSuite::SetUp()
+    {
+    }
+    // Cleanup action of the test case
+    void ActsKhrgles3TestSuite::TearDown()
+    {
+    }
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/ActsKhrgles3TestSuite.h b/graphic/vkgl/src/khrgles3/ActsKhrgles3TestSuite.h
new file mode 100644
index 0000000000000000000000000000000000000000..edc084f2bd3758685a9ce0a77a71902725d1376d
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/ActsKhrgles3TestSuite.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#ifndef KHRGLES3_TESTCASE_H
+#define KHRGLES3_TESTCASE_H
+
+#include <gtest/gtest.h>
+#include "Khrgles3BaseFunc.h"
+
+namespace OHOS {
+    class ActsKhrgles3TestSuite : public testing::Test {
+    public:
+        static time_t starttime;
+        static time_t endtime;
+        static FuncRunResult runResult;
+    protected:
+        // Preset action of the test suite, which is executed before the first test case
+        static void SetUpTestCase(void);
+        // Test suite cleanup action, which is executed after the last test case
+        static void TearDownTestCase(void);
+        // Preset action of the test case
+        virtual void SetUp();
+        // Cleanup action of the test case
+        virtual void TearDown();
+    };
+} // namespace OHOS
+
+#endif // KHRGLES3_TESTCASE_H
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/Khrgles3BaseFunc.cpp b/graphic/vkgl/src/khrgles3/Khrgles3BaseFunc.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a07c9413e8c6605b4537cc3e82a19b8e18d55a69
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/Khrgles3BaseFunc.cpp
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include "tcuDefs.hpp"
+#include "tcuCommandLine.hpp"
+#include "tcuPlatform.hpp"
+#include "ActsApp.h"
+#include "tcuResource.hpp"
+#include "tcuTestLog.hpp"
+#include "tcuTestSessionExecutor.hpp"
+#include "deUniquePtr.hpp"
+
+#include "external/openglcts/modules/common/glcConfigPackage.hpp"
+#include "external/openglcts/modules/common/glcTestPackage.hpp"
+#include "external/openglcts/modules/gles2/es2cTestPackage.hpp"
+#include "external/openglcts/modules/gles32/es32cTestPackage.hpp"
+#include "external/openglcts/modules/gles31/es31cTestPackage.hpp"
+#include "external/openglcts/modules/gles3/es3cTestPackage.hpp"
+#include "external/openglcts/modules/glesext/esextcTestPackage.hpp"
+#include "external/openglcts/modules/common/glcSingleConfigTestPackage.hpp"
+#include "modules/gles2/tes2TestPackage.hpp"
+#include "modules/gles3/tes3TestPackage.hpp"
+#include "modules/gles31/tes31TestPackage.hpp"
+
+#include "ohos_context_i.h"
+#include "Khrgles3BaseFunc.h"
+
+static tcu::TestPackage* createKhrgles3Package(tcu::TestContext& testCtx)
+{
+    return new es3cts::ES30TestPackage(testCtx, "KHR-KHRGLES3");
+}
+void RegistPackage(void)
+{
+    tcu::TestPackageRegistry *registry = tcu::TestPackageRegistry::getSingleton();
+    registry->registerPackage("KHR-GLES3", createKhrgles3Package);
+}
+
+FuncRunResult RunTestKHRGLES(int argc, const char** argv)
+{
+    FuncRunResult runResult;
+    try {
+        tcu::CommandLine cmdLine(argc, argv);
+        tcu::DirArchive archive(cmdLine.getArchiveDir());
+        
+        de::UniquePtr<tcu::Platform> platform(createOhosPlatform());
+        de::UniquePtr<tcu::ActsApp> app(new tcu::ActsApp(*platform, archive, tcutestlog, cmdLine));
+        for (;;) {
+            if (!app->iterate()) {
+                break;
+            };
+        };
+        runResult.isComplete = app->getResult().isComplete;
+        runResult.numPassed = app->getResult().numPassed;
+        runResult.numExecuted = app->getResult().numExecuted;
+        runResult.numFailed = app->getResult().numFailed;
+        runResult.numNotSupported = app->getResult().numNotSupported;
+        runResult.numWarnings = app->getResult().numWarnings;
+        runResult.numWaived = app->getResult().numWaived;
+    } catch (const std::exception &e) {
+        tcu::die("%s", e.what());
+    };
+    return runResult;
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/Khrgles3BaseFunc.h b/graphic/vkgl/src/khrgles3/Khrgles3BaseFunc.h
new file mode 100644
index 0000000000000000000000000000000000000000..0845a01e3c644d0294bd57ae2fe4e17cbe1812d8
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/Khrgles3BaseFunc.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#ifndef KHRGLES3_FUNC_H
+#define KHRGLES3_FUNC_H
+
+struct FuncRunResult {
+    int numExecuted; // !< Total number of cases executed.
+    int numPassed;     // !< Number of cases passed.
+    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.
+};
+
+void RegistPackage(void);
+FuncRunResult RunTestKHRGLES(int argc, const char** argv);
+
+#endif // KHRGLES3_FUNC_H
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/build0001/BUILD.gn b/graphic/vkgl/src/khrgles3/build0001/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..36c2ed03f70f070bdbbabc26f752443fe6089711
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/build0001/BUILD.gn
@@ -0,0 +1,88 @@
+# Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+# 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.
+
+import("//test/xts/acts/graphic/vkglcts/comm.gni")
+
+config("deqp_platform_ohos_config") {
+  cflags_cc = deqp_common_cflags_cc
+
+  cflags_cc += [
+    # "-Wno-conversion",
+    # "-Wno-unused-function",
+    "-Wno-unused-parameter",
+  ]
+
+  defines = deqp_common_defines
+
+  # defines -=["DE_PTR_SIZE=8"]
+  defines += [
+    "DE_PTR_SIZE=4",
+    "_XOPEN_SOURCE=600",
+  ]
+}
+
+ohos_static_library("libkhrgles3func0001") {
+  sources = common_src
+  sources += [ "../Khrgles3BaseFunc.cpp" ]
+
+  include_dirs = common_include
+  deps = common_depends
+  external_deps = [
+    "hilog_native:libhilog",
+    "multimedia_image_standard:image_native",
+  ]
+  lib_dirs = [ "//third_party/VK-GL-CTS/outlibs" ]
+  libs = [ "png" ]
+  configs = [ ":deqp_platform_ohos_config" ]
+  public_deps = [ "//foundation/ace/ace_engine/build/external_config/flutter/skia:ace_skia_ohos" ]
+}
+
+ohos_moduletest_suite("ActsKhrgles3TestSuite0001") {
+  sources = [
+    "../ActsKhrgles30001TestSuite.cpp",
+    "../shaders/Khrgles3declarations_declarationsTestCase.cpp",
+    "../shaders/Khrgles3fragdepth_compareTestCase.cpp",
+    "../shaders/Khrgles3fragdepth_writeTestCase.cpp",
+    "../shaders/Khrgles3indexing_matrix_subscriptTestCase.cpp",
+    "../shaders/Khrgles3indexing_tmp_arrayTestCase.cpp",
+    "../shaders/Khrgles3indexing_uniform_arrayTestCase.cpp",
+    "../shaders/Khrgles3indexing_varying_arrayTestCase.cpp",
+    "../shaders/Khrgles3indexing_vector_subscriptTestCase.cpp",
+    "../shaders/Khrgles3loops_do_while_constant_iterationsTestCase.cpp",
+    "../shaders/Khrgles3loops_do_while_dynamic_iterationsTestCase.cpp",
+    "../shaders/Khrgles3loops_do_while_uniform_iterationsTestCase.cpp",
+    "../shaders/Khrgles3loops_for_constant_iterationsTestCase.cpp",
+    "../shaders/Khrgles3loops_for_dynamic_iterationsTestCase.cpp",
+    "../shaders/Khrgles3loops_for_uniform_iterationsTestCase.cpp",
+    "../shaders/Khrgles3loops_while_constant_iterationsTestCase.cpp",
+    "../shaders/Khrgles3loops_while_dynamic_iterationsTestCase.cpp",
+    "../shaders/Khrgles3loops_while_uniform_iterationsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_basicTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_commentsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_definitionsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_function_definitionsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_function_redefinitionsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_invalid_definitionsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_invalid_function_definitionsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_invalid_redefinitionsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_line_continuationTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_object_redefinitionsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_recursionTestCase.cpp",
+  ]
+
+  include_dirs = [ "//test/xts/acts/graphic/vkglcts/src" ]
+
+  deps = [ ":libkhrgles3func0001" ]
+
+  cflags = [ "-Wno-error" ]
+}
diff --git a/graphic/vkgl/src/khrgles3/build0001/Test.json b/graphic/vkgl/src/khrgles3/build0001/Test.json
new file mode 100644
index 0000000000000000000000000000000000000000..c00294bb4fee2108087fa512e5179a746ce44bdb
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/build0001/Test.json
@@ -0,0 +1,38 @@
+{
+    "description": "Config for ActsKhrgles3TestSuite0001 test cases",
+    "driver": {
+        "module-name": "ActsKhrgles3TestSuite0001",
+        "native-test-timeout": "120000",
+        "native-test-device-path": "/data/local/tmp",
+        "runtime-hint": "100s",
+        "type": "CppTest"
+    },
+    "kits": [
+        {
+            "pre-push" : [
+            ],
+            "post-push" : [
+                "chmod -R 777 /data/local/tmp/*",
+                "mkdir /data/local/tmp/gl_cts",
+                "tar zxvf /data/local/tmp/gl_cts.tar.gz -C /data/local/tmp/gl_cts",
+                "cp -r /data/local/tmp/gl_cts/data/gles2 /data/local/tmp",
+                "cp -r /data/local/tmp/gl_cts/data/gles3 /data/local/tmp",
+                "cp -r /data/local/tmp/gl_cts/data/gles31 /data/local/tmp"
+            ],
+            "push": [
+                "ActsKhrgles3TestSuite0001->/data/local/tmp/ActsKhrgles3TestSuite0001",
+                "../../../common/common/librosen_context.z.so->/system/lib",
+                "gl_cts.tar.gz->/data/local/tmp/gl_cts.tar.gz"
+            ],
+            "type": "PushKit"
+        },
+        {
+            "type": "ShellKit",
+            "run-command": [
+                "remount",
+                "mkdir /data/test",
+                "cd /data/local/tmp"
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/build0002/BUILD.gn b/graphic/vkgl/src/khrgles3/build0002/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..9f31b4ef564ea8b6a7727d9022de62a78fe01935
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/build0002/BUILD.gn
@@ -0,0 +1,88 @@
+# Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+# 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.
+
+import("//test/xts/acts/graphic/vkglcts/comm.gni")
+
+config("deqp_platform_ohos_config") {
+  cflags_cc = deqp_common_cflags_cc
+
+  cflags_cc += [
+    # "-Wno-conversion",
+    # "-Wno-unused-function",
+    "-Wno-unused-parameter",
+  ]
+
+  defines = deqp_common_defines
+
+  # defines -=["DE_PTR_SIZE=8"]
+  defines += [
+    "DE_PTR_SIZE=4",
+    "_XOPEN_SOURCE=600",
+  ]
+}
+
+ohos_static_library("libkhrgles3func0002") {
+  sources = common_src
+  sources += [ "../Khrgles3BaseFunc.cpp" ]
+
+  include_dirs = common_include
+  deps = common_depends
+  external_deps = [
+    "hilog_native:libhilog",
+    "multimedia_image_standard:image_native",
+  ]
+  lib_dirs = [ "//third_party/VK-GL-CTS/outlibs" ]
+  libs = [ "png" ]
+  configs = [ ":deqp_platform_ohos_config" ]
+  public_deps = [ "//foundation/ace/ace_engine/build/external_config/flutter/skia:ace_skia_ohos" ]
+}
+
+ohos_moduletest_suite("ActsKhrgles3TestSuite0002") {
+  sources = [
+    "../ActsKhrgles30002TestSuite.cpp",
+    "../shaders/Khrgles3name_hiding_basicTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_builtinTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_conditional_inclusionTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_conditionalsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_directiveTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_expressionsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_extensionsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_invalid_conditionalsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_invalid_expressionsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_invalid_opsTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_operator_precedenceTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_pragmasTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_predefined_macrosTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_semanticTestCase.cpp",
+    "../shaders/Khrgles3preprocessor_undefined_identifiersTestCase.cpp",
+    "../shaders/Khrgles3shaders_literal_parsingTestCase.cpp",
+    "../shaders/Khrgles3single_basic_array_packedTestCase.cpp",
+    "../shaders/Khrgles3single_basic_array_sharedTestCase.cpp",
+    "../shaders/Khrgles3single_basic_array_std140TestCase.cpp",
+    "../shaders/Khrgles3single_basic_type_packedTestCase.cpp",
+    "../shaders/Khrgles3single_basic_type_sharedTestCase.cpp",
+    "../shaders/Khrgles3single_basic_type_std140TestCase.cpp",
+    "../shaders/Khrgles3struct_localTestCase.cpp",
+    "../shaders/Khrgles3struct_uniformTestCase.cpp",
+    "../shaders/Khrgles3uniform_block_single_nested_structTestCase.cpp",
+    "../shaders/Khrgles3uniform_block_single_nested_struct_arrayTestCase.cpp",
+    "../shaders/Khrgles3uniform_block_single_structTestCase.cpp",
+    "../shaders/Khrgles3uniform_block_single_struct_arrayTestCase.cpp",
+  ]
+
+  include_dirs = [ "//test/xts/acts/graphic/vkglcts/src" ]
+
+  deps = [ ":libkhrgles3func0002" ]
+
+  cflags = [ "-Wno-error" ]
+}
diff --git a/graphic/vkgl/src/khrgles3/build0002/Test.json b/graphic/vkgl/src/khrgles3/build0002/Test.json
new file mode 100644
index 0000000000000000000000000000000000000000..1212ecabe0267d8dbeab69941b34a74ec93ef52a
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/build0002/Test.json
@@ -0,0 +1,38 @@
+{
+    "description": "Config for ActsKhrgles3TestSuite0002 test cases",
+    "driver": {
+        "module-name": "ActsKhrgles3TestSuite0002",
+        "native-test-timeout": "120000",
+        "native-test-device-path": "/data/local/tmp",
+        "runtime-hint": "100s",
+        "type": "CppTest"
+    },
+    "kits": [
+        {
+            "pre-push" : [
+            ],
+            "post-push" : [
+                "chmod -R 777 /data/local/tmp/*",
+                "mkdir /data/local/tmp/gl_cts",
+                "tar zxvf /data/local/tmp/gl_cts.tar.gz -C /data/local/tmp/gl_cts",
+                "cp -r /data/local/tmp/gl_cts/data/gles2 /data/local/tmp",
+                "cp -r /data/local/tmp/gl_cts/data/gles3 /data/local/tmp",
+                "cp -r /data/local/tmp/gl_cts/data/gles31 /data/local/tmp"
+            ],
+            "push": [
+                "ActsKhrgles3TestSuite0002->/data/local/tmp/ActsKhrgles3TestSuite0002",
+                "../../../common/common/librosen_context.z.so->/system/lib",
+                "gl_cts.tar.gz->/data/local/tmp/gl_cts.tar.gz"
+            ],
+            "type": "PushKit"
+        },
+        {
+            "type": "ShellKit",
+            "run-command": [
+                "remount",
+                "mkdir /data/test",
+                "cd /data/local/tmp"
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/build0003/BUILD.gn b/graphic/vkgl/src/khrgles3/build0003/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..102ecd8b07ed51805b175dee65cad2184aeb8d9c
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/build0003/BUILD.gn
@@ -0,0 +1,85 @@
+# Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+# 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.
+
+import("//test/xts/acts/graphic/vkglcts/comm.gni")
+
+config("deqp_platform_ohos_config") {
+  cflags_cc = deqp_common_cflags_cc
+
+  cflags_cc += [
+    # "-Wno-conversion",
+    # "-Wno-unused-function",
+    "-Wno-unused-parameter",
+  ]
+
+  defines = deqp_common_defines
+
+  # defines -=["DE_PTR_SIZE=8"]
+  defines += [
+    "DE_PTR_SIZE=4",
+    "_XOPEN_SOURCE=600",
+  ]
+}
+
+ohos_static_library("libkhrgles3func0003") {
+  sources = common_src
+  sources += [ "../Khrgles3BaseFunc.cpp" ]
+
+  include_dirs = common_include
+  deps = common_depends
+  external_deps = [
+    "hilog_native:libhilog",
+    "multimedia_image_standard:image_native",
+  ]
+  lib_dirs = [ "//third_party/VK-GL-CTS/outlibs" ]
+  libs = [ "png" ]
+  configs = [ ":deqp_platform_ohos_config" ]
+  public_deps = [ "//foundation/ace/ace_engine/build/external_config/flutter/skia:ace_skia_ohos" ]
+}
+
+ohos_moduletest_suite("ActsKhrgles3TestSuite0003") {
+  sources = [
+    "../ActsKhrgles30003TestSuite.cpp",
+    "../shaders/Khrgles3instance_array_basic_type_packedTestCase.cpp",
+    "../shaders/Khrgles3instance_array_basic_type_sharedTestCase.cpp",
+    "../shaders/Khrgles3instance_array_basic_type_std140TestCase.cpp",
+    "../shaders/Khrgles3multi_basic_types_per_block_bufferTestCase.cpp",
+    "../shaders/Khrgles3multi_basic_types_single_bufferTestCase.cpp",
+    "../shaders/Khrgles3multi_nested_struct_per_block_bufferTestCase.cpp",
+    "../shaders/Khrgles3multi_nested_struct_single_bufferTestCase.cpp",
+    "../shaders/Khrgles3random_all_per_block_buffersTestCase.cpp",
+    "../shaders/Khrgles3random_all_shared_bufferTestCase.cpp",
+    "../shaders/Khrgles3random_basic_arraysTestCase.cpp",
+    "../shaders/Khrgles3random_basic_instance_arraysTestCase.cpp",
+    "../shaders/Khrgles3random_basic_typesTestCase.cpp",
+    "../shaders/Khrgles3random_nested_structsTestCase.cpp",
+    "../shaders/Khrgles3random_nested_structs_arraysTestCase.cpp",
+    "../shaders/Khrgles3random_nested_structs_arrays_instance_arraysTestCase.cpp",
+    "../shaders/Khrgles3random_nested_structs_instance_arraysTestCase.cpp",
+    "../shaders/Khrgles3random_scalar_typesTestCase.cpp",
+    "../shaders/Khrgles3random_vector_typesTestCase.cpp",
+    "../shaders/Khrgles3shaders_aggressive_optimizationsTestCase.cpp",
+    "../shaders/Khrgles3shaders_glsl_constructorsTestCase.cpp",
+    "../shaders/Khrgles3shaders_negativeTestCase.cpp",
+    "../shaders/Khrgles3shaders_shader_integer_mixTestCase.cpp",
+    "../shaders/Khrgles3uniform_block_commonTestCase.cpp",
+    "../texture_filter_anisotropic/Khrgles3KHR-GLES3_texture_filter_anisotropicTestCase.cpp",
+    "../texture_repeat_mode/Khrgles3KHR-GLES3_texture_repeat_modeTestCase.cpp",
+  ]
+
+  include_dirs = [ "//test/xts/acts/graphic/vkglcts/src" ]
+
+  deps = [ ":libkhrgles3func0003" ]
+
+  cflags = [ "-Wno-error" ]
+}
diff --git a/graphic/vkgl/src/khrgles3/build0003/Test.json b/graphic/vkgl/src/khrgles3/build0003/Test.json
new file mode 100644
index 0000000000000000000000000000000000000000..e13048c8d9f572f36d7dfffefacb30971b0f1ee8
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/build0003/Test.json
@@ -0,0 +1,38 @@
+{
+    "description": "Config for ActsKhrgles3TestSuite0003 test cases",
+    "driver": {
+        "module-name": "ActsKhrgles3TestSuite0003",
+        "native-test-timeout": "120000",
+        "native-test-device-path": "/data/local/tmp",
+        "runtime-hint": "100s",
+        "type": "CppTest"
+    },
+    "kits": [
+        {
+            "pre-push" : [
+            ],
+            "post-push" : [
+                "chmod -R 777 /data/local/tmp/*",
+                "mkdir /data/local/tmp/gl_cts",
+                "tar zxvf /data/local/tmp/gl_cts.tar.gz -C /data/local/tmp/gl_cts",
+                "cp -r /data/local/tmp/gl_cts/data/gles2 /data/local/tmp",
+                "cp -r /data/local/tmp/gl_cts/data/gles3 /data/local/tmp",
+                "cp -r /data/local/tmp/gl_cts/data/gles31 /data/local/tmp"
+            ],
+            "push": [
+                "ActsKhrgles3TestSuite0003->/data/local/tmp/ActsKhrgles3TestSuite0003",
+                "../../../common/common/librosen_context.z.so->/system/lib",
+                "gl_cts.tar.gz->/data/local/tmp/gl_cts.tar.gz"
+            ],
+            "type": "PushKit"
+        },
+        {
+            "type": "ShellKit",
+            "run-command": [
+                "remount",
+                "mkdir /data/test",
+                "cd /data/local/tmp"
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/build0004/BUILD.gn b/graphic/vkgl/src/khrgles3/build0004/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..0ac32566182d0dc4617cca65e27941dde2064d1e
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/build0004/BUILD.gn
@@ -0,0 +1,83 @@
+# Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+# 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.
+
+import("//test/xts/acts/graphic/vkglcts/comm.gni")
+
+config("deqp_platform_ohos_config") {
+  cflags_cc = deqp_common_cflags_cc
+
+  cflags_cc += [
+    # "-Wno-conversion",
+    # "-Wno-unused-function",
+    "-Wno-unused-parameter",
+  ]
+
+  defines = deqp_common_defines
+
+  # defines -=["DE_PTR_SIZE=8"]
+  defines += [
+    "DE_PTR_SIZE=4",
+    "_XOPEN_SOURCE=600",
+  ]
+}
+
+ohos_static_library("libkhrgles3func0004") {
+  sources = common_src
+  sources += [ "../Khrgles3BaseFunc.cpp" ]
+
+  include_dirs = common_include
+  deps = common_depends
+  external_deps = [
+    "hilog_native:libhilog",
+    "multimedia_image_standard:image_native",
+  ]
+  lib_dirs = [ "//third_party/VK-GL-CTS/outlibs" ]
+  libs = [ "png" ]
+  configs = [ ":deqp_platform_ohos_config" ]
+  public_deps = [ "//foundation/ace/ace_engine/build/external_config/flutter/skia:ace_skia_ohos" ]
+}
+
+ohos_moduletest_suite("ActsKhrgles3TestSuite0004") {
+  sources = [
+    "../ActsKhrgles30004TestSuite.cpp",
+    "../copy_tex_image_conversions/Khrgles3copy_tex_image_conversions_forbiddenTestCase.cpp",
+    "../copy_tex_image_conversions/Khrgles3copy_tex_image_conversions_requiredTestCase.cpp",
+    "../core/Khrgles3core_constant_expressionsTestCase.cpp",
+    "../core/Khrgles3core_nearest_edgeTestCase.cpp",
+    "../core/Khrgles3core_shader_macrosTestCase.cpp",
+    "../core/Khrgles3internalformat_copy_tex_imageTestCase.cpp",
+    "../core/Khrgles3internalformat_renderbufferTestCase.cpp",
+    "../core/Khrgles3internalformat_texture2dTestCase.cpp",
+    "../exposed_extensions/Khrgles3KHR-GLES3_exposed_extensionsTestCase.cpp",
+    "../framebuffer_completeness/Khrgles3KHR-GLES3_framebuffer_completenessTestCase.cpp",
+    "../packed_depth_stencil/Khrgles3packed_depth_stencil_blitTestCase.cpp",
+    "../packed_depth_stencil/Khrgles3packed_depth_stencil_clear_bufferTestCase.cpp",
+    "../packed_depth_stencil/Khrgles3packed_depth_stencil_renderbuffersTestCase.cpp",
+    "../packed_depth_stencil/Khrgles3packed_depth_stencil_stencil_texturingTestCase.cpp",
+    "../packed_depth_stencil/Khrgles3packed_depth_stencil_validate_errorsTestCase.cpp",
+    "../packed_depth_stencil/Khrgles3packed_depth_stencil_verify_mixed_attachmentsTestCase.cpp",
+    "../packed_depth_stencil/Khrgles3packed_depth_stencil_verify_parametersTestCase.cpp",
+    "../packed_depth_stencil/Khrgles3packed_depth_stencil_verify_partial_attachmentsTestCase.cpp",
+    "../packed_depth_stencil/Khrgles3packed_depth_stencil_verify_read_pixelsTestCase.cpp",
+    "../packed_pixels/Khrgles3packed_pixels_pbo_rectangleTestCase.cpp",
+    "../packed_pixels/Khrgles3packed_pixels_rectangleTestCase.cpp",
+    "../packed_pixels/Khrgles3packed_pixels_varied_rectangleTestCase.cpp",
+    "../parallel_shader_compile/Khrgles3KHR-GLES3_parallel_shader_compileTestCase.cpp",
+  ]
+
+  include_dirs = [ "//test/xts/acts/graphic/vkglcts/src" ]
+
+  deps = [ ":libkhrgles3func0004" ]
+
+  cflags = [ "-Wno-error" ]
+}
diff --git a/graphic/vkgl/src/khrgles3/build0004/Test.json b/graphic/vkgl/src/khrgles3/build0004/Test.json
new file mode 100644
index 0000000000000000000000000000000000000000..9c1b33fa2131277fe099849e22ec64f797c9364b
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/build0004/Test.json
@@ -0,0 +1,38 @@
+{
+    "description": "Config for ActsKhrgles3TestSuite0004 test cases",
+    "driver": {
+        "module-name": "ActsKhrgles3TestSuite0004",
+        "native-test-timeout": "120000",
+        "native-test-device-path": "/data/local/tmp",
+        "runtime-hint": "100s",
+        "type": "CppTest"
+    },
+    "kits": [
+        {
+            "pre-push" : [
+            ],
+            "post-push" : [
+                "chmod -R 777 /data/local/tmp/*",
+                "mkdir /data/local/tmp/gl_cts",
+                "tar zxvf /data/local/tmp/gl_cts.tar.gz -C /data/local/tmp/gl_cts",
+                "cp -r /data/local/tmp/gl_cts/data/gles2 /data/local/tmp",
+                "cp -r /data/local/tmp/gl_cts/data/gles3 /data/local/tmp",
+                "cp -r /data/local/tmp/gl_cts/data/gles31 /data/local/tmp"
+            ],
+            "push": [
+                "ActsKhrgles3TestSuite0004->/data/local/tmp/ActsKhrgles3TestSuite0004",
+                "../../../common/common/librosen_context.z.so->/system/lib",
+                "gl_cts.tar.gz->/data/local/tmp/gl_cts.tar.gz"
+            ],
+            "type": "PushKit"
+        },
+        {
+            "type": "ShellKit",
+            "run-command": [
+                "remount",
+                "mkdir /data/test",
+                "cd /data/local/tmp"
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/build0005/BUILD.gn b/graphic/vkgl/src/khrgles3/build0005/BUILD.gn
new file mode 100644
index 0000000000000000000000000000000000000000..3f1d219bd5fb77cd6f6b5e7abd65291d8e811a04
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/build0005/BUILD.gn
@@ -0,0 +1,61 @@
+# Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+# 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.
+
+import("//test/xts/acts/graphic/vkglcts/comm.gni")
+
+config("deqp_platform_ohos_config") {
+  cflags_cc = deqp_common_cflags_cc
+
+  cflags_cc += [
+    # "-Wno-conversion",
+    # "-Wno-unused-function",
+    "-Wno-unused-parameter",
+  ]
+
+  defines = deqp_common_defines
+
+  # defines -=["DE_PTR_SIZE=8"]
+  defines += [
+    "DE_PTR_SIZE=4",
+    "_XOPEN_SOURCE=600",
+  ]
+}
+
+ohos_static_library("libkhrgles3func0005") {
+  sources = common_src
+  sources += [ "../Khrgles3BaseFunc.cpp" ]
+
+  include_dirs = common_include
+  deps = common_depends
+  external_deps = [
+    "hilog_native:libhilog",
+    "multimedia_image_standard:image_native",
+  ]
+  lib_dirs = [ "//third_party/VK-GL-CTS/outlibs" ]
+  libs = [ "png" ]
+  configs = [ ":deqp_platform_ohos_config" ]
+  public_deps = [ "//foundation/ace/ace_engine/build/external_config/flutter/skia:ace_skia_ohos" ]
+}
+
+ohos_moduletest_suite("ActsKhrgles3TestSuite0005") {
+  sources = [
+    "../ActsKhrgles30005TestSuite.cpp",
+    "../number_parsing/Khrgles3KHR-GLES3_number_parsingTestCase.cpp",
+  ]
+
+  include_dirs = [ "//test/xts/acts/graphic/vkglcts/src" ]
+
+  deps = [ ":libkhrgles3func0005" ]
+
+  cflags = [ "-Wno-error" ]
+}
diff --git a/graphic/vkgl/src/khrgles3/build0005/Test.json b/graphic/vkgl/src/khrgles3/build0005/Test.json
new file mode 100644
index 0000000000000000000000000000000000000000..b0cc8112cfdcdd81173f5937f3b87efd2f61cd7b
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/build0005/Test.json
@@ -0,0 +1,38 @@
+{
+    "description": "Config for ActsKhrgles3TestSuite0005 test cases",
+    "driver": {
+        "module-name": "ActsKhrgles3TestSuite0005",
+        "native-test-timeout": "120000",
+        "native-test-device-path": "/data/local/tmp",
+        "runtime-hint": "100s",
+        "type": "CppTest"
+    },
+    "kits": [
+        {
+            "pre-push" : [
+            ],
+            "post-push" : [
+                "chmod -R 777 /data/local/tmp/*",
+                "mkdir /data/local/tmp/gl_cts",
+                "tar zxvf /data/local/tmp/gl_cts.tar.gz -C /data/local/tmp/gl_cts",
+                "cp -r /data/local/tmp/gl_cts/data/gles2 /data/local/tmp",
+                "cp -r /data/local/tmp/gl_cts/data/gles3 /data/local/tmp",
+                "cp -r /data/local/tmp/gl_cts/data/gles31 /data/local/tmp"
+            ],
+            "push": [
+                "ActsKhrgles3TestSuite0005->/data/local/tmp/ActsKhrgles3TestSuite0005",
+                "../../../common/common/librosen_context.z.so->/system/lib",
+                "gl_cts.tar.gz->/data/local/tmp/gl_cts.tar.gz"
+            ],
+            "type": "PushKit"
+        },
+        {
+            "type": "ShellKit",
+            "run-command": [
+                "remount",
+                "mkdir /data/test",
+                "cd /data/local/tmp"
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/graphic/vkgl/src/khrgles3/exposed_extensions/Khrgles3KHR-GLES3_exposed_extensionsTestCase.cpp b/graphic/vkgl/src/khrgles3/exposed_extensions/Khrgles3KHR-GLES3_exposed_extensionsTestCase.cpp
index 7a9ab3cc624dc95141106913dcf482a9809af778..220eaf39e8913ad090e1f79271697b6ba421986e 100644
--- a/graphic/vkgl/src/khrgles3/exposed_extensions/Khrgles3KHR-GLES3_exposed_extensionsTestCase.cpp
+++ b/graphic/vkgl/src/khrgles3/exposed_extensions/Khrgles3KHR-GLES3_exposed_extensionsTestCase.cpp
@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 
-#include <climits>
 #include <gtest/gtest.h>
 #include "../Khrgles3BaseFunc.h"
 #include "../ActsKhrgles30004TestSuite.h"
diff --git a/graphic/vkgl/src/khrgles3/framebuffer_completeness/Khrgles3KHR-GLES3_framebuffer_completenessTestCase.cpp b/graphic/vkgl/src/khrgles3/framebuffer_completeness/Khrgles3KHR-GLES3_framebuffer_completenessTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..14bbb4ccde7b9b7dede69e0b98ce3814ec7f7c3f
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/framebuffer_completeness/Khrgles3KHR-GLES3_framebuffer_completenessTestCase.cpp
@@ -0,0 +1,400 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30004TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003908, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003908 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completene"
+        "ss.incomplete_missing_attachment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003908 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003908 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003909, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003909 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completen"
+        "ess.incomplete_image_zero_width",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003909 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003909 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003910, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003910 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completen"
+        "ess.incomplete_image_zero_height",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003910 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003910 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003911, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003911 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completenes"
+        "s.incomplete_texture_3d_layer_oob",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003911 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003911 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003912, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003912 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completenes"
+        "s.incomplete_texture_2d_layer_oob",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003912 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003912 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003913, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003913 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completeness"
+        ".incomplete_texture_2d_mm_layer_oob",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003913 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003913 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003914, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003914 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completeness.mut"
+        "able_nbl_texture_expect_mipmap_complete",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003914 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003914 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003915, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003915 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completeness.mu"
+        "table_nbl_texture_expect_cube_complete",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003915 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003915 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003916, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003916 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completeness"
+        ".expect_renderable_internal_format",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003916 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003916 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003917, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003917 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completenes"
+        "s.all_rbos_expect_same_numsamples",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003917 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003917 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003918, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003918 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completeness.r"
+        "bo_and_texture_expect_zero_numsamples",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003918 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003918 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003919, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003919 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_com"
+        "pleteness.status_tracking",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003919 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003919 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003920, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003920 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completeness.mu"
+        "table_texture_missing_attachment_level",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003920 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003920 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003921, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003921 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.framebuffer_completeness.imm"
+        "utable_texture_any_level_as_attachment",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003921 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003921 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/number_parsing/Khrgles3KHR-GLES3_number_parsingTestCase.cpp b/graphic/vkgl/src/khrgles3/number_parsing/Khrgles3KHR-GLES3_number_parsingTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..770d54554b4bd476b405ae814775bcbd4e1882b9
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/number_parsing/Khrgles3KHR-GLES3_number_parsingTestCase.cpp
@@ -0,0 +1,508 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30005TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004062, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004062 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.unsigned_"
+        "integer_above_signed_range_decimal",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004062 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004062 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004063, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004063 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.unsigned"
+        "_integer_above_signed_range_base8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004063 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004063 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004064, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004064 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.unsigned"
+        "_integer_above_signed_range_base16",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004064 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004064 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004065, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004065 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.unsigned_integer"
+        "_smallest_value_above_signed_range_decimal",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004065 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004065 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004066, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004066 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.unsigned_intege"
+        "r_smallest_value_above_signed_range_base8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004066 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004066 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004067, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004067 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.unsigned_integer"
+        "_smallest_value_above_signed_range_base16",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004067 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004067 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004068, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004068 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.unsi"
+        "gned_integer_max_value_decimal",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004068 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004068 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004069, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004069 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.uns"
+        "igned_integer_max_value_base8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004069 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004069 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004070, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004070 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.unsi"
+        "gned_integer_max_value_base16",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004070 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004070 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004071, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004071 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.unsigne"
+        "d_integer_too_large_value_invalid",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004071 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004071 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004072, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004072 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.unsigne"
+        "d_integer_negative_value_as_uint",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004072 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004072 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004073, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004073 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.fl"
+        "oat_out_of_range_as_infinity",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004073 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004073 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004074, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004074 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing."
+        "float_out_of_range_as_zero",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004074 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004074 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004075, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004075 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.float_no_limi"
+        "t_on_number_of_digits_positive_exponent",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004075 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004075 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004076, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004076 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.float_no_limi"
+        "t_on_number_of_digits_negative_exponent",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004076 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004076 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004077, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004077 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.float_slightly_o"
+        "ut_of_range_exponent_as_positive_infinity",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004077 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004077 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004078, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004078 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.float"
+        "_overflow_to_positive_infinity",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004078 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004078 end";
+}
+
+static HWTEST_F(ActsKhrgles30005TestSuite, TestCase_004079, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_004079 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.number_parsing.float"
+        "_overflow_to_negative_infinity",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30005TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30005TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30005TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30005TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30005TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_004079 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_004079 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_blitTestCase.cpp b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_blitTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e683923cf91531d5c4e5d0ca2c1d13367c5c9e9b
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_blitTestCase.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30004TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003904, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003904 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_ste"
+        "ncil.blit.depth24_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003904 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003904 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003905, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003905 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_ste"
+        "ncil.blit.depth32f_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003905 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003905 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_clear_bufferTestCase.cpp b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_clear_bufferTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f3362d27deb9a124a2dcbb26007eb2c757bdca86
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_clear_bufferTestCase.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30004TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003902, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003902 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil"
+        ".clear_buffer.depth24_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003902 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003902 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003903, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003903 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil"
+        ".clear_buffer.depth32f_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003903 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003903 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_renderbuffersTestCase.cpp b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_renderbuffersTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..504f0be531a94e2a7df641cbe10620c190eb72d8
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_renderbuffersTestCase.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30004TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003900, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003900 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil"
+        ".renderbuffers.depth24_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003900 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003900 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003901, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003901 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil."
+        "renderbuffers.depth32f_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003901 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003901 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_stencil_texturingTestCase.cpp b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_stencil_texturingTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f74c0f04637a6f874937c03921d8ecee9473b307
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_stencil_texturingTestCase.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30004TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003906, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003906 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil.s"
+        "tencil_texturing.depth24_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003906 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003906 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003907, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003907 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil.st"
+        "encil_texturing.depth32f_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003907 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003907 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_validate_errorsTestCase.cpp b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_validate_errorsTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..4b87491485d0887b830f8089908e666a97e980f1
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_validate_errorsTestCase.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30004TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003890, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003890 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil."
+        "validate_errors.depth24_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003890 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003890 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003891, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003891 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil.v"
+        "alidate_errors.depth32f_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003891 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003891 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_mixed_attachmentsTestCase.cpp b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_mixed_attachmentsTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..48daa2fd9305e28ac2473e611f3a89e7d8658b0a
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_mixed_attachmentsTestCase.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30004TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003896, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003896 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil.verif"
+        "y_mixed_attachments.depth24_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003896 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003896 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003897, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003897 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil.verif"
+        "y_mixed_attachments.depth32f_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003897 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003897 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_parametersTestCase.cpp b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_parametersTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..83163f0fcb20d3fe97cfbc75e3234ac9e3c74c1d
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_parametersTestCase.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30004TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003898, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003898 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil.v"
+        "erify_parameters.depth24_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003898 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003898 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003899, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003899 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil.ve"
+        "rify_parameters.depth32f_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003899 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003899 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_partial_attachmentsTestCase.cpp b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_partial_attachmentsTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a07f0767ddc03c80faa78de16ba4dbb4a17b92b6
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_partial_attachmentsTestCase.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30004TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003894, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003894 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil.verify"
+        "_partial_attachments.depth24_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003894 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003894 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003895, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003895 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.packed_depth_stencil.verify"
+        "_partial_attachments.depth32f_stencil8",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003895 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003895 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_read_pixelsTestCase.cpp b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_read_pixelsTestCase.cpp
index f9c649030e59185836de05615e6ef74a97f4bb71..d76502c083a09b75bd3ece491b9ded85fdec671a 100644
--- a/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_read_pixelsTestCase.cpp
+++ b/graphic/vkgl/src/khrgles3/packed_depth_stencil/Khrgles3packed_depth_stencil_verify_read_pixelsTestCase.cpp
@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 
-#include <climits>
 #include <gtest/gtest.h>
 #include "../Khrgles3BaseFunc.h"
 #include "../ActsKhrgles30004TestSuite.h"
diff --git a/graphic/vkgl/src/khrgles3/parallel_shader_compile/Khrgles3KHR-GLES3_parallel_shader_compileTestCase.cpp b/graphic/vkgl/src/khrgles3/parallel_shader_compile/Khrgles3KHR-GLES3_parallel_shader_compileTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8ea1f54ba71c9a57eee50f5322b505458e8af28f
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/parallel_shader_compile/Khrgles3KHR-GLES3_parallel_shader_compileTestCase.cpp
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30004TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003709, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003709 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.parallel_shade"
+        "r_compile.simple_queries",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003709 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003709 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003710, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003710 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.parallel_shader_comp"
+        "ile.max_shader_compile_threads",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003710 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003710 end";
+}
+
+static HWTEST_F(ActsKhrgles30004TestSuite, TestCase_003711, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003711 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.parallel_shader_compil"
+        "e.compilation_completion_parallel",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30004TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30004TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30004TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30004TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30004TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003711 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003711 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/texture_filter_anisotropic/Khrgles3KHR-GLES3_texture_filter_anisotropicTestCase.cpp b/graphic/vkgl/src/khrgles3/texture_filter_anisotropic/Khrgles3KHR-GLES3_texture_filter_anisotropicTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..e85c74ed36e0fb6b6e78209693e5c0235c023d56
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/texture_filter_anisotropic/Khrgles3KHR-GLES3_texture_filter_anisotropicTestCase.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30003TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002974, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002974 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_filt"
+        "er_anisotropic.queries",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002974 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002974 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002975, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002975 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_filt"
+        "er_anisotropic.drawing",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002975 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002975 end";
+}
diff --git a/graphic/vkgl/src/khrgles3/texture_repeat_mode/Khrgles3KHR-GLES3_texture_repeat_modeTestCase.cpp b/graphic/vkgl/src/khrgles3/texture_repeat_mode/Khrgles3KHR-GLES3_texture_repeat_modeTestCase.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aed7f4d2a6553617408ccb024b4bd151fa3a13e1
--- /dev/null
+++ b/graphic/vkgl/src/khrgles3/texture_repeat_mode/Khrgles3KHR-GLES3_texture_repeat_modeTestCase.cpp
@@ -0,0 +1,4396 @@
+/*
+ * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development Co., Ltd.
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "../Khrgles3BaseFunc.h"
+#include "../ActsKhrgles30003TestSuite.h"
+
+using namespace std;
+using namespace testing::ext;
+using namespace OHOS;
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002976, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002976 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.r8_49x23_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002976 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002976 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002977, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002977 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repea"
+        "t_mode.r8_49x23_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002977 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002977 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002978, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002978 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.r8_49x23_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002978 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002978 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002979, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002979 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.r8_49x23_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002979 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002979 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002980, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002980 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repea"
+        "t_mode.r8_49x23_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002980 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002980 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002981, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002981 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.r8_49x23_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002981 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002981 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002982, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002982 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.r8_49x23_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002982 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002982 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002983, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002983 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repea"
+        "t_mode.r8_49x23_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002983 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002983 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002984, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002984 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.r8_49x23_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002984 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002984 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002985, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002985 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb565_49x23_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002985 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002985 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002986, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002986 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.rgb565_49x23_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002986 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002986 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002987, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002987 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb565_49x23_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002987 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002987 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002988, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002988 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb565_49x23_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002988 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002988 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002989, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002989 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.rgb565_49x23_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002989 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002989 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002990, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002990 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb565_49x23_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002990 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002990 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002991, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002991 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb565_49x23_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002991 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002991 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002992, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002992 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.rgb565_49x23_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002992 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002992 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002993, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002993 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb565_49x23_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002993 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002993 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002994, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002994 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.rgb8_49x23_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002994 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002994 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002995, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002995 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat"
+        "_mode.rgb8_49x23_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002995 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002995 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002996, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002996 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb8_49x23_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002996 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002996 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002997, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002997 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.rgb8_49x23_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002997 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002997 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002998, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002998 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat"
+        "_mode.rgb8_49x23_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002998 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002998 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_002999, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_002999 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb8_49x23_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_002999 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_002999 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003000, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003000 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.rgb8_49x23_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003000 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003000 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003001, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003001 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat"
+        "_mode.rgb8_49x23_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003001 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003001 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003002, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003002 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb8_49x23_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003002 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003002 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003003, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003003 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb10_a2_49x23_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003003 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003003 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003004, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003004 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rgb10_a2_49x23_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003004 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003004 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003005, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003005 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gb10_a2_49x23_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003005 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003005 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003006, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003006 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb10_a2_49x23_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003006 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003006 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003007, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003007 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rgb10_a2_49x23_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003007 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003007 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003008, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003008 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gb10_a2_49x23_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003008 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003008 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003009, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003009 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb10_a2_49x23_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003009 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003009 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003010, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003010 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rgb10_a2_49x23_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003010 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003010 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003011, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003011 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gb10_a2_49x23_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003011 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003011 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003012, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003012 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.r32ui_49x23_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003012 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003012 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003013, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003013 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.r32ui_49x23_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003013 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003013 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003014, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003014 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".r32ui_49x23_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003014 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003014 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003015, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003015 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.r32ui_49x23_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003015 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003015 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003016, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003016 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.r32ui_49x23_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003016 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003016 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003017, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003017 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".r32ui_49x23_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003017 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003017 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003018, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003018 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.r32ui_49x23_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003018 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003018 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003019, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003019 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.r32ui_49x23_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003019 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003019 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003020, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003020 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".r32ui_49x23_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003020 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003020 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003021, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003021 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rg32ui_49x23_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003021 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003021 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003022, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003022 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.rg32ui_49x23_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003022 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003022 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003023, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003023 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rg32ui_49x23_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003023 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003023 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003024, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003024 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rg32ui_49x23_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003024 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003024 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003025, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003025 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.rg32ui_49x23_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003025 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003025 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003026, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003026 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rg32ui_49x23_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003026 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003026 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003027, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003027 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rg32ui_49x23_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003027 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003027 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003028, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003028 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.rg32ui_49x23_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003028 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003028 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003029, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003029 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rg32ui_49x23_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003029 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003029 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003030, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003030 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgba32ui_49x23_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003030 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003030 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003031, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003031 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rgba32ui_49x23_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003031 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003031 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003032, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003032 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gba32ui_49x23_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003032 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003032 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003033, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003033 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgba32ui_49x23_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003033 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003033 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003034, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003034 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rgba32ui_49x23_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003034 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003034 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003035, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003035 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gba32ui_49x23_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003035 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003035 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003036, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003036 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgba32ui_49x23_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003036 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003036 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003037, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003037 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rgba32ui_49x23_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003037 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003037 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003038, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003038 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gba32ui_49x23_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003038 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003038 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003039, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003039 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.dept"
+        "h_component16_49x23_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003039 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003039 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003040, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003040 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.d"
+        "epth_component16_49x23_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003040 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003040 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003041, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003041 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "_component16_49x23_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003041 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003041 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003042, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003042 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.dept"
+        "h_component16_49x23_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003042 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003042 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003043, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003043 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.d"
+        "epth_component16_49x23_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003043 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003043 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003044, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003044 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "_component16_49x23_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003044 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003044 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003045, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003045 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.dept"
+        "h_component16_49x23_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003045 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003045 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003046, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003046 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.d"
+        "epth_component16_49x23_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003046 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003046 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003047, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003047 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "_component16_49x23_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003047 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003047 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003048, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003048 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.dept"
+        "h24_stencil8_49x23_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003048 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003048 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003049, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003049 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "depth24_stencil8_49x23_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003049 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003049 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003050, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003050 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "24_stencil8_49x23_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003050 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003050 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003051, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003051 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.dept"
+        "h24_stencil8_49x23_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003051 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003051 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003052, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003052 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "depth24_stencil8_49x23_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003052 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003052 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003053, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003053 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "24_stencil8_49x23_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003053 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003053 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003054, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003054 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.dept"
+        "h24_stencil8_49x23_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003054 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003054 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003055, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003055 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "depth24_stencil8_49x23_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003055 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003055 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003056, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003056 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "24_stencil8_49x23_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003056 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003056 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003057, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003057 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.r8_11x131_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003057 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003057 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003058, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003058 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat"
+        "_mode.r8_11x131_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003058 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003058 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003059, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003059 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.r8_11x131_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003059 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003059 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003060, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003060 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.r8_11x131_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003060 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003060 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003061, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003061 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat"
+        "_mode.r8_11x131_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003061 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003061 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003062, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003062 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.r8_11x131_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003062 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003062 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003063, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003063 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.r8_11x131_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003063 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003063 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003064, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003064 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat"
+        "_mode.r8_11x131_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003064 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003064 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003065, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003065 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.r8_11x131_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003065 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003065 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003066, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003066 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb565_11x131_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003066 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003066 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003067, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003067 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rgb565_11x131_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003067 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003067 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003068, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003068 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb565_11x131_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003068 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003068 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003069, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003069 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb565_11x131_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003069 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003069 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003070, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003070 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rgb565_11x131_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003070 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003070 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003071, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003071 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb565_11x131_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003071 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003071 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003072, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003072 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb565_11x131_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003072 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003072 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003073, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003073 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rgb565_11x131_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003073 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003073 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003074, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003074 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb565_11x131_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003074 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003074 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003075, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003075 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.rgb8_11x131_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003075 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003075 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003076, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003076 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.rgb8_11x131_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003076 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003076 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003077, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003077 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb8_11x131_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003077 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003077 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003078, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003078 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.rgb8_11x131_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003078 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003078 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003079, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003079 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.rgb8_11x131_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003079 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003079 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003080, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003080 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb8_11x131_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003080 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003080 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003081, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003081 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mod"
+        "e.rgb8_11x131_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003081 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003081 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003082, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003082 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.rgb8_11x131_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003082 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003082 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003083, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003083 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rgb8_11x131_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003083 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003083 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003084, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003084 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb10_a2_11x131_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003084 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003084 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003085, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003085 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.rgb10_a2_11x131_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003085 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003085 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003086, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003086 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gb10_a2_11x131_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003086 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003086 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003087, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003087 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb10_a2_11x131_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003087 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003087 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003088, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003088 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.rgb10_a2_11x131_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003088 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003088 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003089, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003089 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gb10_a2_11x131_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003089 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003089 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003090, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003090 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgb10_a2_11x131_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003090 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003090 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003091, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003091 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.rgb10_a2_11x131_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003091 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003091 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003092, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003092 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gb10_a2_11x131_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003092 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003092 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003093, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003093 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".r32ui_11x131_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003093 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003093 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003094, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003094 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.r32ui_11x131_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003094 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003094 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003095, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003095 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "r32ui_11x131_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003095 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003095 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003096, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003096 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".r32ui_11x131_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003096 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003096 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003097, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003097 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.r32ui_11x131_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003097 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003097 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003098, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003098 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "r32ui_11x131_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003098 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003098 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003099, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003099 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".r32ui_11x131_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003099 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003099 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003100, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003100 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_"
+        "mode.r32ui_11x131_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003100 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003100 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003101, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003101 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "r32ui_11x131_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003101 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003101 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003102, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003102 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rg32ui_11x131_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003102 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003102 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003103, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003103 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rg32ui_11x131_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003103 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003103 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003104, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003104 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rg32ui_11x131_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003104 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003104 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003105, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003105 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rg32ui_11x131_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003105 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003105 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003106, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003106 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rg32ui_11x131_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003106 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003106 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003107, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003107 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rg32ui_11x131_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003107 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003107 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003108, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003108 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode"
+        ".rg32ui_11x131_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003108 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003108 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003109, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003109 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_m"
+        "ode.rg32ui_11x131_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003109 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003109 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003110, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003110 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rg32ui_11x131_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003110 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003110 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003111, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003111 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgba32ui_11x131_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003111 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003111 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003112, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003112 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.rgba32ui_11x131_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003112 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003112 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003113, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003113 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gba32ui_11x131_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003113 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003113 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003114, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003114 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgba32ui_11x131_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003114 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003114 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003115, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003115 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.rgba32ui_11x131_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003115 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003115 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003116, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003116 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gba32ui_11x131_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003116 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003116 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003117, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003117 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode."
+        "rgba32ui_11x131_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003117 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003117 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003118, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003118 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mo"
+        "de.rgba32ui_11x131_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003118 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003118 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003119, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003119 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.r"
+        "gba32ui_11x131_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003119 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003119 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003120, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003120 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "_component16_11x131_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003120 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003120 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003121, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003121 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.d"
+        "epth_component16_11x131_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003121 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003121 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003122, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003122 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth_"
+        "component16_11x131_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003122 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003122 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003123, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003123 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "_component16_11x131_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003123 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003123 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003124, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003124 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.d"
+        "epth_component16_11x131_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003124 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003124 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003125, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003125 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth_"
+        "component16_11x131_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003125 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003125 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003126, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003126 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "_component16_11x131_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003126 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003126 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003127, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003127 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.d"
+        "epth_component16_11x131_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003127 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003127 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003128, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003128 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth_"
+        "component16_11x131_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003128 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003128 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003129, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003129 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.dept"
+        "h24_stencil8_11x131_0_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003129 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003129 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003130, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003130 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.d"
+        "epth24_stencil8_11x131_0_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003130 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003130 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003131, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003131 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "24_stencil8_11x131_0_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003131 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003131 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003132, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003132 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.dept"
+        "h24_stencil8_11x131_1_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003132 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003132 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003133, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003133 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.d"
+        "epth24_stencil8_11x131_1_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003133 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003133 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003134, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003134 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "24_stencil8_11x131_1_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003134 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003134 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003135, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003135 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.dept"
+        "h24_stencil8_11x131_2_clamp_to_edge",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003135 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003135 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003136, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003136 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.d"
+        "epth24_stencil8_11x131_2_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003136 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003136 end";
+}
+
+static HWTEST_F(ActsKhrgles30003TestSuite, TestCase_003137, Function | MediumTest | Level2)
+{
+    GTEST_LOG_(INFO) << "TestCase_003137 start";
+    int argc = 3;
+    const char *argv[3] = {
+        ".",
+        "--deqp-case="
+        "KHR-GLES3.texture_repeat_mode.depth"
+        "24_stencil8_11x131_2_mirrored_repeat",
+        "--deqp-archive-dir=/data/local/tmp/"
+    };
+    
+    FuncRunResult result = RunTestKHRGLES(argc, argv);
+    ActsKhrgles30003TestSuite::runResult.numPassed += result.numPassed;
+    ActsKhrgles30003TestSuite::runResult.numFailed += result.numFailed;
+    ActsKhrgles30003TestSuite::runResult.numNotSupported += result.numNotSupported;
+    ActsKhrgles30003TestSuite::runResult.numWarnings += result.numWarnings;
+    ActsKhrgles30003TestSuite::runResult.numWaived += result.numWaived;
+    if (result.numNotSupported == 1) {
+        GTEST_LOG_(INFO) << "TestCase_003137 notsupport!";
+    } else if (result.isComplete) {
+        EXPECT_TRUE(result.isComplete);
+        EXPECT_TRUE(result.numPassed == 1);
+    };
+    GTEST_LOG_(INFO) << "TestCase_003137 end";
+}