public void WithLowerUnderScoreBackingFields()
    {
        var memberMappings = MappingFinder.GetMappings(DefinitionFinder.FindType <ClassWithUnderScoreBackingFields>()).ToList();

        Assert.AreEqual("_property1", memberMappings.First(x => x.PropertyDefinition.Name == "Property1").FieldDefinition.Name);
        Assert.AreEqual("_property2", memberMappings.First(x => x.PropertyDefinition.Name == "Property2").FieldDefinition.Name);
    }
示例#2
0
    public void TestSqlGuid()
    {
        var typeDefinition  = DefinitionFinder.FindType <SqlGuid>();
        var findNamedMethod = TypeEqualityFinder.FindNamedMethod(typeDefinition);

        Assert.IsNull(findNamedMethod);
    }
示例#3
0
    public void TestSqlGuid()
    {
        var typeDefinition  = DefinitionFinder.FindType <SqlGuid>();
        var findNamedMethod = ModuleWeaver.FindNamedMethod(typeDefinition);

        Assert.Null(findNamedMethod);
    }
    public void Run()
    {
        var memberMappings = ModuleWeaver.GetMappings(DefinitionFinder.FindType <ClassWithAutoPropertiesAndDodgyField>()).ToList();

        Assert.AreEqual("<Property1>k__BackingField", memberMappings.Single(x => x.PropertyDefinition.Name == "Property1").FieldDefinition.Name);
        Assert.AreEqual("<Property2>k__BackingField", memberMappings.Single(x => x.PropertyDefinition.Name == "Property2").FieldDefinition.Name);
    }
    public void Run()
    {
        var memberMappings = ModuleWeaver.GetMappings(DefinitionFinder.FindType <ClassWithLowerCaseBackingFields>()).ToList();

        Assert.Equal("property1", memberMappings.First(x => x.PropertyDefinition.Name == "Property1").FieldDefinition.Name);
        Assert.Equal("property2", memberMappings.First(x => x.PropertyDefinition.Name == "Property2").FieldDefinition.Name);
    }
示例#6
0
    public void TestString()
    {
        var typeDefinition  = DefinitionFinder.FindType <string>();
        var findNamedMethod = ModuleWeaver.FindNamedMethod(typeDefinition);

        Assert.Equal("System.Boolean System.String::Equals(System.String,System.String)", findNamedMethod.FullName);
    }
示例#7
0
    public void CanCheckIfGetterCallsSetter(string propertyName, bool expectedResult)
    {
        var propertyDefinition = DefinitionFinder.FindType <ClassWithStackOverflow>().Properties.First(x => x.Name == propertyName);
        var result             = stackOverflowChecker.CheckIfGetterCallsSetter(propertyDefinition);

        Assert.AreEqual(expectedResult, result);
    }
    public void TestInt()
    {
        var typeDefinition  = DefinitionFinder.FindType <int>();
        var findNamedMethod = ModuleWeaver.FindNamedMethod(typeDefinition);

        Assert.IsNull(findNamedMethod);
    }
    public void CanDetectIfGetterCallsVirtualBaseSetter()
    {
        var propertyDefinition = DefinitionFinder.FindType <ChildClassWithOverflow>().Properties.First(x => x.Name == "Property1");
        var result             = stackOverflowChecker.CheckIfGetterCallsVirtualBaseSetter(propertyDefinition);

        Assert.True(result);
    }
示例#10
0
    public void CanDetectIfGetterCallsVirtualBaseSetterWhenBaseClassInDifferentAssembly()
    {
        var propertyDefinition = DefinitionFinder.FindType <ChildWithBaseInDifferentAssembly>().Properties.First(x => x.Name == "Property1");
        var result             = stackOverflowChecker.CheckIfGetterCallsVirtualBaseSetter(propertyDefinition);

        Assert.AreEqual(true, result);
    }
示例#11
0
    public void Run()
    {
        var memberMappings = ModuleWeaver.GetMappings(DefinitionFinder.FindType <ClassWithSingleBackingFieldsSet>()).ToList();

        Assert.AreEqual("propertyA", memberMappings.Single(x => x.PropertyDefinition.Name == "Property1").FieldDefinition.Name);
        Assert.AreEqual("propertyB", memberMappings.Single(x => x.PropertyDefinition.Name == "Property2").FieldDefinition.Name);
    }
示例#12
0
    public void Run()
    {
        var memberMappings = ModuleWeaver.GetMappings(DefinitionFinder.FindType <ClassWithSingleBackingFieldsGet>()).ToList();
        var memberMapping  = memberMappings.Single(x => x.PropertyDefinition.Name == "Property1");

        Assert.IsNull(memberMapping.FieldDefinition);
    }
示例#13
0
        public void ValidateFindMethodsThatDoNotUsesArraySlicesInBody()
        {
            var typeToFind = DefinitionFinder.FindType(typeof(ArraySlice <>));
            var methods    = Weaver.FindMethodsUsingArraySlices(typeToFind)
                             .Where(x => x.Name.StartsWith("DoNot") && x.DeclaringType.Name == "ControlWeavingAtMethodLevel");

            Assert.Equal(2, methods.Count());
        }
        public void SurveyViewModel_Should_Have_CommandInitialization_Injected()
        {
            var instance       = Assembly.GetInstance("WpfMvvmSample.SurveyViewModel");
            var objectInstance = (object)instance;
            var type           = DefinitionFinder.FindType(objectInstance.GetType());
            var method         = type.FindMethod("<Commander_Fody>InitializeCommands");

            method.Should().NotBeNull();
        }
示例#15
0
    public void PropertyThatDoesNotExist()
    {
        var reader = new ModuleWeaver();
        var node   = new TypeNode
        {
            TypeDefinition = DefinitionFinder.FindType <ClassWithInvalidDepends>(),
        };

        reader.ProcessDependsOnAttributes(node);
    }
 public void Run()
 {
     var typeDefinition = DefinitionFinder.FindType<Person>();
     var node = new TypeNode
     {
         TypeDefinition = typeDefinition,
         Mappings = ModuleWeaver.GetMappings(typeDefinition).ToList()
     };
     new IlGeneratedByDependencyReader(node).Process();
     Assert.Empty(node.PropertyDependencies);
 }
    public void IsAbstract()
    {
        var checker            = new ModuleWeaver();
        var propertyDefinition = DefinitionFinder.FindType <BaseClass>().Properties.First(x => x.Name == "AbstractProperty");

        var message = checker.CheckForWarning(new PropertyData
        {
            PropertyDefinition = propertyDefinition,
        }, false);

        Assert.IsNotNull(message);
    }
示例#18
0
    public void Run()
    {
        var typeDefinition = DefinitionFinder.FindType <Person>();
        var node           = new TypeNode
        {
            TypeDefinition = typeDefinition,
            Mappings       = MappingFinder.GetMappings(typeDefinition).ToList()
        };

        new IlGeneratedByDependencyReader(node).Process();
        Assert.AreEqual(0, node.PropertyDependencies.Count);
    }
    public void IsIndexer()
    {
        var checker            = new ModuleWeaver();
        var propertyDefinition = DefinitionFinder.FindType <IndexerClass>().Properties.First();

        var message = checker.CheckForWarning(new PropertyData
        {
            PropertyDefinition = propertyDefinition,
        }, false);

        Assert.IsNotNull(message);
    }
    public void PropertyThatDoesNotExist()
    {
        var logger = Substitute.For <Logger>();
        var reader = new DependsOnDataAttributeReader(null, logger);
        var node   = new TypeNode
        {
            TypeDefinition = DefinitionFinder.FindType <ClassWithInvalidDepends>(),
        };

        reader.Process(node);
        logger.Received().LogError("Could not find property 'NotAProperty2' for DependsOnAttribute assinged to 'FullName'.");
        logger.Received().LogError("Could not find property 'NotAProperty1' for DependsOnAttribute assinged to 'FullName'.");
    }
示例#21
0
    public void PropertyThatDoesNotExist()
    {
        var reader = new ModuleWeaver();
        var node   = new TypeNode
        {
            TypeDefinition = DefinitionFinder.FindType <ClassWithInvalidDepends>(),
        };

        reader.ProcessDependsOnAttributes(node);
        //TODO: should raise an exception
        //logger.Received().LogError("Could not find property 'NotAProperty2' for DependsOnAttribute assigned to 'FullName'.");
        //logger.Received().LogError("Could not find property 'NotAProperty1' for DependsOnAttribute assigned to 'FullName'.");
    }
示例#22
0
    public void IsAbstract()
    {
        var checker            = new ErrorChecker(null, null);
        var propertyDefinition = DefinitionFinder.FindType <IndexerClass>().Properties.First();

        var message = checker.CheckForErrors(new PropertyData
        {
            PropertyDefinition        = propertyDefinition,
            NotificationAddedDirectly = true
        }, false);

        Assert.IsNotNull(message);
    }
    public void IsAbstract()
    {
        var checker            = new WarningChecker(null, null);
        var propertyDefinition = DefinitionFinder.FindType <BaseClass>().Properties.First(x => x.Name == "AbstractProperty");

        var message = checker.CheckForWarning(new PropertyData
        {
            PropertyDefinition        = propertyDefinition,
            NotificationAddedDirectly = false
        }, false);

        Assert.IsNotNull(message);
    }
    public void Run()
    {
        var typeDefinition    = DefinitionFinder.FindType <InnerClass>();
        var recursiveIlFinder = new RecursiveIlFinder(typeDefinition);

        var methodDefinition = typeDefinition.Methods.First(x => x.Name == "Method1");

        recursiveIlFinder.Execute(methodDefinition);
#if (DEBUG)
        Assert.Equal(25, recursiveIlFinder.Instructions.Count);
#else
        Assert.Equal(15, recursiveIlFinder.Instructions.Count);
#endif
    }
示例#25
0
 public void Run()
 {
     var typeDefinition = DefinitionFinder.FindType<Person>();
     var node = new TypeNode
                    {
                        TypeDefinition = typeDefinition,
                        Mappings = ModuleWeaver.GetMappings(typeDefinition).ToList()
                    };
     new IlGeneratedByDependencyReader(node).Process();
     var first = node.PropertyDependencies[0];
     Assert.AreEqual(1, node.PropertyDependencies.Count);
     Assert.AreEqual("FullName", first.ShouldAlsoNotifyFor.Name);
     Assert.AreEqual("GivenNames", first.WhenPropertyIsSet.Name);
 }
示例#26
0
    public void Run()
    {
        var typeDefinition = DefinitionFinder.FindType <TestClass>();
        var node           = new TypeNode
        {
            TypeDefinition = typeDefinition,
            Mappings       = ModuleWeaver.GetMappings(typeDefinition).ToList()
        };

        new IlGeneratedByDependencyReader(node).Process();
        Assert.Single(node.PropertyDependencies);
        Assert.Equal("PropertyWithLambda", node.PropertyDependencies[0].ShouldAlsoNotifyFor.Name);
        Assert.Equal("Property1", node.PropertyDependencies[0].WhenPropertyIsSet.Name);
    }
    public void Integration()
    {
        var reader = new ModuleWeaver();
        var node   = new TypeNode
        {
            TypeDefinition = DefinitionFinder.FindType <Person>()
        };

        reader.ProcessDependsOnAttributes(node);

        Assert.AreEqual("FullName", node.PropertyDependencies[0].ShouldAlsoNotifyFor.Name);
        Assert.AreEqual("GivenNames", node.PropertyDependencies[0].WhenPropertyIsSet.Name);
        Assert.AreEqual("FullName", node.PropertyDependencies[1].ShouldAlsoNotifyFor.Name);
        Assert.AreEqual("FamilyName", node.PropertyDependencies[1].WhenPropertyIsSet.Name);
    }
示例#28
0
    public void IsIndexer()
    {
        var checker            = new ModuleWeaver();
        var propertyDefinition = DefinitionFinder.FindType <IndexerClass>()
                                 .Properties
                                 .First();

        var propertyData = new PropertyData
        {
            PropertyDefinition = propertyDefinition,
        };
        var message = checker.CheckForWarning(propertyData, InvokerTypes.String);

        Assert.Equal("Property is an indexer.", message);
    }
示例#29
0
    public void Run()
    {
        var typeDefinition = DefinitionFinder.FindType <Person <int> >();
        var node           = new TypeNode
        {
            TypeDefinition = typeDefinition,
            Mappings       = MappingFinder.GetMappings(typeDefinition).ToList()
        };

        new IlGeneratedByDependencyReader(node).Process();
        Assert.AreEqual("FullName", node.PropertyDependencies[0].ShouldAlsoNotifyFor.Name);
        Assert.AreEqual("GivenNames", node.PropertyDependencies[0].WhenPropertyIsSet.Name);
        Assert.AreEqual("FullName", node.PropertyDependencies[1].ShouldAlsoNotifyFor.Name);
        Assert.AreEqual("FamilyName", node.PropertyDependencies[1].WhenPropertyIsSet.Name);
    }
    public void IsChanged()
    {
        var reader = new NotifyPropertyDataAttributeReader(null);

        var typeDefinition      = DefinitionFinder.FindType <TestClass>();
        var propertyDefinitions = new List <PropertyDefinition>();
        var trueData            = reader.Read(typeDefinition.Properties.First(x => x.Name == "SetIsChangedTrue"), propertyDefinitions);

        Assert.IsTrue(trueData.SetIsChanged.Value);
        var falseData = reader.Read(typeDefinition.Properties.First(x => x.Name == "SetIsChangedFalse"), propertyDefinitions);

        Assert.IsFalse(falseData.SetIsChanged.Value);
        var defauleData = reader.Read(typeDefinition.Properties.First(x => x.Name == "SetIsChangedDefault"), propertyDefinitions);

        Assert.IsNull(defauleData.SetIsChanged);
    }