private static void CreateFaultInjectionTypeLibs(MockTypeLibrariesFailurePoints failurePoint, out MockTypeLib mainTypeLib,
out MockTypeLib dependencyTypeLibGood1, out MockTypeLib dependencyTypeLibBad1,
out MockTypeLib dependencyTypeLibGood2, out MockTypeLib dependencyTypeLibBad2)
{
mainTypeLib = new MockTypeLib();
mainTypeLib.AddTypeInfo(new MockTypeInfo());
mainTypeLib.AddTypeInfo(new MockTypeInfo());
dependencyTypeLibGood1 = new MockTypeLib();
dependencyTypeLibGood1.AddTypeInfo(new MockTypeInfo());
// Make it the StdOle lib to exercise the ITypeInfo.GetDocumentation failure point
dependencyTypeLibBad1 = new MockTypeLib(NativeMethods.IID_StdOle);
dependencyTypeLibBad1.AddTypeInfo(new MockTypeInfo());
dependencyTypeLibGood2 = new MockTypeLib();
dependencyTypeLibGood2.AddTypeInfo(new MockTypeInfo());
// Make it the StdOle lib to exercise the ITypeInfo.GetDocumentation failure point
dependencyTypeLibBad2 = new MockTypeLib(NativeMethods.IID_StdOle);
dependencyTypeLibBad2.AddTypeInfo(new MockTypeInfo());
COMException failureException = new COMException("unhandled exception in " + failurePoint.ToString());
dependencyTypeLibBad1.InjectFailure(failurePoint, failureException);
dependencyTypeLibBad2.InjectFailure(failurePoint, failureException);
}
public void FaultInjectionMainLib()
{
// The primary test here is that we don't throw, which can't be explicitly expressed in NUnit...
// other asserts are secondary
foreach (MockTypeLibrariesFailurePoints failurePoint in Enum.GetValues(typeof(MockTypeLibrariesFailurePoints)))
{
MockTypeLib mainTypeLib = new MockTypeLib();
mainTypeLib.AddTypeInfo(new MockTypeInfo());
// Make it the StdOle lib to exercise the ITypeInfo.GetDocumentation failure point
MockTypeLib dependencyTypeLib = new MockTypeLib(NativeMethods.IID_StdOle);
dependencyTypeLib.AddTypeInfo(new MockTypeInfo());
COMException failureException = new COMException("unhandled exception in " + failurePoint.ToString());
mainTypeLib.InjectFailure(failurePoint, failureException);
dependencyTypeLib.InjectFailure(failurePoint, failureException);
mainTypeLib.ContainedTypeInfos[0].ImplementsInterface(dependencyTypeLib.ContainedTypeInfos[0]);
mainTypeLib.ContainedTypeInfos[0].DefinesVariable(dependencyTypeLib.ContainedTypeInfos[0]);
mainTypeLib.ContainedTypeInfos[0].DefinesFunction(
new MockTypeInfo[] { dependencyTypeLib.ContainedTypeInfos[0] }, dependencyTypeLib.ContainedTypeInfos[0]);
ComDependencyWalker walker = new ComDependencyWalker(new MarshalReleaseComObject(MockReleaseComObject));
walker.AnalyzeTypeLibrary(mainTypeLib);
Assert.Single(walker.EncounteredProblems); // "Test failed for failure point " + failurePoint.ToString()
Assert.Equal(failureException, walker.EncounteredProblems[0]); // "Test failed for failure point " + failurePoint.ToString()
mainTypeLib.AssertAllHandlesReleased();
dependencyTypeLib.AssertAllHandlesReleased();
}
}
public void IgnoreKnownOleTypes()
{
MockTypeLib mainTypeLib = new MockTypeLib();
mainTypeLib.AddTypeInfo(new MockTypeInfo());
MockTypeLib oleTypeLib = new MockTypeLib();
oleTypeLib.AddTypeInfo(new MockTypeInfo(NativeMethods.IID_IUnknown));
oleTypeLib.AddTypeInfo(new MockTypeInfo(NativeMethods.IID_IDispatch));
oleTypeLib.AddTypeInfo(new MockTypeInfo(NativeMethods.IID_IDispatchEx));
oleTypeLib.AddTypeInfo(new MockTypeInfo(NativeMethods.IID_IEnumVariant));
oleTypeLib.AddTypeInfo(new MockTypeInfo(NativeMethods.IID_ITypeInfo));
// We don't check for this type in the ComDependencyWalker, so it doesn't get counted as a known OLE type.
// It's too late in the Dev10 cycle to add it to shipping code without phenomenally good reason, but we should
// re-examine this in Dev11.
// oleTypeLib.AddTypeInfo(new MockTypeInfo(TYPEKIND.TKIND_ENUM));
foreach (MockTypeInfo typeInfo in oleTypeLib.ContainedTypeInfos)
{
mainTypeLib.ContainedTypeInfos[0].DefinesVariable(typeInfo);
}
RunDependencyWalker(mainTypeLib, oleTypeLib, false);
}
private void CreateTwoTypeLibs(out MockTypeLib mainTypeLib, out MockTypeLib dependencyTypeLib)
{
mainTypeLib = new MockTypeLib();
mainTypeLib.AddTypeInfo(new MockTypeInfo());
dependencyTypeLib = new MockTypeLib();
dependencyTypeLib.AddTypeInfo(new MockTypeInfo());
}
public void WalkTypeInfosInEmptyLibrary()
{
MockTypeLib typeLib = new MockTypeLib();
ComDependencyWalker walker = new ComDependencyWalker(new MarshalReleaseComObject(MockReleaseComObject));
walker.AnalyzeTypeLibrary(typeLib);
Assert.Equal(0, walker.GetDependencies().GetLength(0));
typeLib.AssertAllHandlesReleased();
}
public void IgnoreGuidType()
{
MockTypeLib mainTypeLib = new MockTypeLib();
mainTypeLib.AddTypeInfo(new MockTypeInfo());
MockTypeLib oleTypeLib = new MockTypeLib(NativeMethods.IID_StdOle);
oleTypeLib.AddTypeInfo(new MockTypeInfo());
oleTypeLib.ContainedTypeInfos[0].TypeName = "GUID";
mainTypeLib.ContainedTypeInfos[0].DefinesVariable(oleTypeLib.ContainedTypeInfos[0]);
RunDependencyWalker(mainTypeLib, oleTypeLib, false);
}
private TYPELIBATTR[] RunDependencyWalker(MockTypeLib mainTypeLib, MockTypeLib dependencyTypeLib, bool dependencyShouldBePresent)
{
ComDependencyWalker walker = new ComDependencyWalker(new MarshalReleaseComObject(MockReleaseComObject));
walker.AnalyzeTypeLibrary(mainTypeLib);
TYPELIBATTR[] dependencies = walker.GetDependencies();
// types from the main type library should be in the dependency list
AssertDependenciesContainTypeLib(dependencies, mainTypeLib, true);
AssertDependenciesContainTypeLib(dependencies, dependencyTypeLib, dependencyShouldBePresent);
mainTypeLib.AssertAllHandlesReleased();
dependencyTypeLib.AssertAllHandlesReleased();
return(dependencies);
}
private void RunDependencyWalkerFaultInjection(MockTypeLibrariesFailurePoints failurePoint, MockTypeLib mainTypeLib, MockTypeLib dependencyTypeLibGood1, MockTypeLib dependencyTypeLibBad1, MockTypeLib dependencyTypeLibGood2, MockTypeLib dependencyTypeLibBad2)
{
ComDependencyWalker walker = new ComDependencyWalker(new MarshalReleaseComObject(MockReleaseComObject));
walker.AnalyzeTypeLibrary(mainTypeLib);
// Did the current failure point get hit for this test? If not then no point in checking anything
// The previous test (FaultInjectionMainLib) ensures that all defined failure points actually
// cause some sort of trouble
if (walker.EncounteredProblems.Count > 0)
{
TYPELIBATTR[] dependencies = walker.GetDependencies();
AssertDependenciesContainTypeLib("Test failed for failure point " + failurePoint.ToString(),
dependencies, mainTypeLib, true);
AssertDependenciesContainTypeLib("Test failed for failure point " + failurePoint.ToString(),
dependencies, dependencyTypeLibGood1, true);
AssertDependenciesContainTypeLib("Test failed for failure point " + failurePoint.ToString(),
dependencies, dependencyTypeLibGood2, true);
AssertDependenciesContainTypeLib("Test failed for failure point " + failurePoint.ToString(),
dependencies, dependencyTypeLibBad1, false);
AssertDependenciesContainTypeLib("Test failed for failure point " + failurePoint.ToString(),
dependencies, dependencyTypeLibBad2, false);
}
mainTypeLib.AssertAllHandlesReleased();
dependencyTypeLibGood1.AssertAllHandlesReleased();
dependencyTypeLibGood2.AssertAllHandlesReleased();
dependencyTypeLibBad1.AssertAllHandlesReleased();
dependencyTypeLibBad2.AssertAllHandlesReleased();
}
private void AssertDependenciesContainTypeLib(string message, TYPELIBATTR[] dependencies, MockTypeLib typeLib, bool contains)
{
bool dependencyExists = false;
foreach (TYPELIBATTR attr in dependencies)
{
if (attr.guid == typeLib.Attributes.guid)
{
dependencyExists = true;
break;
}
}
Assert.Equal(contains, dependencyExists);
}
private void AssertDependenciesContainTypeLib(TYPELIBATTR[] dependencies, MockTypeLib typeLib, bool contains)
{
AssertDependenciesContainTypeLib("", dependencies, typeLib, contains);
}