private void TestGetGenericDefinition(MethodBase original, MethodBase expected)
{
var originalData = new AnalysisDataResolver().Resolve(original);
var foundData = originalData.GetGenericDefinition();
Assert.AreEqual(expected, foundData.Inner);
}
public void TestAccessorsIncludePrivateMembers()
{
var testClass = new AnalysisDataResolver().Resolve <TestClass>();
var @event = testClass.GetEvents().Where(e => e.Name == "PrivateEvent").Single();
Assert.AreEqual(2, @event.Accessors.Count);
}
private void TestGetGenericDefinition(MethodBase original, MethodBase expected)
{
var originalData = new AnalysisDataResolver().Resolve(original);
var foundData = originalData.GetGenericDefinition();
Assert.AreEqual(expected, foundData.Inner);
}
public void TestShouldSelectWithDifferentConstructors(string description, BindingFlags flags, bool shouldSelect)
{
var constructor = new AnalysisDataResolver().Resolve(this.GetType().GetConstructors(flags)[0]);
bool result = new TestableStaticConstructorsSelectionStrategy().ShouldSelect(constructor, null);
Assert.AreEqual(shouldSelect, result);
}
public void TestShouldSelectWithDifferentConstructors(string description, BindingFlags flags, bool shouldSelect)
{
var constructor = new AnalysisDataResolver().Resolve(this.GetType().GetConstructors(flags)[0]);
bool result = new TestableStaticConstructorsSelectionStrategy().ShouldSelect(constructor, null);
Assert.AreEqual(shouldSelect, result);
}
public void SetUp()
{
//AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += (sender, args) => {
// return Assembly.ReflectionOnlyLoad(args.Name);
//};
//this.assembly = Assembly.ReflectionOnlyLoadFrom(this.GetType().Assembly.Location);
this.analyzer = new AnalysisDataResolver();
}
public void SetUp()
{
//AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += (sender, args) => {
// return Assembly.ReflectionOnlyLoad(args.Name);
//};
//this.assembly = Assembly.ReflectionOnlyLoadFrom(this.GetType().Assembly.Location);
this.analyzer = new AnalysisDataResolver();
}
private IAssemblyData[] LoadAssemblies(IList <string> assemblyPaths)
{
var analyzer = new AnalysisDataResolver();
return((
from path in assemblyPaths
let assembly = Assembly.LoadFrom(path)
select analyzer.Resolve(assembly)
).ToArray());
}
public void TestMembersExcludesAccessorsOf(string memberNameAndKind) {
var type = new AnalysisDataResolver().Resolve<TestClass>();
var member = type.Members.OfType<IWithAccessors>()
.Single(m => m.Name == memberNameAndKind);
var typeMembersArray = type.Members.ToArray();
foreach (var accessor in member.Accessors) {
Assert.DoesNotContain(typeMembersArray, accessor);
}
}
public void Test(Type type, bool expectTrue)
{
var constructor = new AnalysisDataResolver().Resolve(type.GetConstructor(Type.EmptyTypes));
var strategy = new TestableEmptyDefaultConstructorsSelectionStrategy();
bool result = strategy.ShouldSelect(constructor, null);
if (expectTrue)
Assert.IsTrue(result);
else
Assert.IsFalse(result);
}
public void TestSelectFrom()
{
var globalAsaxMethods = new AnalysisDataResolver()
.Resolve(typeof(GlobalAsaxStub))
.GetMethods();
var selectedMethods = new GlobalAsaxMethodsSelectionStrategy()
.SelectFrom(globalAsaxMethods, null)
.ToArray();
Assert.AreElementsEqualIgnoringOrder(globalAsaxMethods, selectedMethods);
}
public void TestSelectFrom()
{
var globalAsaxMethods = new AnalysisDataResolver()
.Resolve(typeof(GlobalAsaxStub))
.GetMethods();
var selectedMethods = new GlobalAsaxMethodsSelectionStrategy()
.SelectFrom(globalAsaxMethods, null)
.ToArray();
Assert.AreElementsEqualIgnoringOrder(globalAsaxMethods, selectedMethods);
}
public void TestMembersExcludesAccessorsOf(string memberNameAndKind)
{
var type = new AnalysisDataResolver().Resolve <TestClass>();
var member = type.Members.OfType <IWithAccessors>()
.Single(m => m.Name == memberNameAndKind);
var typeMembersArray = type.Members.ToArray();
foreach (var accessor in member.Accessors)
{
Assert.DoesNotContain(typeMembersArray, accessor);
}
}
public void TestGetAllMembersReturnMethodsWithCorrectDeclaringMemberFor(string memberNameAndKind) {
var type = new AnalysisDataResolver().Resolve<TestClass>();
var accessors = type.GetAllMembers(false)
.OfType<MethodData>()
.Where(m => m.Name.EndsWith(memberNameAndKind))
.ToArray();
var declaringMember = type.Members.Single(m => m.Name == memberNameAndKind);
foreach (var accessor in accessors) {
Assert.AreEqual(declaringMember, accessor.DeclaringMember);
}
}
public void TestGetAllMembersReturnMethodsWithCorrectDeclaringMemberFor(string memberNameAndKind)
{
var type = new AnalysisDataResolver().Resolve <TestClass>();
var accessors = type.GetAllMembers(false)
.OfType <MethodData>()
.Where(m => m.Name.EndsWith(memberNameAndKind))
.ToArray();
var declaringMember = type.Members.Single(m => m.Name == memberNameAndKind);
foreach (var accessor in accessors)
{
Assert.AreEqual(declaringMember, accessor.DeclaringMember);
}
}
public void TestGetBaseAndImplementedMethods()
{
const string TestMethodName = "TestMethod";
var resolver = new AnalysisDataResolver();
var methods = Inheritance.GetBaseAndImplementedMethods(
resolver.Resolve(typeof(TestInheritedClass).GetMethod(TestMethodName))
);
Assert.AreElementsEqualIgnoringOrder(
methods.ToArray(), new[] {
resolver.Resolve(typeof(TestInterface).GetMethod(TestMethodName)),
resolver.Resolve(typeof(TestBaseClass).GetMethod(TestMethodName))
}
);
}
public void TestGetBaseAndImplementedMethods()
{
const string TestMethodName = "TestMethod";
var resolver = new AnalysisDataResolver();
var methods = Inheritance.GetBaseAndImplementedMethods(
resolver.Resolve(typeof(TestInheritedClass).GetMethod(TestMethodName))
);
Assert.AreElementsEqualIgnoringOrder(
methods.ToArray(), new[] {
resolver.Resolve(typeof(TestInterface).GetMethod(TestMethodName)),
resolver.Resolve(typeof(TestBaseClass).GetMethod(TestMethodName))
}
);
}
public void Test(Type type, bool expectTrue)
{
var constructor = new AnalysisDataResolver().Resolve(type.GetConstructor(Type.EmptyTypes));
var strategy = new TestableEmptyDefaultConstructorsSelectionStrategy();
bool result = strategy.ShouldSelect(constructor, null);
if (expectTrue)
{
Assert.IsTrue(result);
}
else
{
Assert.IsFalse(result);
}
}
public GenericSupport(ISupportsGenerics host, AnalysisDataResolver resolver)
{
this.host = host;
this.resolver = resolver;
}
public GenericSupport(ISupportsGenerics host, AnalysisDataResolver resolver)
{
this.host = host;
this.resolver = resolver;
}
public void TestAccessorsIncludePrivateMembers() {
var testClass = new AnalysisDataResolver().Resolve<TestClass>();
var @event = testClass.GetEvents().Where(e => e.Name == "PrivateEvent").Single();
Assert.AreEqual(2, @event.Accessors.Count);
}
public AnalysisContext(AnalysisDataResolver resolver)
{
this.Resolver = resolver;
this.SourceProvider = new SourceProvider();
this.AssemblyLoader = new AssemblyLoader();
}
public void TestName(Type type, string expectedName)
{
var typeData = new AnalysisDataResolver().Resolve(type);
Assert.AreEqual(expectedName, typeData.Name);
}
public void TestName(Type type, string expectedName) {
var typeData = new AnalysisDataResolver().Resolve(type);
Assert.AreEqual(expectedName, typeData.Name);
}
private IAssemblyData[] LoadAssemblies(IList<string> assemblyPaths)
{
var analyzer = new AnalysisDataResolver();
return (
from path in assemblyPaths
let assembly = Assembly.LoadFrom(path)
select analyzer.Resolve(assembly)
).ToArray();
}
