executor/xeTestCase.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * drawElements Quality Program Test Executor
  * ------------------------------------------
  *
  * Copyright 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  *//*!
  * \file
  * \brief Test case.
  *//*--------------------------------------------------------------------*/

 #include "xeTestCase.hpp"

 using std::vector;

 namespace xe
 {

 const char *getTestCaseTypeName(TestCaseType caseType)
 {
     switch (caseType)
     {
     case TESTCASETYPE_SELF_VALIDATE:
         return "SelfValidate";
     case TESTCASETYPE_CAPABILITY:
         return "Capability";
     case TESTCASETYPE_ACCURACY:
         return "Accuracy";
     case TESTCASETYPE_PERFORMANCE:
         return "Performance";
     default:
         DE_ASSERT(false);
         return nullptr;
     }
 }

 static inline int getFirstComponentLength(const char *path)
 {
     int compLen = 0;
     while (path[compLen] != 0 && path[compLen] != '.')
         compLen++;
     return compLen;
 }

 static bool compareNameToPathComponent(const char *name, const char *path, int compLen)
 {
     for (int pos = 0; pos < compLen; pos++)
     {
         if (name[pos] != path[pos])
             return false;
     }

     if (name[compLen] != 0)
         return false;

     return true;
 }

 static void splitPath(const char *path, std::vector<std::string> &components)
 {
     std::string pathStr(path);
     int compStart = 0;

     for (int pos = 0; pos < (int)pathStr.length(); pos++)
     {
         if (pathStr[pos] == '.')
         {
             components.push_back(pathStr.substr(compStart, pos - compStart));
             compStart = pos + 1;
         }
     }

     DE_ASSERT(compStart < (int)pathStr.length());
     components.push_back(pathStr.substr(compStart));
 }

 // TestNode

 TestNode::TestNode(TestGroup *parent, TestNodeType nodeType, const char *name)
     : m_parent(parent)
     , m_nodeType(nodeType)
     , m_name(name)
 {
     if (m_parent)
     {
         // Verify that the name is unique.
         if (parent->m_childNames.find(name) != parent->m_childNames.end())
             throw Error(std::string("Duplicate node '") + name + "' in '" + parent->getFullPath());

         m_parent->m_children.push_back(this);
         m_parent->m_childNames.insert(name);
     }
 }

 void TestNode::getFullPath(std::string &dst) const
 {
     dst.clear();

     int nameLen             = 0;
     const TestNode *curNode = this;

     for (;;)
     {
         nameLen += (int)curNode->m_name.length();

         DE_ASSERT(curNode->m_parent);
         if (curNode->m_parent->getNodeType() != TESTNODETYPE_ROOT)
         {
             nameLen += 1;
             curNode = curNode->m_parent;
         }
         else
             break;
     }

     dst.resize(nameLen);

     curNode = this;
     int pos = nameLen;

     for (;;)
     {
         std::copy(curNode->m_name.begin(), curNode->m_name.end(), dst.begin() + (pos - curNode->m_name.length()));
         pos -= (int)curNode->m_name.length();

         DE_ASSERT(curNode->m_parent);
         if (curNode->m_parent->getNodeType() != TESTNODETYPE_ROOT)
         {
             dst[--pos] = '.';
             curNode    = curNode->m_parent;
         }
         else
             break;
     }
 }

 const TestNode *TestNode::find(const char *path) const
 {
     if (m_nodeType == TESTNODETYPE_ROOT)
     {
         // Don't need to consider current node.
         return static_cast<const TestGroup *>(this)->findChildNode(path);
     }
     else
     {
         // Check if first component matches this node.
         int compLen = getFirstComponentLength(path);
         XE_CHECK(compLen > 0);

         if (compareNameToPathComponent(getName(), path, compLen))
         {
             if (path[compLen] == 0)
                 return this;
             else if (getNodeType() == TESTNODETYPE_GROUP)
                 return static_cast<const TestGroup *>(this)->findChildNode(path + compLen + 1);
             else
                 return nullptr;
         }
         else
             return nullptr;
     }
 }

 TestNode *TestNode::find(const char *path)
 {
     return const_cast<TestNode *>(const_cast<const TestNode *>(this)->find(path));
 }

 // TestGroup

 TestGroup::TestGroup(TestGroup *parent, TestNodeType nodeType, const char *name) : TestNode(parent, nodeType, name)
 {
     DE_ASSERT(nodeType == TESTNODETYPE_GROUP || nodeType == TESTNODETYPE_ROOT);
     DE_ASSERT(!parent == (nodeType == TESTNODETYPE_ROOT));
 }

 TestGroup::~TestGroup(void)
 {
     for (std::vector<TestNode *>::iterator i = m_children.begin(); i != m_children.end(); i++)
         delete *i;
 }

 TestGroup *TestGroup::createGroup(const char *name)
 {
     return new TestGroup(this, TESTNODETYPE_GROUP, name);
 }

 TestCase *TestGroup::createCase(TestCaseType caseType, const char *name)
 {
     return TestCase::createAsChild(this, caseType, name);
 }

 const TestNode *TestGroup::findChildNode(const char *path) const
 {
     int compLen = getFirstComponentLength(path);
     XE_CHECK(compLen > 0);

     // Try to find matching children.
     const TestNode *matchingNode = nullptr;
     for (vector<TestNode *>::const_iterator iter = m_children.begin(); iter != m_children.end(); iter++)
     {
         if (compareNameToPathComponent((*iter)->getName(), path, compLen))
         {
             matchingNode = *iter;
             break;
         }
     }

     if (matchingNode)
     {
         if (path[compLen] == 0)
             return matchingNode; // Last element in path, return matching node.
         else if (matchingNode->getNodeType() == TESTNODETYPE_GROUP)
             return static_cast<const TestGroup *>(matchingNode)->findChildNode(path + compLen + 1);
         else
             return nullptr;
     }
     else
         return nullptr;
 }

 // TestRoot

 TestRoot::TestRoot(void) : TestGroup(nullptr, TESTNODETYPE_ROOT, "")
 {
 }

 // TestCase

 TestCase *TestCase::createAsChild(TestGroup *parent, TestCaseType caseType, const char *name)
 {
     return new TestCase(parent, caseType, name);
 }

 TestCase::TestCase(TestGroup *parent, TestCaseType caseType, const char *name)
     : TestNode(parent, TESTNODETYPE_TEST_CASE, name)
     , m_caseType(caseType)
 {
 }

 TestCase::~TestCase(void)
 {
 }

 // TestHierarchyBuilder helpers

 void addChildGroupsToMap(std::map<std::string, TestGroup *> &groupMap, TestGroup *group)
 {
     for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
     {
         TestNode *node = group->getChild(ndx);
         if (node->getNodeType() == TESTNODETYPE_GROUP)
         {
             TestGroup *childGroup = static_cast<TestGroup *>(node);
             std::string fullPath;
             childGroup->getFullPath(fullPath);

             groupMap.insert(std::make_pair(fullPath, childGroup));
             addChildGroupsToMap(groupMap, childGroup);
         }
     }
 }

 // TestHierarchyBuilder

 TestHierarchyBuilder::TestHierarchyBuilder(TestRoot *root) : m_root(root)
 {
     addChildGroupsToMap(m_groupMap, root);
 }

 TestHierarchyBuilder::~TestHierarchyBuilder(void)
 {
 }

 TestCase *TestHierarchyBuilder::createCase(const char *path, TestCaseType caseType)
 {
     // \todo [2012-09-05 pyry] This can be done with less string manipulations.
     std::vector<std::string> components;
     splitPath(path, components);
     DE_ASSERT(!components.empty());

     // Create all parents if necessary.
     TestGroup *curGroup = m_root;
     std::string curGroupPath;
     for (int ndx = 0; ndx < (int)components.size() - 1; ndx++)
     {
         if (!curGroupPath.empty())
             curGroupPath += ".";
         curGroupPath += components[ndx];

         std::map<std::string, TestGroup *>::const_iterator groupPos = m_groupMap.find(curGroupPath);
         if (groupPos == m_groupMap.end())
         {
             TestGroup *newGroup = curGroup->createGroup(components[ndx].c_str());
             m_groupMap.insert(std::make_pair(curGroupPath, newGroup));
             curGroup = newGroup;
         }
         else
             curGroup = groupPos->second;
     }

     return curGroup->createCase(caseType, components.back().c_str());
 }

 // TestSet helpers

 static void addNodeAndParents(std::set<const TestNode *> &nodeSet, const TestNode *node)
 {
     while (node != nullptr)
     {
         nodeSet.insert(node);
         node = node->getParent();
     }
 }

 static void addChildren(std::set<const TestNode *> &nodeSet, const TestGroup *group)
 {
     for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
     {
         const TestNode *child = group->getChild(ndx);
         nodeSet.insert(child);

         if (child->getNodeType() == TESTNODETYPE_GROUP)
             addChildren(nodeSet, static_cast<const TestGroup *>(child));
     }
 }

 static void removeChildren(std::set<const TestNode *> &nodeSet, const TestGroup *group)
 {
     for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
     {
         const TestNode *child = group->getChild(ndx);
         nodeSet.erase(child);

         if (child->getNodeType() == TESTNODETYPE_GROUP)
             removeChildren(nodeSet, static_cast<const TestGroup *>(child));
     }
 }

 static bool hasChildrenInSet(const std::set<const TestNode *> &nodeSet, const TestGroup *group)
 {
     for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
     {
         if (nodeSet.find(group->getChild(ndx)) != nodeSet.end())
             return true;
     }
     return false;
 }

 static void removeEmptyGroups(std::set<const TestNode *> &nodeSet, const TestGroup *group)
 {
     if (!hasChildrenInSet(nodeSet, group))
     {
         nodeSet.erase(group);
         if (group->getParent() != nullptr)
             removeEmptyGroups(nodeSet, group->getParent());
     }
 }

 // TestSet

 void TestSet::add(const TestNode *node)
 {
     if (node->getNodeType() == TESTNODETYPE_TEST_CASE)
         addCase(static_cast<const TestCase *>(node));
     else
     {
         XE_CHECK(node->getNodeType() == TESTNODETYPE_GROUP || node->getNodeType() == TESTNODETYPE_ROOT);
         addGroup(static_cast<const TestGroup *>(node));
     }
 }

 void TestSet::addCase(const TestCase *testCase)
 {
     addNodeAndParents(m_set, testCase);
 }

 void TestSet::addGroup(const TestGroup *testGroup)
 {
     addNodeAndParents(m_set, testGroup);
     addChildren(m_set, testGroup);
 }

 void TestSet::remove(const TestNode *node)
 {
     if (node->getNodeType() == TESTNODETYPE_TEST_CASE)
         removeCase(static_cast<const TestCase *>(node));
     else
     {
         XE_CHECK(node->getNodeType() == TESTNODETYPE_GROUP || node->getNodeType() == TESTNODETYPE_ROOT);
         removeGroup(static_cast<const TestGroup *>(node));
     }
 }

 void TestSet::removeCase(const TestCase *testCase)
 {
     if (m_set.find(testCase) != m_set.end())
     {
         m_set.erase(testCase);
         removeEmptyGroups(m_set, testCase->getParent());
     }
 }

 void TestSet::removeGroup(const TestGroup *testGroup)
 {
     if (m_set.find(testGroup) != m_set.end())
     {
         m_set.erase(testGroup);
         removeChildren(m_set, testGroup);
         if (testGroup->getParent() != nullptr)
             removeEmptyGroups(m_set, testGroup->getParent());
     }
 }

 // ConstTestNodeIterator

 ConstTestNodeIterator::ConstTestNodeIterator(const TestNode *root) : m_root(root)
 {
 }

 ConstTestNodeIterator ConstTestNodeIterator::begin(const TestNode *root)
 {
     ConstTestNodeIterator iter(root);
     iter.m_iterStack.push_back(GroupState(nullptr));
     return iter;
 }

 ConstTestNodeIterator ConstTestNodeIterator::end(const TestNode *root)
 {
     DE_UNREF(root);
     return ConstTestNodeIterator(root);
 }

 ConstTestNodeIterator &ConstTestNodeIterator::operator++(void)
 {
     DE_ASSERT(!m_iterStack.empty());

     const TestNode *curNode  = **this;
     TestNodeType curNodeType = curNode->getNodeType();

     if ((curNodeType == TESTNODETYPE_GROUP || curNodeType == TESTNODETYPE_ROOT) &&
         static_cast<const TestGroup *>(curNode)->getNumChildren() > 0)
     {
         m_iterStack.push_back(GroupState(static_cast<const TestGroup *>(curNode)));
     }
     else
     {
         for (;;)
         {
             const TestGroup *group = m_iterStack.back().group;
             int &childNdx          = m_iterStack.back().childNdx;
             int numChildren        = group ? group->getNumChildren() : 1;

             childNdx += 1;
             if (childNdx == numChildren)
             {
                 m_iterStack.pop_back();
                 if (m_iterStack.empty())
                     break;
             }
             else
                 break;
         }
     }

     return *this;
 }

 ConstTestNodeIterator ConstTestNodeIterator::operator++(int)
 {
     ConstTestNodeIterator copy(*this);
     ++(*this);
     return copy;
 }

 const TestNode *ConstTestNodeIterator::operator*(void) const
 {
     DE_ASSERT(!m_iterStack.empty());
     if (m_iterStack.size() == 1)
     {
         DE_ASSERT(m_iterStack[0].group == nullptr && m_iterStack[0].childNdx == 0);
         return m_root;
     }
     else
         return m_iterStack.back().group->getChild(m_iterStack.back().childNdx);
 }

 bool ConstTestNodeIterator::operator!=(const ConstTestNodeIterator &other) const
 {
     return m_root != other.m_root || m_iterStack != other.m_iterStack;
 }

 } // namespace xe
	/*-------------------------------------------------------------------------
	* drawElements Quality Program Test Executor
	* ------------------------------------------
	*
	* Copyright 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	//!
	* \file
	* \brief Test case.
	//--------------------------------------------------------------------*/

	#include "xeTestCase.hpp"

	using std::vector;

	namespace xe
	{

	const char *getTestCaseTypeName(TestCaseType caseType)
	{
	switch (caseType)
	{
	case TESTCASETYPE_SELF_VALIDATE:
	return "SelfValidate";
	case TESTCASETYPE_CAPABILITY:
	return "Capability";
	case TESTCASETYPE_ACCURACY:
	return "Accuracy";
	case TESTCASETYPE_PERFORMANCE:
	return "Performance";
	default:
	DE_ASSERT(false);
	return nullptr;
	}
	}

	static inline int getFirstComponentLength(const char *path)
	{
	int compLen = 0;
	while (path[compLen] != 0 && path[compLen] != '.')
	compLen++;
	return compLen;
	}

	static bool compareNameToPathComponent(const char name, const char path, int compLen)
	{
	for (int pos = 0; pos < compLen; pos++)
	{
	if (name[pos] != path[pos])
	return false;
	}

	if (name[compLen] != 0)
	return false;

	return true;
	}

	static void splitPath(const char *path, std::vector<std::string> &components)
	{
	std::string pathStr(path);
	int compStart = 0;

	for (int pos = 0; pos < (int)pathStr.length(); pos++)
	{
	if (pathStr[pos] == '.')
	{
	components.push_back(pathStr.substr(compStart, pos - compStart));
	compStart = pos + 1;
	}
	}

	DE_ASSERT(compStart < (int)pathStr.length());
	components.push_back(pathStr.substr(compStart));
	}

	// TestNode

	TestNode::TestNode(TestGroup parent, TestNodeType nodeType, const char name)
	: m_parent(parent)
	, m_nodeType(nodeType)
	, m_name(name)
	{
	if (m_parent)
	{
	// Verify that the name is unique.
	if (parent->m_childNames.find(name) != parent->m_childNames.end())
	throw Error(std::string("Duplicate node '") + name + "' in '" + parent->getFullPath());

	m_parent->m_children.push_back(this);
	m_parent->m_childNames.insert(name);
	}
	}

	void TestNode::getFullPath(std::string &dst) const
	{
	dst.clear();

	int nameLen = 0;
	const TestNode *curNode = this;

	for (;;)
	{
	nameLen += (int)curNode->m_name.length();

	DE_ASSERT(curNode->m_parent);
	if (curNode->m_parent->getNodeType() != TESTNODETYPE_ROOT)
	{
	nameLen += 1;
	curNode = curNode->m_parent;
	}
	else
	break;
	}

	dst.resize(nameLen);

	curNode = this;
	int pos = nameLen;

	for (;;)
	{
	std::copy(curNode->m_name.begin(), curNode->m_name.end(), dst.begin() + (pos - curNode->m_name.length()));
	pos -= (int)curNode->m_name.length();

	DE_ASSERT(curNode->m_parent);
	if (curNode->m_parent->getNodeType() != TESTNODETYPE_ROOT)
	{
	dst[--pos] = '.';
	curNode = curNode->m_parent;
	}
	else
	break;
	}
	}

	const TestNode TestNode::find(const char path) const
	{
	if (m_nodeType == TESTNODETYPE_ROOT)
	{
	// Don't need to consider current node.
	return static_cast<const TestGroup *>(this)->findChildNode(path);
	}
	else
	{
	// Check if first component matches this node.
	int compLen = getFirstComponentLength(path);
	XE_CHECK(compLen > 0);

	if (compareNameToPathComponent(getName(), path, compLen))
	{
	if (path[compLen] == 0)
	return this;
	else if (getNodeType() == TESTNODETYPE_GROUP)
	return static_cast<const TestGroup *>(this)->findChildNode(path + compLen + 1);
	else
	return nullptr;
	}
	else
	return nullptr;
	}
	}

	TestNode TestNode::find(const char path)
	{
	return const_cast<TestNode >(const_cast<const TestNode >(this)->find(path));
	}

	// TestGroup

	TestGroup::TestGroup(TestGroup parent, TestNodeType nodeType, const char name) : TestNode(parent, nodeType, name)
	{
	DE_ASSERT(nodeType == TESTNODETYPE_GROUP \|\| nodeType == TESTNODETYPE_ROOT);
	DE_ASSERT(!parent == (nodeType == TESTNODETYPE_ROOT));
	}

	TestGroup::~TestGroup(void)
	{
	for (std::vector<TestNode *>::iterator i = m_children.begin(); i != m_children.end(); i++)
	delete *i;
	}

	TestGroup TestGroup::createGroup(const char name)
	{
	return new TestGroup(this, TESTNODETYPE_GROUP, name);
	}

	TestCase TestGroup::createCase(TestCaseType caseType, const char name)
	{
	return TestCase::createAsChild(this, caseType, name);
	}

	const TestNode TestGroup::findChildNode(const char path) const
	{
	int compLen = getFirstComponentLength(path);
	XE_CHECK(compLen > 0);

	// Try to find matching children.
	const TestNode *matchingNode = nullptr;
	for (vector<TestNode *>::const_iterator iter = m_children.begin(); iter != m_children.end(); iter++)
	{
	if (compareNameToPathComponent((*iter)->getName(), path, compLen))
	{
	matchingNode = *iter;
	break;
	}
	}

	if (matchingNode)
	{
	if (path[compLen] == 0)
	return matchingNode; // Last element in path, return matching node.
	else if (matchingNode->getNodeType() == TESTNODETYPE_GROUP)
	return static_cast<const TestGroup *>(matchingNode)->findChildNode(path + compLen + 1);
	else
	return nullptr;
	}
	else
	return nullptr;
	}

	// TestRoot

	TestRoot::TestRoot(void) : TestGroup(nullptr, TESTNODETYPE_ROOT, "")
	{
	}

	// TestCase

	TestCase TestCase::createAsChild(TestGroup parent, TestCaseType caseType, const char *name)
	{
	return new TestCase(parent, caseType, name);
	}

	TestCase::TestCase(TestGroup parent, TestCaseType caseType, const char name)
	: TestNode(parent, TESTNODETYPE_TEST_CASE, name)
	, m_caseType(caseType)
	{
	}

	TestCase::~TestCase(void)
	{
	}

	// TestHierarchyBuilder helpers

	void addChildGroupsToMap(std::map<std::string, TestGroup > &groupMap, TestGroup group)
	{
	for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
	{
	TestNode *node = group->getChild(ndx);
	if (node->getNodeType() == TESTNODETYPE_GROUP)
	{
	TestGroup childGroup = static_cast<TestGroup >(node);
	std::string fullPath;
	childGroup->getFullPath(fullPath);

	groupMap.insert(std::make_pair(fullPath, childGroup));
	addChildGroupsToMap(groupMap, childGroup);
	}
	}
	}

	// TestHierarchyBuilder

	TestHierarchyBuilder::TestHierarchyBuilder(TestRoot *root) : m_root(root)
	{
	addChildGroupsToMap(m_groupMap, root);
	}

	TestHierarchyBuilder::~TestHierarchyBuilder(void)
	{
	}

	TestCase TestHierarchyBuilder::createCase(const char path, TestCaseType caseType)
	{
	// \todo [2012-09-05 pyry] This can be done with less string manipulations.
	std::vector<std::string> components;
	splitPath(path, components);
	DE_ASSERT(!components.empty());

	// Create all parents if necessary.
	TestGroup *curGroup = m_root;
	std::string curGroupPath;
	for (int ndx = 0; ndx < (int)components.size() - 1; ndx++)
	{
	if (!curGroupPath.empty())
	curGroupPath += ".";
	curGroupPath += components[ndx];

	std::map<std::string, TestGroup *>::const_iterator groupPos = m_groupMap.find(curGroupPath);
	if (groupPos == m_groupMap.end())
	{
	TestGroup *newGroup = curGroup->createGroup(components[ndx].c_str());
	m_groupMap.insert(std::make_pair(curGroupPath, newGroup));
	curGroup = newGroup;
	}
	else
	curGroup = groupPos->second;
	}

	return curGroup->createCase(caseType, components.back().c_str());
	}

	// TestSet helpers

	static void addNodeAndParents(std::set<const TestNode > &nodeSet, const TestNode node)
	{
	while (node != nullptr)
	{
	nodeSet.insert(node);
	node = node->getParent();
	}
	}

	static void addChildren(std::set<const TestNode > &nodeSet, const TestGroup group)
	{
	for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
	{
	const TestNode *child = group->getChild(ndx);
	nodeSet.insert(child);

	if (child->getNodeType() == TESTNODETYPE_GROUP)
	addChildren(nodeSet, static_cast<const TestGroup *>(child));
	}
	}

	static void removeChildren(std::set<const TestNode > &nodeSet, const TestGroup group)
	{
	for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
	{
	const TestNode *child = group->getChild(ndx);
	nodeSet.erase(child);

	if (child->getNodeType() == TESTNODETYPE_GROUP)
	removeChildren(nodeSet, static_cast<const TestGroup *>(child));
	}
	}

	static bool hasChildrenInSet(const std::set<const TestNode > &nodeSet, const TestGroup group)
	{
	for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
	{
	if (nodeSet.find(group->getChild(ndx)) != nodeSet.end())
	return true;
	}
	return false;
	}

	static void removeEmptyGroups(std::set<const TestNode > &nodeSet, const TestGroup group)
	{
	if (!hasChildrenInSet(nodeSet, group))
	{
	nodeSet.erase(group);
	if (group->getParent() != nullptr)
	removeEmptyGroups(nodeSet, group->getParent());
	}
	}

	// TestSet

	void TestSet::add(const TestNode *node)
	{
	if (node->getNodeType() == TESTNODETYPE_TEST_CASE)
	addCase(static_cast<const TestCase *>(node));
	else
	{
	XE_CHECK(node->getNodeType() == TESTNODETYPE_GROUP \|\| node->getNodeType() == TESTNODETYPE_ROOT);
	addGroup(static_cast<const TestGroup *>(node));
	}
	}

	void TestSet::addCase(const TestCase *testCase)
	{
	addNodeAndParents(m_set, testCase);
	}

	void TestSet::addGroup(const TestGroup *testGroup)
	{
	addNodeAndParents(m_set, testGroup);
	addChildren(m_set, testGroup);
	}

	void TestSet::remove(const TestNode *node)
	{
	if (node->getNodeType() == TESTNODETYPE_TEST_CASE)
	removeCase(static_cast<const TestCase *>(node));
	else
	{
	XE_CHECK(node->getNodeType() == TESTNODETYPE_GROUP \|\| node->getNodeType() == TESTNODETYPE_ROOT);
	removeGroup(static_cast<const TestGroup *>(node));
	}
	}

	void TestSet::removeCase(const TestCase *testCase)
	{
	if (m_set.find(testCase) != m_set.end())
	{
	m_set.erase(testCase);
	removeEmptyGroups(m_set, testCase->getParent());
	}
	}

	void TestSet::removeGroup(const TestGroup *testGroup)
	{
	if (m_set.find(testGroup) != m_set.end())
	{
	m_set.erase(testGroup);
	removeChildren(m_set, testGroup);
	if (testGroup->getParent() != nullptr)
	removeEmptyGroups(m_set, testGroup->getParent());
	}
	}

	// ConstTestNodeIterator

	ConstTestNodeIterator::ConstTestNodeIterator(const TestNode *root) : m_root(root)
	{
	}

	ConstTestNodeIterator ConstTestNodeIterator::begin(const TestNode *root)
	{
	ConstTestNodeIterator iter(root);
	iter.m_iterStack.push_back(GroupState(nullptr));
	return iter;
	}

	ConstTestNodeIterator ConstTestNodeIterator::end(const TestNode *root)
	{
	DE_UNREF(root);
	return ConstTestNodeIterator(root);
	}

	ConstTestNodeIterator &ConstTestNodeIterator::operator++(void)
	{
	DE_ASSERT(!m_iterStack.empty());

	const TestNode curNode = *this;
	TestNodeType curNodeType = curNode->getNodeType();

	if ((curNodeType == TESTNODETYPE_GROUP \|\| curNodeType == TESTNODETYPE_ROOT) &&
	static_cast<const TestGroup *>(curNode)->getNumChildren() > 0)
	{
	m_iterStack.push_back(GroupState(static_cast<const TestGroup *>(curNode)));
	}
	else
	{
	for (;;)
	{
	const TestGroup *group = m_iterStack.back().group;
	int &childNdx = m_iterStack.back().childNdx;
	int numChildren = group ? group->getNumChildren() : 1;

	childNdx += 1;
	if (childNdx == numChildren)
	{
	m_iterStack.pop_back();
	if (m_iterStack.empty())
	break;
	}
	else
	break;
	}
	}

	return *this;
	}

	ConstTestNodeIterator ConstTestNodeIterator::operator++(int)
	{
	ConstTestNodeIterator copy(*this);
	++(*this);
	return copy;
	}

	const TestNode ConstTestNodeIterator::operator(void) const
	{
	DE_ASSERT(!m_iterStack.empty());
	if (m_iterStack.size() == 1)
	{
	DE_ASSERT(m_iterStack[0].group == nullptr && m_iterStack[0].childNdx == 0);
	return m_root;
	}
	else
	return m_iterStack.back().group->getChild(m_iterStack.back().childNdx);
	}

	bool ConstTestNodeIterator::operator!=(const ConstTestNodeIterator &other) const
	{
	return m_root != other.m_root \|\| m_iterStack != other.m_iterStack;
	}

	} // namespace xe