resultxsd.cpp

自动化编译工具代码

}

//////////////////////////////////////////////////////////////////////////////
//
// class CNameType
//
//////////////////////////////////////////////////////////////////////////////


CNameType::CNameType(CSchemaString::basetype Value) : CSchemaString(Value)
{
	Validate();
}


CNameType::CNameType(const CString& sValue) : CSchemaString(sValue)
{
	Validate();
}


void CNameType::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CStatisticsType
//
//////////////////////////////////////////////////////////////////////////////


int CStatisticsType::GetTestsMinCount()
{
	return 1;
}


int CStatisticsType::GetTestsMaxCount()
{
	return 1;
}


int CStatisticsType::GetTestsCount()
{
	return ChildCount(Element, _T(""), _T("Tests"));
}


bool CStatisticsType::HasTests()
{
	return GetTestsCount() > 0;
}


void CStatisticsType::AddTests(CTestsType Tests)
{
	AppendChild(Element, _T(""), _T("Tests"), Tests);
}


CTestsType CStatisticsType::GetTestsAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("Tests"), nIndex)->text);
}


CTestsType CStatisticsType::GetTests()
{
	return GetTestsAt(0);
}


void CStatisticsType::RemoveTestsAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("Tests"), nIndex);
}


void CStatisticsType::RemoveTests()
{
	while (HasTests())
		RemoveTestsAt(0);
}

int CStatisticsType::GetFailuresTotalMinCount()
{
	return 1;
}


int CStatisticsType::GetFailuresTotalMaxCount()
{
	return 1;
}


int CStatisticsType::GetFailuresTotalCount()
{
	return ChildCount(Element, _T(""), _T("FailuresTotal"));
}


bool CStatisticsType::HasFailuresTotal()
{
	return GetFailuresTotalCount() > 0;
}


void CStatisticsType::AddFailuresTotal(CFailuresTotalType FailuresTotal)
{
	AppendChild(Element, _T(""), _T("FailuresTotal"), FailuresTotal);
}


CFailuresTotalType CStatisticsType::GetFailuresTotalAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("FailuresTotal"), nIndex)->text);
}


CFailuresTotalType CStatisticsType::GetFailuresTotal()
{
	return GetFailuresTotalAt(0);
}


void CStatisticsType::RemoveFailuresTotalAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("FailuresTotal"), nIndex);
}


void CStatisticsType::RemoveFailuresTotal()
{
	while (HasFailuresTotal())
		RemoveFailuresTotalAt(0);
}

int CStatisticsType::GetErrorsMinCount()
{
	return 1;
}


int CStatisticsType::GetErrorsMaxCount()
{
	return 1;
}


int CStatisticsType::GetErrorsCount()
{
	return ChildCount(Element, _T(""), _T("Errors"));
}


bool CStatisticsType::HasErrors()
{
	return GetErrorsCount() > 0;
}


void CStatisticsType::AddErrors(CErrorsType Errors)
{
	AppendChild(Element, _T(""), _T("Errors"), Errors);
}


CErrorsType CStatisticsType::GetErrorsAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("Errors"), nIndex)->text);
}


CErrorsType CStatisticsType::GetErrors()
{
	return GetErrorsAt(0);
}


void CStatisticsType::RemoveErrorsAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("Errors"), nIndex);
}


void CStatisticsType::RemoveErrors()
{
	while (HasErrors())
		RemoveErrorsAt(0);
}

int CStatisticsType::GetFailuresMinCount()
{
	return 1;
}


int CStatisticsType::GetFailuresMaxCount()
{
	return 1;
}


int CStatisticsType::GetFailuresCount()
{
	return ChildCount(Element, _T(""), _T("Failures"));
}


bool CStatisticsType::HasFailures()
{
	return GetFailuresCount() > 0;
}


void CStatisticsType::AddFailures(CFailuresType Failures)
{
	AppendChild(Element, _T(""), _T("Failures"), Failures);
}


CFailuresType CStatisticsType::GetFailuresAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("Failures"), nIndex)->text);
}


CFailuresType CStatisticsType::GetFailures()
{
	return GetFailuresAt(0);
}


void CStatisticsType::RemoveFailuresAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("Failures"), nIndex);
}


void CStatisticsType::RemoveFailures()
{
	while (HasFailures())
		RemoveFailuresAt(0);
}

//////////////////////////////////////////////////////////////////////////////
//
// class CSuccessfulTestsType
//
//////////////////////////////////////////////////////////////////////////////


int CSuccessfulTestsType::GetTestMinCount()
{
	return 1;
}


int CSuccessfulTestsType::GetTestMaxCount()
{
	return 1;
}


int CSuccessfulTestsType::GetTestCount()
{
	return ChildCount(Element, _T(""), _T("Test"));
}


bool CSuccessfulTestsType::HasTest()
{
	return GetTestCount() > 0;
}


void CSuccessfulTestsType::AddTest(CTestType Test)
{
	AppendChildElement(_T(""), _T("Test"), &Test);
}


CTestType CSuccessfulTestsType::GetTestAt(int nIndex)
{
	return CTestType(*this, GetChildAt(Element, _T(""), _T("Test"), nIndex));
}


CTestType CSuccessfulTestsType::GetTest()
{
	return GetTestAt(0);
}


void CSuccessfulTestsType::RemoveTestAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("Test"), nIndex);
}


void CSuccessfulTestsType::RemoveTest()
{
	while (HasTest())
		RemoveTestAt(0);
}

//////////////////////////////////////////////////////////////////////////////
//
// class CidType2
//
//////////////////////////////////////////////////////////////////////////////


CidType2::CidType2(CSchemaByte::basetype Value) : CSchemaByte(Value)
{
	Validate();
}


CidType2::CidType2(const CString& sValue) : CSchemaByte(sValue)
{
	Validate();
}


void CidType2::Validate()
{
}


//////////////////////////////////////////////////////////////////////////////
//
// class CTestType
//
//////////////////////////////////////////////////////////////////////////////


int CTestType::GetidMinCount()
{
	return 1;
}


int CTestType::GetidMaxCount()
{
	return 1;
}


int CTestType::GetidCount()
{
	return ChildCount(Attribute, _T(""), _T("id"));
}


bool CTestType::Hasid()
{
	return GetidCount() > 0;
}


void CTestType::Addid(CidType2 id)
{
	AppendChild(Attribute, _T(""), _T("id"), id);
}


CidType2 CTestType::GetidAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Attribute, _T(""), _T("id"), nIndex)->text);
}


CidType2 CTestType::Getid()
{
	return GetidAt(0);
}


void CTestType::RemoveidAt(int nIndex)
{
	RemoveChildAt(Attribute, _T(""), _T("id"), nIndex);
}


void CTestType::Removeid()
{
	while (Hasid())
		RemoveidAt(0);
}

int CTestType::GetNameMinCount()
{
	return 1;
}


int CTestType::GetNameMaxCount()
{
	return 1;
}


int CTestType::GetNameCount()
{
	return ChildCount(Element, _T(""), _T("Name"));
}


bool CTestType::HasName()
{
	return GetNameCount() > 0;
}


void CTestType::AddName(CNameType Name)
{
	AppendChild(Element, _T(""), _T("Name"), Name);
}


CNameType CTestType::GetNameAt(int nIndex)
{
	return CString((LPCTSTR)GetChildAt(Element, _T(""), _T("Name"), nIndex)->text);
}


CNameType CTestType::GetName()
{
	return GetNameAt(0);
}


void CTestType::RemoveNameAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("Name"), nIndex);
}


void CTestType::RemoveName()
{
	while (HasName())
		RemoveNameAt(0);
}

//////////////////////////////////////////////////////////////////////////////
//
// class CTestRunType
//
//////////////////////////////////////////////////////////////////////////////


int CTestRunType::GetFailedTestsMinCount()
{
	return 1;
}


int CTestRunType::GetFailedTestsMaxCount()
{
	return 1;
}


int CTestRunType::GetFailedTestsCount()
{
	return ChildCount(Element, _T(""), _T("FailedTests"));
}


bool CTestRunType::HasFailedTests()
{
	return GetFailedTestsCount() > 0;
}


void CTestRunType::AddFailedTests(CFailedTestsType FailedTests)
{
	AppendChildElement(_T(""), _T("FailedTests"), &FailedTests);
}


CFailedTestsType CTestRunType::GetFailedTestsAt(int nIndex)
{
	return CFailedTestsType(*this, GetChildAt(Element, _T(""), _T("FailedTests"), nIndex));
}


CFailedTestsType CTestRunType::GetFailedTests()
{
	return GetFailedTestsAt(0);
}


void CTestRunType::RemoveFailedTestsAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("FailedTests"), nIndex);
}


void CTestRunType::RemoveFailedTests()
{
	while (HasFailedTests())
		RemoveFailedTestsAt(0);
}

int CTestRunType::GetSuccessfulTestsMinCount()
{
	return 1;
}


int CTestRunType::GetSuccessfulTestsMaxCount()
{
	return 1;
}


int CTestRunType::GetSuccessfulTestsCount()
{
	return ChildCount(Element, _T(""), _T("SuccessfulTests"));
}


bool CTestRunType::HasSuccessfulTests()
{
	return GetSuccessfulTestsCount() > 0;
}


void CTestRunType::AddSuccessfulTests(CSuccessfulTestsType SuccessfulTests)
{
	AppendChildElement(_T(""), _T("SuccessfulTests"), &SuccessfulTests);
}


CSuccessfulTestsType CTestRunType::GetSuccessfulTestsAt(int nIndex)
{
	return CSuccessfulTestsType(*this, GetChildAt(Element, _T(""), _T("SuccessfulTests"), nIndex));
}


CSuccessfulTestsType CTestRunType::GetSuccessfulTests()
{
	return GetSuccessfulTestsAt(0);
}


void CTestRunType::RemoveSuccessfulTestsAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("SuccessfulTests"), nIndex);
}


void CTestRunType::RemoveSuccessfulTests()
{
	while (HasSuccessfulTests())
		RemoveSuccessfulTestsAt(0);
}

int CTestRunType::GetStatisticsMinCount()
{
	return 1;
}


int CTestRunType::GetStatisticsMaxCount()
{
	return 1;
}


int CTestRunType::GetStatisticsCount()
{
	return ChildCount(Element, _T(""), _T("Statistics"));
}


bool CTestRunType::HasStatistics()
{
	return GetStatisticsCount() > 0;
}


void CTestRunType::AddStatistics(CStatisticsType Statistics)
{
	AppendChildElement(_T(""), _T("Statistics"), &Statistics);
}


CStatisticsType CTestRunType::GetStatisticsAt(int nIndex)
{
	return CStatisticsType(*this, GetChildAt(Element, _T(""), _T("Statistics"), nIndex));
}


CStatisticsType CTestRunType::GetStatistics()
{
	return GetStatisticsAt(0);
}


void CTestRunType::RemoveStatisticsAt(int nIndex)
{
	RemoveChildAt(Element, _T(""), _T("Statistics"), nIndex);
}


void CTestRunType::RemoveStatistics()
{
	while (HasStatistics())
		RemoveStatisticsAt(0);
}

//////////////////////////////////////////////////////////////////////////////
//
// class CTestsType
//
//////////////////////////////////////////////////////////////////////////////


CTestsType::CTestsType(CSchemaByte::basetype Value) : CSchemaByte(Value)
{
	Validate();
}


CTestsType::CTestsType(const CString& sValue) : CSchemaByte(sValue)
{
	Validate();
}


void CTestsType::Validate()
{
}