//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1993.
//
// File: genenum.cpp
//
// Contents: implementation of CEnumeratorTest object
// This is the object that does all of the testing.
//
// Classes:
//
// Functions:
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
//--------------------------------------------------------------------------
#include "headers.hxx"
#pragma hdrstop
//+-------------------------------------------------------------------------
//
// Member: CEnumeratorTest::CEnumeratorTest
//
// Synopsis: constructor
//
// Arguments: none
//
// Returns:
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
// Notes:
//
//--------------------------------------------------------------------------
CEnumeratorTest::CEnumeratorTest()
{
m_pEnumTest = NULL;
m_ElementSize = 0;
m_ElementCount = -1;
}
//+-------------------------------------------------------------------------
//
// Member: CEnumeratorTest::CEnumeratorTest
//
// Synopsis: constructor
//
// Arguments: [enumtest] -- The enumerator object to be tested
// [elementsize] -- The size of one element from next
// [elementcount] -- The number of elements expected to in
// the enumerator. 0 if unknown.
//
// Returns:
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
// Notes:
//
//--------------------------------------------------------------------------
CEnumeratorTest::CEnumeratorTest(IGenEnum * enumtest, size_t elementsize, LONG elementcount)
{
m_pEnumTest = enumtest;
m_ElementSize = elementsize;
m_ElementCount = elementcount;
}
//+-------------------------------------------------------------------------
//
// Function: CEnumeratorTest::GetNext
//
// Synopsis: Internal Next Implementation. Does some basic checks on the
// return values.
//
// Effects:
//
// Arguments: [celt] -- the number of items to fetch
// [pceltFetched] -- the number of items fetched
// [phresult] -- the return from next
//
// Requires:
//
// Returns: True if the basic tests passed, false if they didn't
// The result of the next call itself is passed in param 3.
//
// Signals:
//
// Modifies:
//
// Algorithm: Checks:
// That if s_ok is returned celt and pceltFetched are ==
// If a verify is provided it is called
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
// Notes:
//
//--------------------------------------------------------------------------
BOOL CEnumeratorTest::GetNext( ULONG celt,
ULONG* pceltFetched,
HRESULT* phresult
)
{
void* prgelt;
ULONG ul;
BOOL fRet = TRUE;
//
// Allocate memory for the return elements
//
prgelt = new char[m_ElementSize * celt];
if (prgelt == NULL)
{
printf("IEnumX::GetNext out of memory.\r\n");
return(FALSE);
}
//
// Call next
//
*phresult = m_pEnumTest->Next(celt, prgelt, pceltFetched);
//
// If the return result is S_OK make sure the numbers match
//
if (*phresult == S_OK)
{
if ((pceltFetched) && (celt != *pceltFetched))
{
printf("IEnumX::Next returned S_OK but celt"
" and pceltFetch mismatch.\r\n");
fRet = FALSE;
}
}
//
// If false is returned then make sure celt is less than
// the number actually fetched
//
if (*phresult == S_FALSE)
{
if ((pceltFetched) && (celt < *pceltFetched))
{
printf("IEnumX::Next return S_FALSE but celt is"
" less than pceltFetch.\r\n");
fRet = FALSE;
}
}
//
// Call verify to make sure the elements are ok.
//
if ((*phresult == S_OK) || (*phresult == S_FALSE))
{
//
// If we got S_FALSE back set celt to the number of elements
// returned in pceltFetched. If the user gave NULL for
// pceltFetched and we got S_FALSE back then celt can only be
// zero.
//
if (*phresult == S_FALSE)
{
if (pceltFetched)
{
celt = *pceltFetched;
}
else
{
celt = 0;
}
}
//
// loop through every returned element
//
for (ul=0; ul <= celt ; ul++)
{
if ((fRet == TRUE) &&
(Verify(((char *)prgelt) + (ul * m_ElementSize)) == FALSE))
{
printf("Data element %d returned by IEnumX::Next is bad.\r\n", ul);
fRet = FALSE;
//
// we keep looping anyway just to
// free up resources.
//
}
//
// If the user supplied a cleanup function there is additional
// memory that needs to be freed
//
// Math: cast prgelt to char* to it a one byte size and then scale
// it by the index * the element size
//
Cleanup(((char *)prgelt) + (ul * m_ElementSize));
}
}
delete prgelt;
return fRet;
}
//+-------------------------------------------------------------------------
//
// Method: CEnumeratorTest::TestNext
//
// Synopsis: Test the next enumerator methods
//
// Effects:
//
// Arguments: None.
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
// Notes: BUGBUG: This function should really be broken down into
// smaller function.
// Also, the return mechanism is unwieldy.
//
//--------------------------------------------------------------------------
HRESULT CEnumeratorTest::TestNext(void)
{
ULONG celtFetched;
LONG lInternalCount = 0;
HRESULT hresult;
ULONG i;
void* prgelt;
//
// First we want to count the element by doing a next on each one.
//
do {
if (!GetNext(1, &celtFetched, &hresult))
{
return(E_FAIL);
}
if (hresult == S_OK)
{
lInternalCount++;
}
} while ( hresult == S_OK );
//
// If the user passed in an amount make sure it matches what we got
//
if ((m_ElementCount != -1) && (lInternalCount != m_ElementCount))
{
printf("IEnumX: enumerated count and passed count do not match!\r\n");
return(E_FAIL);
}
else if (m_ElementCount == -1)
{
//
// If the user didn't pass in the element count let's set it here.
//
m_ElementCount = lInternalCount;
}
hresult = m_pEnumTest->Reset();
if (hresult != S_OK)
{
printf("IEnumnX: Reset failed (%lx)\r\n", hresult );
return(E_FAIL);
}
//
// Make sure we fail on ...Next(celt>1, ...,NULL)
//
if (GetNext(2, NULL, &hresult))
{
if (SUCCEEDED(hresult))
{
printf("IEnumX: celt>1 pceltFetched==NULL returned success\r\n");
return(E_FAIL);
}
}
else
{
return(E_FAIL);
}
//
// This next test will call next getting more each time
//
for (i = 1; i < (ULONG)m_ElementCount; i++)
{
hresult = m_pEnumTest->Reset();
if (hresult != S_OK)
{
printf("IEnumnX: Reset failed (%lx)\r\n", hresult );
return(E_FAIL);
}
if (!GetNext(i, &celtFetched, &hresult))
{
return(E_FAIL);
}
if ((hresult != S_OK) || (celtFetched != i))
{
printf("IEnumX: next/reset test failed!\r\n");
return(E_FAIL);
}
}
//
// Now get more elements than we were supposed to
// This should return S_FALSE with the max number in the number fetched
//
hresult = m_pEnumTest->Reset();
if (hresult != S_OK)
{
printf("IEnumX: Reset failed (%lx)\r\n", hresult );
return(E_FAIL);
}
if (!GetNext(m_ElementCount + 1, &celtFetched, &hresult))
{
return(E_FAIL);
}
if ((hresult != S_FALSE) || (lInternalCount != m_ElementCount))
{
printf("IEnumX: next/reset test failed!\r\n");
return(E_FAIL);
}
//
// Now verifyall. We do it here after the object has been worked on a bit
// since it is more likely to fail at this point
//
hresult = m_pEnumTest->Reset();
if (hresult != S_OK)
{
printf("IEnumX: Reset failed (%lx)\r\n", hresult );
return(E_FAIL);
}
//
// Allocate memory for the return elements
//
prgelt = new char[m_ElementSize * m_ElementCount];
if (prgelt == NULL)
{
printf("IEnumX: verifyall new failed\r\n");
return(E_OUTOFMEMORY);
}
hresult = m_pEnumTest->Next(m_ElementCount, prgelt, &celtFetched);
if ((hresult != S_OK) || (celtFetched != (ULONG)m_ElementCount))
{
printf("IEnumX: verifyall test: next failed (%lx)\r\n", hresult );
delete prgelt;
return(E_FAIL);
}
if (VerifyAll(prgelt, m_ElementCount) == FALSE)
{
printf("IEnumX: verifyall failed (%lx)\r\n", hresult );
delete prgelt;
return(E_FAIL);
}
delete prgelt;
return(S_OK);
}
//+-------------------------------------------------------------------------
//
// Method: CEnumeratorTest::TestSkip
//
// Synopsis: This function calls all the tests
//
// Effects:
//
// Arguments: None
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
// Notes:
//
//--------------------------------------------------------------------------
HRESULT CEnumeratorTest::TestSkip(void)
{
LONG i;
HRESULT hresult;
ULONG celtFetched;
//
// Make sure we call TestNext to set the element count
//
if (m_ElementCount == -1)
{
TestNext();
}
//
// Call Skip, reset and try to get one element
//
for (i = 0; i < (LONG)m_ElementCount; i++)
{
hresult = m_pEnumTest->Reset();
if (hresult != S_OK)
{
printf("IEnumnX: Reset failed (%lx)\r\n", hresult );
return(E_FAIL);
}
hresult = m_pEnumTest->Skip(i);
if (hresult != S_OK)
{
printf("IEnumnX: Skip failed (%lx)\r\n", hresult );
return(E_FAIL);
}
//
// Now one element to provide some check that the skip worked
//
if (!GetNext(1, &celtFetched, &hresult))
{
return(E_FAIL);
}
if (hresult != S_OK)
{
return(E_FAIL);
}
}
//
// Reset the enumerator before we leave
//
hresult = m_pEnumTest->Reset();
if (hresult != S_OK)
{
printf("IEnumnX: Reset failed (%lx)\r\n", hresult );
return(E_FAIL);
}
return(S_OK);
}
//+-------------------------------------------------------------------------
//
// Method: CEnumeratorTest::TestRelease
//
// Synopsis: This function calls all the tests
//
// Effects:
//
// Arguments: None
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
// Notes:
//
//--------------------------------------------------------------------------
HRESULT CEnumeratorTest::TestRelease(void)
{
return(S_OK);
}
//+-------------------------------------------------------------------------
//
// Method: CEnumeratorTest::TestClone
//
// Synopsis: This function calls all the tests
//
// Effects:
//
// Arguments: None
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
// Notes:
//
//--------------------------------------------------------------------------
HRESULT CEnumeratorTest::TestClone(void)
{
return(S_OK);
}
//+-------------------------------------------------------------------------
//
// Method: CEnumeratorTest::TestAll
//
// Synopsis: This function calls all the tests
//
// Effects:
//
// Arguments: None
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
// Notes:
//
//--------------------------------------------------------------------------
HRESULT CEnumeratorTest::TestAll(void)
{
HRESULT hresult;
hresult = TestNext();
if (hresult == S_OK)
{
hresult = TestSkip();
}
if (hresult == S_OK)
{
hresult = TestClone();
}
if (hresult == S_OK)
{
hresult = TestRelease();
}
return(hresult);
}
//+-------------------------------------------------------------------------
//
// Method: CEnumeratorTest::VerifyAll
//
// Synopsis: Verify entire array of returned results.
//
// Arguments: None
//
// Returns: BOOL
//
// Algorithm: Just default to saying everything is ok
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
// Notes:
//
//--------------------------------------------------------------------------
BOOL CEnumeratorTest::VerifyAll(void *pv, LONG cl)
{
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CEnumeratorTest::Verify
//
// Synopsis: Verify one element
//
// Arguments: None
//
// Returns: BOOL
//
// Algorithm: Just default to saying everything is ok
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
// Notes:
//
//--------------------------------------------------------------------------
BOOL CEnumeratorTest::Verify(void *pv)
{
return TRUE;
}
//+-------------------------------------------------------------------------
//
// Method: CEnumeratorTest::Cleanup
//
// Synopsis: Default implementation of cleanup
//
// Arguments: [pv] - pointer to entry enumerated
//
// Algorithm: If there is nothing special to free this implementation
// can be used.
//
// History: dd-mmm-yy Author Comment
// 24-May-94 kennethm author
//
//--------------------------------------------------------------------------
void CEnumeratorTest::Cleanup(void *pv)
{
return;
}