//+------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1993.
//
//  File: 	cliptest.cpp
//
//  Contents:   Data Advise Holder tests
//
//  Classes:    CDataAdviseTestFormatEtc
//              CTestAdviseSink
//              CTestDaHolder
//
//  Functions:  TestPrimeFirstOnlyOnceNoData
//              TestPrimeFirstOnlyOnceData
//              DoRegisterNotifyDeregister
//              TestRegisterNotifyDegister
//              TestRegisterNotifyDegisterNoData
//              TestNotifyOnStop
//              TestNotifyOnce
//              CreateMassRegistration
//              DoMassUnadvise
//              TestEnumerator
//              LEDataAdviseHolderTest
//
//  History:    dd-mmm-yy Author    Comment
//		25-May-94 ricksa    author
//
//--------------------------------------------------------------------------

#include    "oletest.h"
#include    "gendata.h"
#include    "genenum.h"



//+-------------------------------------------------------------------------
//
//  Class:      CDataAdviseTestFormatEtc
//
//  Purpose:    Hold FORMATETC used by the data advise holder unit tests
//
//  Interface:  GetFormatEtc - get a pointer to the FORMATETC
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//  Notes:
//
//--------------------------------------------------------------------------
class CDataAdviseTestFormatEtc
{
public:
                        CDataAdviseTestFormatEtc(void);

    FORMATETC *         GetFormatEtc(void);

private:

    FORMATETC           _formatetc;
};




//+-------------------------------------------------------------------------
//
//  Member:     CDataAdviseTestFormatEtc::CDataAdviseTestFormatEtc
//
//  Synopsis:   Initialize object
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
CDataAdviseTestFormatEtc::CDataAdviseTestFormatEtc(void)
{
    _formatetc.cfFormat = RegisterClipboardFormat("OleTest Storage Format");
    _formatetc.ptd = NULL;
    _formatetc.dwAspect = DVASPECT_CONTENT;
    _formatetc.lindex = -1;
    _formatetc.tymed = TYMED_ISTORAGE;
}




//+-------------------------------------------------------------------------
//
//  Member:     CDataAdviseTestFormatEtc::GetFormatEtc
//
//  Synopsis:   Get pointer to standard format etc
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
FORMATETC *CDataAdviseTestFormatEtc::GetFormatEtc(void)
{
    return &_formatetc;
}




// Global Formatec for all the data advise tests
CDataAdviseTestFormatEtc g_datfeDaTest;




//+-------------------------------------------------------------------------
//
//  Class:      CTestAdviseSink
//
//  Purpose:    Advise sink used to verify data advise holder
//
//  Interface:  QueryInterface - get new interface pointer
//              AddRef - bump reference count
//              Release - decrement reference count
//              OnDataChange - data change notification
//              OnViewChange - not implemented
//              OnRename - not implemented
//              OnSave - not implemented
//              OnClose - not implemented
//              ValidOnDataChange - verify all expected data change notification
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//  Notes:      We only implement interface methods required for
//              test of data advise holder.
//
//--------------------------------------------------------------------------
class CTestAdviseSink : public IAdviseSink
{
public:
                        CTestAdviseSink(CGenDataObject *pgdo);

    // IUnknown methods
    STDMETHOD(QueryInterface)(REFIID riid, LPVOID FAR* ppvObj);

    STDMETHOD_(ULONG, AddRef)(void);

    STDMETHOD_(ULONG, Release)(void);

    // IAdviseSink methods
    STDMETHOD_(void, OnDataChange)(FORMATETC *pFormatetc, STGMEDIUM *pStgmed);

    STDMETHOD_(void, OnViewChange)(
                            DWORD dwAspect,
                            LONG lindex);

    STDMETHOD_(void, OnRename)(IMoniker *pmk);

    STDMETHOD_(void, OnSave)(void);

    STDMETHOD_(void, OnClose)(void);

    // Test methods used for verification
    BOOL                ValidOnDataChange(void);

private:

    LONG                _lRefs;

    CGenDataObject *    _pgdo;

    BOOL                _fValidOnDataChange;

};



//+-------------------------------------------------------------------------
//
//  Member:     CTestAdviseSink::CTestAdviseSink
//
//  Synopsis:   Initialize object
//
//  Arguments:  [pgdo] - generic data object
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//  Notes:      pgdo being NULL means we don't expect a STGMEDIUM when
//              the OnDataChange notification occurs.
//
//--------------------------------------------------------------------------
CTestAdviseSink::CTestAdviseSink(CGenDataObject *pgdo)
    : _lRefs(1), _fValidOnDataChange(FALSE)
{
    _pgdo = pgdo;
}




//+-------------------------------------------------------------------------
//
//  Member:     CTestAdviseSink::QueryInterface
//
//  Synopsis:   Return a new interface
//
//  Arguments:  [riid] - interface id requested
//              [ppvObj] - where to put the interface
//
//  Returns:    S_OK - we are returning an interface
//              E_NOINTERFACE - we do not support the requested interface
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
STDMETHODIMP CTestAdviseSink::QueryInterface(
    REFIID riid,
    LPVOID *ppvObj)
{
    if (IsEqualGUID(IID_IUnknown, riid) || IsEqualGUID(IID_IAdviseSink, riid))
    {
        AddRef();
        *ppvObj = this;
        return NOERROR;
    }

    *ppvObj = NULL;

    return E_NOINTERFACE;
}




//+-------------------------------------------------------------------------
//
//  Member:     CTestAdviseSink::AddRef
//
//  Synopsis:   Bump reference count
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CTestAdviseSink::AddRef(void)
{
    return _lRefs++;
}




//+-------------------------------------------------------------------------
//
//  Member:     CTestAdviseSink::Release
//
//  Synopsis:   Decrement reference count
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CTestAdviseSink::Release(void)
{
    assert(_lRefs >= 1);

    return --_lRefs;
}




//+-------------------------------------------------------------------------
//
//  Member:     CTestAdviseSink::OnDataChange
//
//  Synopsis:   Notify of change in data
//
//  Arguments:  [pFormatetc] - FORMATETC of data
//              [pStgmed] - storage medium for data
//
//  Algorithm:  Verify that the we recieved the expected FORMATEC. Then
//              verify that we recieved the expected STGMEDIUM.
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
STDMETHODIMP_(void) CTestAdviseSink::OnDataChange(
    FORMATETC *pFormatetc,
    STGMEDIUM *pStgmed)
{
    // Verify the format
    if (memcmp(g_datfeDaTest.GetFormatEtc(), pFormatetc, sizeof(FORMATETC))
        == 0)
    {
        if (_pgdo != NULL)
        {
            // We have a data object that we can use to verify the format
            // so we do.
            _fValidOnDataChange =
                _pgdo->VerifyFormatAndMedium(pFormatetc, pStgmed);
        }
        // We are expecting an empty STGMEDIUM so verify that it is
        else if ((pStgmed->tymed == TYMED_NULL)
            && (pStgmed->pUnkForRelease == NULL))
        {
            _fValidOnDataChange = TRUE;
        }
    }
}




//+-------------------------------------------------------------------------
//
//  Member:     CTestAdviseSink::OnViewChange
//
//  Synopsis:   Notify that view should change
//
//  Arguments:  [dwAspect] - specifies view of the object
//              [lindex] -  which piece of view changed
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//  Notes:      Not supported for this object
//
//--------------------------------------------------------------------------
STDMETHODIMP_(void) CTestAdviseSink::OnViewChange(
    DWORD dwAspect,
    LONG lindex)
{
    OutputString("CTestAdviseSink::OnViewChange Unexpectedly Called!\r\n");
}




//+-------------------------------------------------------------------------
//
//  Member:     CTestAdviseSink::OnRename
//
//  Synopsis:   Notifies of rename operation
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//  Notes:      Not supported for this object
//
//--------------------------------------------------------------------------
STDMETHODIMP_(void) CTestAdviseSink::OnRename(IMoniker *pmk)
{
    OutputString("CTestAdviseSink::OnRename Unexpectedly Called!\r\n");
}




//+-------------------------------------------------------------------------
//
//  Member:     CTestAdviseSink::OnSave
//
//  Synopsis:   Notify that object was saved
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//  Notes:      Not supported for this object
//
//--------------------------------------------------------------------------
STDMETHODIMP_(void) CTestAdviseSink::OnSave(void)
{
    OutputString("CTestAdviseSink::OnSave Unexpectedly Called!\r\n");
}



//+-------------------------------------------------------------------------
//
//  Member:     CTestAdviseSink::OnClose
//
//  Synopsis:   Notify object closed
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//  Notes:      Not supported for this object
//
//--------------------------------------------------------------------------
STDMETHODIMP_(void) CTestAdviseSink::OnClose(void)
{
    OutputString("CTestAdviseSink::OnClose Unexpectedly Called!\r\n");
}




//+-------------------------------------------------------------------------
//
//  Member:     CTestAdviseSink::ValidOnDataChange
//
//  Synopsis:   Verify that we recieved the expected OnDataChange notification
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
BOOL CTestAdviseSink::ValidOnDataChange(void)
{
    BOOL fResult = _fValidOnDataChange;
    _fValidOnDataChange = FALSE;
    return fResult;
}


// Preallocated structure used to mass advise registration testing
#define MAX_REGISTER 100
struct
{
    CTestAdviseSink *   ptas;
    DWORD               dwConnection;
} aMassAdvise[MAX_REGISTER];




//+-------------------------------------------------------------------------
//
//  Class:      CTestDaHolder
//
//  Purpose:    Test enumerator for data advise holder
//
//  Interface:  Verify - verify particular entry being enumerated
//              VerifyAllEnmerated - verify all entries were enumerated once
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
class CTestDaHolder : public CEnumeratorTest
{
public:

                        CTestDaHolder(IEnumSTATDATA *penumAdvise, HRESULT& rhr);

    BOOL                Verify(void *);

    BOOL                VerifyAllEnmerated(void);

    BOOL                VerifyAll(void *, LONG);

private:

    DWORD               _cdwFound[MAX_REGISTER];
};




//+-------------------------------------------------------------------------
//
//  Member:     CTestDaHolder::CTestDaHolder
//
//  Synopsis:   Initialize object
//
//  Arguments:  [penumAdvise] - data advise holder enumerator
//              [rhr] - HRESULT reference thorugh which to return an error
//
//  Algorithm:
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
CTestDaHolder::CTestDaHolder(IEnumSTATDATA *penumAdvise, HRESULT& rhr)
    : CEnumeratorTest(penumAdvise, sizeof(STATDATA), MAX_REGISTER, rhr)
{
    // Zero out our table of counts
    memset(&_cdwFound[0], 0, sizeof(_cdwFound));
}




//+-------------------------------------------------------------------------
//
//  Member:     CTestDaHolder::VerifyAllEnmerated
//
//  Synopsis:   Verify all objects got enumerated
//
//  Returns:    TRUE - all objects enumerated
//              FALSE - error in enumeration
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
BOOL CTestDaHolder::VerifyAllEnmerated(void)
{
    for (int i = 0; i < MAX_REGISTER; i++)
    {
        if (_cdwFound[i] != 1)
        {
            OutputString("Entry %d enumerated %d times\r\n", i, _cdwFound[i]);
            return FALSE;
        }

        // Reset for another test
        _cdwFound[i] = 0;
    }

    return TRUE;
}



//+-------------------------------------------------------------------------
//
//  Member:     CTestDaHolder::Verify
//
//  Synopsis:   Verify an enumeration entry
//
//  Arguments:  [pvEntry] - entry enumerated
//
//  Returns:    TRUE - enumerated entry is valid
//              FALSE - obvious error in enumeration
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
BOOL CTestDaHolder::Verify(void *pvEntry)
{
    STATDATA *pstatdata = (STATDATA *) pvEntry;

    // Verify the advf field
    if ((pstatdata->advf == 0)
        && (memcmp(g_datfeDaTest.GetFormatEtc(), &pstatdata->formatetc,
            sizeof(FORMATETC)) == 0))
    {
        // Can we find the connection?
        for (int i = 0; i < MAX_REGISTER; i++)
        {
            if (pstatdata->dwConnection == aMassAdvise[i].dwConnection)
            {
                // Bump found count
                _cdwFound[i]++;

                // Everything is OK so tell the caller
                return TRUE;
            }
        }
    }

    return FALSE;
}



//+-------------------------------------------------------------------------
//
//  Member:     CTestDaHolder::VerifyAll
//
//  Synopsis:   Verify that an array of all entries is valid
//
//  Arguments:  [pvEntries] - array of enumerated data
//              [clEntries] - number of enumerated entries
//
//  Returns:    TRUE - enumerated entry is valid
//              FALSE - obvious error in enumeration
//
//  History:    dd-mmm-yy Author    Comment
//              02-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
BOOL CTestDaHolder::VerifyAll(void *pvEntries, LONG clEntries)
{
    // Verify that the count is as expected.
    if (clEntries != MAX_REGISTER)
    {
        return FALSE;
    }

    // Verify each entry in the array is reasonable
    STATDATA *pstatdata = (STATDATA *) pvEntries;

    for (int i = 0; i < MAX_REGISTER; i++, pstatdata++)
    {
        if (!Verify(pstatdata))
        {
            return FALSE;
        }
    }

    // Verify that each entry was only referred to once
    return VerifyAllEnmerated();
}





//+-------------------------------------------------------------------------
//
//  Function:   TestPrimeFirstOnlyOnceNoData
//
//  Synopsis:   Test one notification of
//              ADVF_NODATA | ADVF_PRIMEFIRST | ADVF_ONLYONCE
//
//  Arguments:  [pdahTest] - data advise holder we are testing
//              [pgdo] - generic data object
//
//  Returns:    NOERROR - notification was correct
//              E_FAIL - error in notification
//
//  Algorithm:  Create an test advise sink object. Register it with the
//              advise holder which should cause the notification. Verify
//              that the advise was notified and that no connection was
//              returned.
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT TestPrimeFirstOnlyOnceNoData(
    IDataAdviseHolder *pdahTest,
    CGenDataObject *pgdo)
{
    // Create an advise sink - the NULL means we don't want to validate
    // the STGMEDIUM.
    CTestAdviseSink tas(NULL);

    DWORD dwConnection = 0;

    // Register the advise
    HRESULT hr = pdahTest->Advise(pgdo, g_datfeDaTest.GetFormatEtc(),
        ADVF_NODATA | ADVF_PRIMEFIRST | ADVF_ONLYONCE, &tas, &dwConnection);

    // Confirm that the advise is notified and in the correct state
    if (!tas.ValidOnDataChange())
    {
        OutputString("TestPrimeFirstOnlyOnceNoData OnDataChange invalid!\r\n");
        return E_FAIL;
    }

    // Make sure the advise was not registered
    if (dwConnection != 0)
    {
        OutputString("TestPrimeFirstOnlyOnceNoData got Connection!\r\n");
        return E_FAIL;
    }

    return NOERROR;
}


//+-------------------------------------------------------------------------
//
//  Function:   TestPrimeFirstOnlyOnceData
//
//  Synopsis:   Test one notification of
//              ADVF_PRIMEFIRST | ADVF_ONLYONCE
//
//  Arguments:  [pdahTest] - data advise holder we are testing
//              [pgdo] - generic data object
//
//  Returns:    NOERROR - notification was correct
//              E_FAIL - error in notification
//
//  Algorithm:  Create an test advise sink object. Register it with the
//              advise holder which should cause the notification. Verify
//              that the advise was notified and that no connection was
//              returned.
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT TestPrimeFirstOnlyOnceData(
    IDataAdviseHolder *pdahTest,
    CGenDataObject *pgdo)
{
    // Create an advise sink that we can verify the STGMEDIUM
    CTestAdviseSink tas(pgdo);

    // Where to store the connection
    DWORD dwConnection = 0;

    // Register the advise
    HRESULT hr = pdahTest->Advise(pgdo, g_datfeDaTest.GetFormatEtc(),
        ADVF_PRIMEFIRST | ADVF_ONLYONCE, &tas, &dwConnection);

    // Confirm that the advise is notified and in the correct state
    if (!tas.ValidOnDataChange())
    {
        OutputString("TestPrimeFirstOnlyOnceData OnDataChange invalid!\r\n");
        return E_FAIL;
    }

    // Make sure the advise was not registered
    if (dwConnection != 0)
    {
        OutputString("TestPrimeFirstOnlyOnceData got Connection!\r\n");
        return E_FAIL;
    }

    return NOERROR;
}



//+-------------------------------------------------------------------------
//
//  Function:   DoRegisterNotifyDeregister
//
//  Synopsis:
//
//  Arguments:  [pdahTest] - data advise holder we are testing
//              [pdo] - IDataObject interface
//              [pgdo] - generic data object
//              [advf] - advise flags to use
//              [pszCaller] - name of test
//
//  Returns:    NOERROR - notification was correct
//              E_FAIL - error in notification
//
//  Algorithm:  Create a test advise sink object. Register for an notification
//              with the data advise holder. Confirm that the prime first
//              notification worked. Confirm that the object did get
//              registered. Tell the advise holder to notify all registered
//              advises that the data changed. Confirm that the appropriate
//              notification was sent. Then deregister the advise. Do it
//              again to make sure the connection is no longer valid.
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT DoRegisterNotifyDeregister(
    IDataAdviseHolder *pdahTest,
    IDataObject *pdo,
    CGenDataObject *pgdo,
    DWORD advf,
    char *pszCaller)
{
    // Create an advise sink that we can verify the STGMEDIUM
    CTestAdviseSink tas(pgdo);

    // Where to store the connection
    DWORD dwConnection;

    // Register the advise
    HRESULT hr = pdahTest->Advise(pdo, g_datfeDaTest.GetFormatEtc(),
        ADVF_PRIMEFIRST | advf, &tas, &dwConnection);

    // Confirm that the advise is notified and in the correct state
    if (!tas.ValidOnDataChange())
    {
        OutputString("%s First OnDataChange invalid!\r\n", pszCaller);
        return E_FAIL;
    }

    // Make sure the advise is registered
    if (dwConnection == 0)
    {
        OutputString("%s did not get Connection!\r\n", pszCaller);
        return E_FAIL;
    }

    // Test regular data change
    hr = pdahTest->SendOnDataChange(pdo, 0, 0);

    if (hr != NOERROR)
    {
        OutputString("%s SendOnDataChange unexpected HRESULT = %lx!\r\n",
            pszCaller, hr);
        return E_FAIL;
    }

    // Confirm that the advise is notified and in the correct state
    if (!tas.ValidOnDataChange())
    {
        OutputString("%s Second OnDataChange invalid!\r\n", pszCaller);
        return E_FAIL;
    }

    // Test unadvise
    hr = pdahTest->Unadvise(dwConnection);

    if (hr != NOERROR)
    {
        OutputString("%s Unadvise unexpected HRESULT = %lx!\r\n", pszCaller, hr);
        return E_FAIL;
    }

    // Test second unadvise on the same connection
    hr = pdahTest->Unadvise(dwConnection);

    if (hr != OLE_E_NOCONNECTION)
    {
        OutputString("%s Second Unadvise Bad Hresult = %lx!\r\n", pszCaller, hr);
        return E_FAIL;
    }

    return NOERROR;
}


//+-------------------------------------------------------------------------
//
//  Function:   TestRegisterNotifyDegister
//
//  Synopsis:   Test a simple register/notify/deregister sequence
//
//  Arguments:  [pdahTest] - data advise holder we are testing
//              [pgdo] - generic data object
//
//  Returns:    NOERROR - notification was correct
//              E_FAIL - error in notification
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT TestRegisterNotifyDegister(
    IDataAdviseHolder *pdahTest,
    CGenDataObject *pgdo)
{
    return DoRegisterNotifyDeregister(pdahTest, pgdo, pgdo, 0,
        "TestRegisterNotifyDegister");
}



//+-------------------------------------------------------------------------
//
//  Function:   TestRegisterNotifyDegisterNoData
//
//  Synopsis:   Test a simple register/notify/deregister sequence with
//              no data being returned.
//
//  Arguments:  [pdahTest] - data advise holder we are testing
//              [pgdo] - generic data object
//
//  Returns:    NOERROR - notification was correct
//              E_FAIL - error in notification
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT TestRegisterNotifyDegisterNoData(
    IDataAdviseHolder *pdahTest,
    CGenDataObject *pgdo)
{
    return DoRegisterNotifyDeregister(pdahTest, pgdo, NULL, ADVF_NODATA,
        "TestRegisterNotifyDegisterNoData");
}




//+-------------------------------------------------------------------------
//
//  Function:   TestNotifyOnStop
//
//  Synopsis:   Test a registration with a call of notify on stop
//
//  Arguments:  [pdahTest] - data advise holder we are testing
//              [pgdo] - generic data object
//
//  Returns:    NOERROR - notification was correct
//              E_FAIL - error in notification
//
//  Algorithm:  Create a test object. Register it with the advise holder.
//              Confirm that the connection was returned and that no
//              notification occurred. Then tell the data advise holder
//              to notify its registrations of a data change. Make sure
//              that the advise was correctly notified. Finally, verify
//              that we can deregister the advise and that its connection
//              becomes invalid.
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT  TestNotifyOnStop(
    IDataAdviseHolder *pdahTest,
    CGenDataObject *pgdo)
{
    // Routine name for messages
    char *pszCaller = "TestNotifyOnStop";

    // Create an advise sink that we can verify the STGMEDIUM
    CTestAdviseSink tas(pgdo);

    // Where to store the connection
    DWORD dwConnection;

    // Register the advise
    HRESULT hr = pdahTest->Advise(pgdo, g_datfeDaTest.GetFormatEtc(),
        ADVF_DATAONSTOP, &tas, &dwConnection);

    // Make sure the advise is registered
    if (dwConnection == 0)
    {
        OutputString("%s did not get Connection!\r\n", pszCaller);
        return E_FAIL;
    }

    // Confirm that the data object was not notified
    if (tas.ValidOnDataChange())
    {
        OutputString("%s Registration caused notification!\r\n", pszCaller);
        return E_FAIL;
    }

    // Test regular data change
    hr = pdahTest->SendOnDataChange(pgdo, 0, ADVF_DATAONSTOP);

    if (hr != NOERROR)
    {
        OutputString("%s SendOnDataChange unexpected HRESULT = %lx!\r\n",
            pszCaller, hr);
        return E_FAIL;
    }

    // Confirm that the advise is notified and in the correct state
    if (!tas.ValidOnDataChange())
    {
        OutputString("%s Second OnDataChange invalid!\r\n", pszCaller);
        return E_FAIL;
    }

    // Test unadvise
    hr = pdahTest->Unadvise(dwConnection);

    if (hr != NOERROR)
    {
        OutputString("%s Unadvise unexpected HRESULT = %lx!\r\n", pszCaller, hr);
        return E_FAIL;
    }

    // Test second unadvise on the same connection
    hr = pdahTest->Unadvise(dwConnection);

    if (hr != OLE_E_NOCONNECTION)
    {
        OutputString("%s Second Unadvise Bad Hresult = %lx!\r\n", pszCaller, hr);
        return E_FAIL;
    }

    return NOERROR;
}




//+-------------------------------------------------------------------------
//
//  Function:   TestNotifyOnce
//
//  Synopsis:   Test a notify once advise
//
//  Arguments:  [pdahTest] - data advise holder we are testing
//              [pgdo] - generic data object
//
//  Returns:    NOERROR - notification was correct
//              E_FAIL - error in notification
//
//  Algorithm:  Create a test advise object. Register it to be advised only
//              once of a change. Confirm that we got a registration. Then
//              tell the advise holder to notify its advises of a data
//              change. Confirm that the correct notification occurred. Finally,
//              confirm that we are no longer registered with the advise
//              holder.
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT  TestNotifyOnce(
    IDataAdviseHolder *pdahTest,
    CGenDataObject *pgdo)
{
    // Routine name for messages
    char *pszCaller = "TestNotifyOnce";

    // Create an advise sink that we can verify the STGMEDIUM
    CTestAdviseSink tas(pgdo);

    // Where to store the connection
    DWORD dwConnection;

    // Register the advise
    HRESULT hr = pdahTest->Advise(pgdo, g_datfeDaTest.GetFormatEtc(),
        ADVF_ONLYONCE, &tas, &dwConnection);

    // Make sure the advise is registered
    if (dwConnection == 0)
    {
        OutputString("%s did not get Connection!\r\n", pszCaller);
        return E_FAIL;
    }

    // Test regular data change
    hr = pdahTest->SendOnDataChange(pgdo, 0, 0);

    if (hr != NOERROR)
    {
        OutputString("%s SendOnDataChange unexpected HRESULT = %lx!\r\n",
            pszCaller, hr);
        return E_FAIL;
    }

    // Confirm that the advise is notified and in the correct state
    if (!tas.ValidOnDataChange())
    {
        OutputString("%s Send OnDataChange invalid!\r\n", pszCaller);
        return E_FAIL;
    }

    // Try a second notify
    hr = pdahTest->SendOnDataChange(pgdo, 0, 0);


    // Confirm that the advise is *not* notified
    if (tas.ValidOnDataChange())
    {
        OutputString("%s Second OnDataChange unexpectedly succeeded!\r\n",
            pszCaller);
        return E_FAIL;
    }

    // Test unadvise - should fail since we requested to be notified
    // only once.
    hr = pdahTest->Unadvise(dwConnection);

    if (hr != OLE_E_NOCONNECTION)
    {
        OutputString("%s Second Unadvise Bad Hresult = %lx!\r\n", pszCaller, hr);
        return E_FAIL;
    }

    return NOERROR;
}




//+-------------------------------------------------------------------------
//
//  Function:   CreateMassRegistration
//
//  Synopsis:   Register a large number of advise objects with a holder
//
//  Arguments:  [pdahTest] - data advise holder we are testing
//              [pgdo] - generic data object
//              [pszCaller] - name of test
//
//  Returns:    NOERROR - all advises were registered
//              E_FAIL - error in registration
//
//  Algorithm:  Create a MAX_REGISTER number of test advise objects and
//              store them in the aMassAdvise array. Then register them
//              all with the input advise holder.
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT CreateMassRegistration(
    IDataAdviseHolder *pdahTest,
    CGenDataObject *pgdo,
    char *pszCaller)
{
    // Create the advise sinks for the test for the test
    for (int i = 0; i < MAX_REGISTER; i++)
    {
        aMassAdvise[i].ptas = new CTestAdviseSink(pgdo);

        if (aMassAdvise[i].ptas == NULL)
        {
            OutputString(
                "%s Advise create of test advise failed on %d!\r\n", pszCaller,
                    i);
            return E_FAIL;
        }

        aMassAdvise[i].dwConnection = 0;
    }

    HRESULT hr;

    // Register the advise sinks
    for (i = 0; i < MAX_REGISTER; i++)
    {
        // Register the advise
        hr = pdahTest->Advise(pgdo, g_datfeDaTest.GetFormatEtc(),
            0, aMassAdvise[i].ptas, &aMassAdvise[i].dwConnection);

        if (hr != NOERROR)
        {
            OutputString(
                "%s Advise unexpected HRESULT = %lx on %d!\r\n", pszCaller,
                    hr, i);
            return E_FAIL;
        }
    }

    return S_OK;
}




//+-------------------------------------------------------------------------
//
//  Function:   DoMassUnadvise
//
//  Synopsis:   Deregister all entries in the aMassAdvise array
//
//  Arguments:  [pdahTest] - data advise holder we are testing
//              [pszCaller] - name of test
//
//  Returns:    NOERROR - deregistration worked
//              E_FAIL - error in deregistration
//
//  Algorithm:  For each entry in the aMassAdvise array, deregister it
//              from the holder. Then confirm that its connection is
//              no longer valid.
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT DoMassUnadvise(
    IDataAdviseHolder *pdahTest,
    char *pszCaller)
{
    HRESULT hr;

    // Unadvise them
    for (int i = 0; i < MAX_REGISTER; i++)
    {
        // Test unadvise
        hr = pdahTest->Unadvise(aMassAdvise[i].dwConnection);

        if (hr != NOERROR)
        {
            OutputString(
                "%s Unadvise unexpected HRESULT = %lx on %d!\r\n", pszCaller,
                    hr, i);
            return E_FAIL;
        }

        // Test second unadvise on the same connection
        hr = pdahTest->Unadvise(aMassAdvise[i].dwConnection);

        if (hr != OLE_E_NOCONNECTION)
        {
            OutputString(
                "%s Second Unadvise Bad Hresult = %lx on %d!\r\n", pszCaller,
                    hr, i);
            return E_FAIL;
        }
    }

    // Delete the advise sinks for the test
    for (i = 0; i < MAX_REGISTER; i++)
    {
        delete aMassAdvise[i].ptas ;
    }

    return S_OK;
}




//+-------------------------------------------------------------------------
//
//  Function:   TestMassRegister
//
//  Synopsis:   Test registering a large number of advises with a holder
//
//  Arguments:  [pdahTest] - data advise holder we are testing
//              [pgdo] - generic data object
//
//  Returns:    NOERROR - notification was correct
//              E_FAIL - error in notification
//
//  Algorithm:  Register a large number of test advises with the data advise
//              holder. Then tell the advise holder to notify them of
//              a change. Confirm that all registered entries were notified.
//              Finally, deregister all the test advises.
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT TestMassRegister(
    IDataAdviseHolder *pdahTest,
    CGenDataObject *pgdo)
{
    char *pszCaller = "TestMassRegister";

    HRESULT hr = CreateMassRegistration(pdahTest, pgdo, "TestMassRegister");

    if (hr != NOERROR)
    {
        return hr;
    }

    // Notify them of a change
    hr = pdahTest->SendOnDataChange(pgdo, 0, 0);

    // Verify that each was notified
    for (int i = 0; i < MAX_REGISTER; i++)
    {
        if (!aMassAdvise[i].ptas->ValidOnDataChange())
        {
            OutputString(
                "%s OnDataChange invalid for entry %d!\r\n", pszCaller, i);
            return E_FAIL;
        }
    }

    // Unadvise them and free the memory
    return DoMassUnadvise(pdahTest, "TestMassRegister");
}




//+-------------------------------------------------------------------------
//
//  Function:   TestEnumerator
//
//  Synopsis:   Test the data advise holder enumerator
//
//  Arguments:  [pdahTest] - data advise holder we are testing
//              [pgdo] - generic data object
//
//  Returns:    NOERROR - notification was correct
//              E_FAIL - error in notification
//
//  Algorithm:  Create a large number of test advises and register them
//              with the advise holder. Get an advise enumerator. Create
//              a test enumerator object. Tell the test enumerator object
//              to enumerate all the object in the holder. Verify that
//              all objects were correctly enumerated. Then release the
//              advise holder enumerator. Finally, deregister all the
//              test advises from the advise holder.
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT  TestEnumerator(
    IDataAdviseHolder *pdahTest,
    CGenDataObject *pgdo)
{
    char *pszCaller = "TestEnumerator";

    // Do a mass register
    HRESULT hr = CreateMassRegistration(pdahTest, pgdo, pszCaller);

    if (hr != NOERROR)
    {
        return hr;
    }

    // Get an enumerator for this registration
    IEnumSTATDATA *penumAdvise;

    hr = pdahTest->EnumAdvise(&penumAdvise);

    if (hr != NOERROR)
    {
        OutputString("%s EnumAdvise failed %lx!\r\n", pszCaller, hr);
        return E_FAIL;
    }

    // Create a test enumerator object
    CTestDaHolder tdh(penumAdvise, hr);

    if (hr != NOERROR)
    {
        OutputString(
            "%s Failed creating  CTestDaHolder %lx!\r\n", pszCaller, hr);
        return E_FAIL;
    }

    // Enmerate all 1 by 1
    if (tdh.TestNext() != NOERROR)
    {
        OutputString(
            "%s tdh.TestNext failed during enumeration\r\n", pszCaller);
        return E_FAIL;
    }

    // Verify that all entries were enumerated
    if (!tdh.VerifyAllEnmerated())
    {
        OutputString(
            "%s tdh.VerifyAllEnmerated failed verification pass\r\n", pszCaller);
        return E_FAIL;
    }

    // Do a test all
    if (tdh.TestAll() != NOERROR)
    {
        OutputString(
            "%s tdh.TestAll failed during enumeration\r\n", pszCaller);
        return E_FAIL;
    }

    // Release the advise enumerator
    if (penumAdvise->Release() != 0)
    {
        OutputString(
            "%s Failed freeing advise enumerator %lx!\r\n", pszCaller, hr);
        return E_FAIL;
    }

    // Release the registrations
    return DoMassUnadvise(pdahTest, pszCaller);
}




//+-------------------------------------------------------------------------
//
//  Function:   LEDataAdviseHolderTest
//
//  Synopsis:   Unit test for the data advise holder.
//
//  Returns:    NOERROR - test passed
//              E_FAIL - test failed.
//
//  Algorithm:  Create an advise holder object. Run through all the test
//              cases. Return NOERROR if they succeed or stop with the first
//              that fails.
//
//  History:    dd-mmm-yy Author    Comment
//              01-Jun-94 Ricksa    Created
//
//--------------------------------------------------------------------------
HRESULT LEDataAdviseHolderTest(void)
{
    // Create a data object for use in the test
    CGenDataObject *pgdo = new CGenDataObject;

    assert(pgdo);

    // Create a data advise holder
    IDataAdviseHolder *pdahTest;

    HRESULT hr = CreateDataAdviseHolder(&pdahTest);

    if (hr != NOERROR)
    {
        OutputString(
            "LEDataAdviseHolderTest CreateDataAdviseHolder Faild hr = %lx", hr);
        return hr;
    }

    // Case 1: ADVF_PRIMEFIRST & ADVF_ONLYONCE & ADVF_NODATA
    if ((hr = TestPrimeFirstOnlyOnceNoData(pdahTest, pgdo)) != NOERROR)
    {
        return hr;
    }

    // Case 2: ADVF_PRIMEFIRST
    if ((hr = TestPrimeFirstOnlyOnceNoData(pdahTest, pgdo)) != NOERROR)
    {
        return hr;
    }

    // Case 3: Register/Notify/Deregister
    if ((hr = TestRegisterNotifyDegister(pdahTest, pgdo)) != NOERROR)
    {
        return hr;
    }

    // Case 4: Register/Notify/Deregister with no data returned
    if ((hr = TestRegisterNotifyDegisterNoData(pdahTest, pgdo)) != NOERROR)
    {
        return hr;
    }

    // Case 5: Test notify on stop
    if ((hr = TestNotifyOnStop(pdahTest, pgdo)) != NOERROR)
    {
        return hr;
    }

    // Case 6: Test notify only once
    if ((hr = TestNotifyOnce(pdahTest, pgdo)) != NOERROR)
    {
        return hr;
    }

    // Case 7: Test mass Register/Notify/Deregister
    if ((hr = TestMassRegister(pdahTest, pgdo)) != NOERROR)
    {
        return hr;
    }

    // Case 8: Test Enumerator
    if ((hr = TestEnumerator(pdahTest, pgdo)) != NOERROR)
    {
        return hr;
    }

    // We are done
    DWORD dwFinalRefs = pdahTest->Release();

    if (dwFinalRefs != 0)
    {
        OutputString(
            "LEDataAdviseHolderTest Final Release is = %d", dwFinalRefs);
        return E_FAIL;
    }

    pgdo->Release();

    return NOERROR;
}