mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
513 lines
15 KiB
513 lines
15 KiB
// csdrtcat.cxx
|
|
|
|
// This runs the following tests.
|
|
// Adds two classes catclsid1, catclsid2
|
|
|
|
// adds 3 categories
|
|
// 1 with 1 desc and locale id.
|
|
// 2 with 2 desc and locale id.
|
|
// 3 without 1 desc and locale id 2.
|
|
//
|
|
// register 2 categories in the req. list for catclsid1. (cat1, cat2)
|
|
// register 1 impl category in the impl list for catclsid1 (cat3)
|
|
//
|
|
// register 2 in the the impl for the catclsid2.(cat2, cat3)
|
|
//
|
|
// unregister 1 cat frm the req list for catclsid1 (cat2)
|
|
// register that one for impl list of catclsid1 (cat2)
|
|
//
|
|
//
|
|
// Info tests confirmations as well as tests.
|
|
//
|
|
// Enumcat result should be two. Match descriptions.
|
|
// EnumImplCategories of clsid1 should be 2. (cat2, cat3)
|
|
// EnumReqCategories of clsid2 should be zero.
|
|
//
|
|
// Enumclasses of categories with (req: cat1, cat3) (impl: cat2) should be two.
|
|
//
|
|
// GetCategoryDesc with the other locale id than the one used in EnumCat. cat2
|
|
// with any locale id cat3.
|
|
//
|
|
// IsClassOfCategories clsid1 impl cat2, req: cat1 answer should be S_OK
|
|
//
|
|
//
|
|
|
|
#include "csdrt.hxx"
|
|
extern BOOL fVerbose;
|
|
|
|
GUID catClsid1;
|
|
GUID catClsid2;
|
|
GUID testCatid1;
|
|
GUID testCatid2;
|
|
GUID testCatid3;
|
|
|
|
Sname testCatDesc1, testCatDesc2, testCatDesc21, testCatDesc3, TestCatClassDesc1, TestCatClassDesc2;
|
|
Sname testCatPackName1, testCatPackName2;
|
|
LCID TestCatLocale1, TestCatLocale2;
|
|
|
|
LPOLESTR testConstCatDesc1 = L"CS DRT Test Category Desc, 1 (Locale same as Thread)";
|
|
LPOLESTR testConstCatDesc2 = L"CS DRT Test Category Desc, 2 (Locale same as Thread)";
|
|
LPOLESTR testConstCatDesc21 = L"CS DRT Test Category Desc, 2 (Locale = Thread Locale + 1)";
|
|
LPOLESTR testConstCatDesc3 = L"CS DRT Test Category Desc, 3 (Locale = Thread Locale + 1)";
|
|
|
|
LPOLESTR testConstCatClassDesc1 = L"CS DRT Class id 1 for comcat test";
|
|
LPOLESTR testConstCatClassDesc2 = L"CS DRT Class id 2 for comcat test";
|
|
|
|
LPOLESTR testConstCatPackName1 = L"CS DRT Test Comcat Pack 1";
|
|
LPOLESTR testConstCatPackName2 = L"CS DRT Test Comcat Pack 2";
|
|
|
|
|
|
void InitCatTempNames()
|
|
{
|
|
CreateGuid(&catClsid1);
|
|
CreateGuid(&catClsid2);
|
|
|
|
CreateGuid(&testCatid1);
|
|
CreateGuid(&testCatid2);
|
|
CreateGuid(&testCatid3);
|
|
|
|
CreateUnique(testCatDesc1, testConstCatDesc1);
|
|
CreateUnique(testCatDesc2, testConstCatDesc2);
|
|
CreateUnique(testCatDesc21, testConstCatDesc21);
|
|
CreateUnique(testCatDesc3, testConstCatDesc3);
|
|
|
|
CreateUnique(TestCatClassDesc1, testConstCatClassDesc1);
|
|
CreateUnique(TestCatClassDesc2, testConstCatClassDesc2);
|
|
|
|
TestCatLocale1 = GetThreadLocale();
|
|
TestCatLocale2 = 2*TestCatLocale1 + 1;
|
|
|
|
CreateUnique(testCatPackName1, testConstCatPackName1);
|
|
CreateUnique(testCatPackName2, testConstCatPackName2);
|
|
}
|
|
|
|
void ReleaseObj(GUID obj)
|
|
{
|
|
}
|
|
|
|
void ReleaseObj(CATEGORYINFO obj)
|
|
{
|
|
}
|
|
|
|
|
|
HRESULT CreateCatClasses(IClassAdmin *pIClassAdmin1, IClassAdmin *pIClassAdmin2)
|
|
{
|
|
// CLASSDETAIL ClassDetail;
|
|
// PACKAGEDETAIL PackageDetail;
|
|
HRESULT hr = S_OK;
|
|
|
|
// adding classes--------------------------------
|
|
|
|
InitCatTempNames();
|
|
|
|
// memset (&ClassDetail, NULL, sizeof (CLASSDETAIL));
|
|
// memcpy (&ClassDetail.Clsid, &catClsid1, sizeof (GUID));
|
|
//
|
|
// memset(&PackageDetail, 0, sizeof(PACKAGEDETAIL));
|
|
// PackageDetail.pActInfo->cClasses = 1;
|
|
// PackageDetail.pActInfo->pClasses = (CLASSDETAIL *)CoTaskMemAlloc(sizeof(CLASSDETAIL));
|
|
// PackageDetail.pActInfo->pClasses[0] = ClassDetail;
|
|
//
|
|
// hr = pIClassAdmin1->AddPackage(testCatPackName1, &PackageDetail);
|
|
// if (!SUCCEEDED(hr))
|
|
// {
|
|
// printf ("ERROR! 1. NewPackage() in CatTest returned 0x%x.\n", hr);
|
|
// return hr;
|
|
// }
|
|
//
|
|
// PackageDetail.pActInfo->pClasses[0].Clsid = catClsid2;
|
|
//
|
|
// if (pIClassAdmin2)
|
|
// hr = pIClassAdmin2->AddPackage(testCatPackName2, &PackageDetail);
|
|
// else
|
|
// hr = pIClassAdmin1->AddPackage(testCatPackName2, &PackageDetail);
|
|
//
|
|
// if (!SUCCEEDED(hr))
|
|
// {
|
|
// printf ("ERROR! 2. NewPackage() in CatTest returned 0x%x.\n", hr);
|
|
// return hr;
|
|
// }
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT RegCategories(ICatRegister *pICatRegister1, ICatRegister *pICatRegister2)
|
|
{
|
|
HRESULT hr;
|
|
CATEGORYINFO CategoryInfo;
|
|
|
|
// adding categories---------------------------
|
|
|
|
memset (&CategoryInfo, NULL, sizeof (CATEGORYINFO));
|
|
memcpy(&CategoryInfo.catid, &testCatid1, sizeof(GUID));
|
|
CategoryInfo.lcid = TestCatLocale1;
|
|
wcscpy(CategoryInfo.szDescription, testCatDesc1);
|
|
|
|
hr = pICatRegister1->RegisterCategories(1, &CategoryInfo);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! 1. RegisterCategories in CatTest returned 0x%x.\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
memset (&CategoryInfo, NULL, sizeof (CATEGORYINFO));
|
|
memcpy(&CategoryInfo.catid, &testCatid2, sizeof(GUID));
|
|
CategoryInfo.lcid = TestCatLocale1;
|
|
wcscpy(CategoryInfo.szDescription, testCatDesc2);
|
|
|
|
hr = pICatRegister1->RegisterCategories(1, &CategoryInfo);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! 2. RegisterCategories in CatTest returned 0x%x.\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
memset (&CategoryInfo, NULL, sizeof (CATEGORYINFO));
|
|
memcpy(&CategoryInfo.catid, &testCatid2, sizeof(GUID));
|
|
CategoryInfo.lcid = TestCatLocale2;
|
|
wcscpy(CategoryInfo.szDescription, testCatDesc21);
|
|
|
|
hr = pICatRegister1->RegisterCategories(1, &CategoryInfo);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! 3. RegisterCategories in CatTest returned 0x%x.\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
memset (&CategoryInfo, NULL, sizeof (CATEGORYINFO));
|
|
memcpy(&CategoryInfo.catid, &testCatid3, sizeof(GUID));
|
|
CategoryInfo.lcid = TestCatLocale2;
|
|
wcscpy(CategoryInfo.szDescription, testCatDesc3);
|
|
|
|
if (pICatRegister2)
|
|
hr = pICatRegister2->RegisterCategories(1, &CategoryInfo);
|
|
else
|
|
hr = pICatRegister1->RegisterCategories(1, &CategoryInfo);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! 4. RegisterCategories in CatTest returned 0x%x.\n", hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT RegCategoriesWithClasses(ICatRegister *pICatRegister1,
|
|
ICatRegister *pICatRegister2)
|
|
{
|
|
GUID guids[4];
|
|
HRESULT hr=S_OK;
|
|
// registering implemented and required categories.--------------
|
|
|
|
guids[0] = testCatid1;
|
|
guids[1] = testCatid2;
|
|
hr = pICatRegister1->RegisterClassReqCategories(catClsid1, 2, guids);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! 1. RegisterClassReqCategories in CatTest returned 0x%x.\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
hr = pICatRegister1->RegisterClassImplCategories(catClsid1, 1, &testCatid3);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! 1. RegisterClassImplCategories in CatTest returned 0x%x.\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
|
|
guids[0] = testCatid2;
|
|
guids[1] = testCatid3;
|
|
if (pICatRegister2)
|
|
hr = pICatRegister2->RegisterClassImplCategories(catClsid2, 2, guids);
|
|
else
|
|
hr = pICatRegister1->RegisterClassImplCategories(catClsid2, 2, guids);
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! 2. RegisterClassImplCategories in CatTest returned 0x%x.\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
hr = pICatRegister1->UnRegisterClassReqCategories(catClsid1, 1, &testCatid2);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! 1. UnRegisterClassReqCategories in CatTest returned 0x%x.\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
hr = pICatRegister1->RegisterClassImplCategories(catClsid1, 1, &testCatid2);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! 1. RegisterClassImplCategories in CatTest returned 0x%x.\n", hr);
|
|
return hr;
|
|
}
|
|
return hr;
|
|
}
|
|
void VerbosePrintObj(CATEGORYINFO catinfo)
|
|
{
|
|
VerbosePrint("Description %S\n", catinfo.szDescription);
|
|
}
|
|
|
|
void VerbosePrintObj(GUID guid)
|
|
{
|
|
|
|
}
|
|
|
|
HRESULT DoEnumCatsOfClassesTest(ICatInformation *pICatInformation)
|
|
{
|
|
HRESULT hr=S_OK;
|
|
IEnumGUID *pIEnumGUID = NULL;
|
|
GUID guids[4];
|
|
LPOLESTR szDesc;
|
|
ULONG got;
|
|
|
|
// Enumerating Implemented Categories-------------------------
|
|
|
|
hr = pICatInformation->EnumImplCategoriesOfClass(catClsid1, &pIEnumGUID);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! EnumImplCategoriesOfClass in CatTest returned 0x%x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
hr = EnumTests<IEnumGUID, GUID>(pIEnumGUID, 2, NULL, 0, 0, FALSE);
|
|
|
|
// Enumerating Required Categories-------------------------
|
|
|
|
hr = pICatInformation->EnumReqCategoriesOfClass(catClsid1, &pIEnumGUID);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! EnumImplCategoriesOfClass in CatTest returned 0x%x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! EnumReqCategoriesOfClass in CatTest returned 0x%x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
hr = EnumTests<IEnumGUID, GUID>(pIEnumGUID, 1, NULL, 0, 0, FALSE);
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT DoEnumClassesOfCats(ICatInformation *pICatInformation)
|
|
{
|
|
HRESULT hr=S_OK;
|
|
IEnumGUID *pIEnumGUID = NULL;
|
|
GUID guids[4];
|
|
ULONG got;
|
|
|
|
// Enumerating classes of categories--------------------------------
|
|
guids[0] = testCatid1;
|
|
guids[1] = testCatid3;
|
|
hr = pICatInformation->EnumClassesOfCategories(1, &testCatid2, 2, guids, &pIEnumGUID);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! EnumClassesOfCategories in CatTest returned 0x%x\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
EnumTests<IEnumGUID, GUID>(pIEnumGUID, 2, NULL, 0, 0, FALSE);
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CatCleanup(ICatRegister *pICatRegister1, ICatRegister *pICatRegister2)
|
|
{
|
|
HRESULT hr;
|
|
// Removing the categories at the end of the test.-----------------
|
|
|
|
hr = pICatRegister1->UnRegisterCategories(1, &testCatid1);
|
|
if (FAILED(hr))
|
|
printf ("ERROR! 1. UnRegisterCategories() in CatTest returned 0x%x.\n", hr);
|
|
|
|
hr = pICatRegister1->UnRegisterCategories(1, &testCatid2);
|
|
if (FAILED(hr))
|
|
printf ("ERROR! 2. UnRegisterCategories() in CatTest returned 0x%x.\n", hr);
|
|
|
|
if (pICatRegister2)
|
|
hr = pICatRegister2->UnRegisterCategories(1, &testCatid3);
|
|
else
|
|
hr = pICatRegister1->UnRegisterCategories(1, &testCatid3);
|
|
|
|
if (FAILED(hr))
|
|
printf ("ERROR! 3. UnRegisterCategories() in CatTest returned 0x%x.\n", hr);
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CatClassCleanup(IClassAdmin *pIClassAdmin1, IClassAdmin *pIClassAdmin2)
|
|
{
|
|
HRESULT hr;
|
|
|
|
// Removing the classes and at the end of the test.--------------
|
|
// hr = pIClassAdmin1->RemovePackage(testCatPackName1, 0);
|
|
// if (FAILED(hr))
|
|
// printf ("ERROR! 1. RemovePackage() in CatTest returned 0x%x.\n", hr);
|
|
|
|
if (pIClassAdmin2)
|
|
hr = pIClassAdmin2->RemovePackage(testCatPackName2, 0);
|
|
else
|
|
hr = pIClassAdmin1->RemovePackage(testCatPackName2, 0);
|
|
|
|
if (FAILED(hr))
|
|
printf ("ERROR! 2. RemovePackage() in CatTest returned 0x%x.\n", hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT DoCatTests(IClassAdmin *pIClassAdmin1, IClassAdmin *pIClassAdmin2)
|
|
{
|
|
HRESULT hr=S_OK, hr1=S_OK;
|
|
CATEGORYINFO CategoryInfo;
|
|
ICatRegister *pICatRegister1=NULL, *pICatRegister2=NULL;
|
|
ICatInformation *pICatInformation = NULL;
|
|
IEnumGUID *pIEnumGUID = NULL;
|
|
GUID guids[4];
|
|
LPOLESTR szDesc;
|
|
ULONG expected, got=0;
|
|
IEnumCATEGORYINFO *pIEnumCATEGORYINFO = NULL;
|
|
|
|
VerbosePrint("Creating classes for category test\n\n");
|
|
hr = CreateCatClasses(pIClassAdmin1, pIClassAdmin2);
|
|
if (FAILED(hr))
|
|
goto ReleaseAll;
|
|
|
|
//getting Icatregister interface--------------
|
|
|
|
hr = pIClassAdmin1->QueryInterface(IID_ICatRegister, (void **)&pICatRegister1);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! QueryInterface failed for ICatRegister in CatTest returned 0x%x.\n", hr);
|
|
goto ReleaseAll;
|
|
}
|
|
|
|
|
|
if (pIClassAdmin2)
|
|
hr = pIClassAdmin2->QueryInterface(IID_ICatRegister, (void **)&pICatRegister2);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error! QueryInterface failed for ICatRegister in CatTest returned 0x%x.\n", hr);
|
|
goto ReleaseAll;
|
|
}
|
|
|
|
// getting the ICatInformation pointer
|
|
|
|
hr = CoCreateInstance(CLSID_GblComponentCategoriesMgr, NULL, CLSCTX_INPROC,
|
|
IID_ICatInformation, (void **)&pICatInformation);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("**Error! QueryInterface failed for ICatInformation in comcat returned 0x%x.\n", hr);
|
|
goto ReleaseAll;
|
|
}
|
|
|
|
VerbosePrint("\nEnumerating Categories for category test before registering\n\n");
|
|
hr = pICatInformation->EnumCategories(TestCatLocale1, &pIEnumCATEGORYINFO);
|
|
if (FAILED(hr)) {
|
|
printf("**Error! EnumCategories failed for ICatInformation in comcat returned 0x%x.\n", hr);
|
|
goto ReleaseAll;
|
|
}
|
|
|
|
hr = EnumTests<IEnumCATEGORYINFO, CATEGORYINFO>(pIEnumCATEGORYINFO, 0, &got, 0, 0, FALSE);
|
|
|
|
if (FAILED(hr))
|
|
goto ReleaseAll;
|
|
|
|
VerbosePrint("\nRegistering Categories for category test\n\n");
|
|
hr = RegCategories(pICatRegister1, pICatRegister2);
|
|
if (FAILED(hr))
|
|
goto ReleaseAll;
|
|
|
|
VerbosePrint("\nRegistering Categories with classes for category test\n\n");
|
|
hr = RegCategoriesWithClasses(pICatRegister1, pICatRegister2);
|
|
if (FAILED(hr))
|
|
goto ReleaseAll;
|
|
|
|
|
|
VerbosePrint("\nEnumerating Categories for category test after registering\n\n");
|
|
hr = pICatInformation->EnumCategories(TestCatLocale1, &pIEnumCATEGORYINFO);
|
|
if (FAILED(hr)) {
|
|
printf("**Error! EnumCategories failed for ICatInformation in comcat returned 0x%x.\n", hr);
|
|
goto ReleaseAll;
|
|
|
|
}
|
|
|
|
hr = EnumTests<IEnumCATEGORYINFO, CATEGORYINFO>(pIEnumCATEGORYINFO, got+3, NULL, 0, 0, FALSE);
|
|
if (FAILED(hr))
|
|
goto ReleaseAll;
|
|
|
|
VerbosePrint("\nEnumerating Categories of the classes for category test\n\n");
|
|
hr = DoEnumCatsOfClassesTest(pICatInformation);
|
|
if (FAILED(hr))
|
|
goto ReleaseAll;
|
|
|
|
VerbosePrint("\nEnumerating Classes of the categories for category test\n\n");
|
|
|
|
hr = DoEnumClassesOfCats(pICatInformation);
|
|
if (FAILED(hr))
|
|
goto ReleaseAll;
|
|
|
|
|
|
VerbosePrint("\nTesting IsClassOfCategories for category test\n\n");
|
|
|
|
hr = pICatInformation->IsClassOfCategories(catClsid1, 1, &testCatid2, -1, NULL); // 1, &testCatid1);
|
|
if (hr != S_OK)
|
|
{
|
|
printf("Error! IsClassOfCategories in CatTest returned 0x%x\n", hr);
|
|
goto ReleaseAll;
|
|
}
|
|
|
|
// GetCategoryDesc------------------
|
|
|
|
VerbosePrint("\nCalling GetCategoryDesc for category test\n\n");
|
|
|
|
hr = pICatInformation->GetCategoryDesc(testCatid2, TestCatLocale2, &szDesc);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error!1. GetCategoryDesc in CatTest returned 0x%x\n", hr);
|
|
goto ReleaseAll;
|
|
}
|
|
|
|
if (wcscmp(szDesc, testCatDesc21) != 0)
|
|
{
|
|
printf("Description not matching, Expected: \"%s\", got \"%s\"\n");
|
|
goto ReleaseAll;
|
|
}
|
|
|
|
CoTaskMemFree(szDesc);
|
|
|
|
hr = pICatInformation->GetCategoryDesc(testCatid3, TestCatLocale2, &szDesc);
|
|
if (FAILED(hr))
|
|
{
|
|
printf("Error!2. GetCategoryDesc in CatTest returned 0x%x\n", hr);
|
|
goto ReleaseAll;
|
|
}
|
|
|
|
if (wcscmp(szDesc, testCatDesc3) != 0)
|
|
{
|
|
printf("Error!3. Description not matching, Expected: \"%s\", got \"%s\"\n");
|
|
goto ReleaseAll;
|
|
}
|
|
|
|
CoTaskMemFree(szDesc);
|
|
|
|
VerbosePrint("\nCleaning up the classes and the categories for category test\n\n");
|
|
|
|
ReleaseAll:
|
|
CatCleanup(pICatRegister1, pICatRegister2);
|
|
CatClassCleanup(pIClassAdmin1, pIClassAdmin2);
|
|
|
|
if (pICatRegister1)
|
|
pICatRegister1->Release();
|
|
|
|
if (pICatRegister2)
|
|
pICatRegister2->Release();
|
|
|
|
if (pICatInformation)
|
|
pICatInformation->Release();
|
|
return hr;
|
|
}
|
|
|
|
|