public void SpecificGenericsMatchBeforeWildCard()
        {
            var wildcardGenericsProfile = new Profile
            {
                Name           = "wildcardGenericsProfile",
                ClassGrouping  = "Grid",
                FallbackOutput = "<Fallback />",
                Mappings       = new ObservableCollection <Mapping>
                {
                    new Mapping
                    {
                        Type         = "List<T>",
                        NameContains = "",
                        Output       = "<Wildcard />",
                        IfReadOnly   = false,
                    },
                    new Mapping
                    {
                        Type         = "List<string>",
                        NameContains = "",
                        Output       = "<ListOfStrings />",
                        IfReadOnly   = false,
                    },
                },
            };

            var result = AnalyzerBase.GetPropertyOutput(wildcardGenericsProfile, "List<string>", "MyProperty", isReadOnly: false, indent: UnusedIndentValue);

            Assert.AreEqual("<ListOfStrings />", result);
        }
        public void CanHandleMultipleNumberReplacements()
        {
            var gridProfile = new Profile
            {
                Name              = "GridTestProfile",
                ClassGrouping     = "Grid",
                FallbackOutput    = "<TextBlock Text=\"FALLBACK_$name$\" />",
                SubPropertyOutput = "<TextBlock Text=\"SUBPROP_$name$\" />",
                Mappings          = new ObservableCollection <Mapping>
                {
                    new Mapping
                    {
                        Type         = StringPropertyName,
                        NameContains = "",
                        Output       = "<TextBlock Text=\"$name$\" Grid.Row=\"$incint$\" /><TextBlock Text=\"$name$\" Grid.Row=\"$incint$\" />",
                        IfReadOnly   = false,
                    },
                },
            };

            var result = AnalyzerBase.GetPropertyOutput(gridProfile, StringPropertyName, "MyProperty", false, UnusedIndentValue);

            var expected = "<TextBlock Text=\"MyProperty\" Grid.Row=\"1\" />" + Environment.NewLine +
                           "<TextBlock Text=\"MyProperty\" Grid.Row=\"2\" />";

            StringAssert.AreEqual(expected, result);
        }
        public void CorrectlySplitCamelCasePropertyNames()
        {
            var profile = TestProfile.CreateEmpty();

            profile.Mappings.Add(new Mapping
            {
                Type         = "string",
                IfReadOnly   = false,
                NameContains = string.Empty,
                Output       = "$namewithspaces$",
            });

            var result = AnalyzerBase.GetPropertyOutput(profile, "string", "MyProperty", isReadOnly: false, indent: UnusedIndentValue);

            Assert.AreEqual("My Property", result);
        }
        public void WriteablePropertiesMatchFallbackIfOnlySpecificReadOnlyDefined()
        {
            var readonlyProfile = new Profile
            {
                Name           = "readonlyProfile",
                ClassGrouping  = "Grid",
                FallbackOutput = "<Fallback />",
                Mappings       = new ObservableCollection <Mapping>
                {
                    new Mapping
                    {
                        Type         = StringPropertyName,
                        NameContains = "",
                        Output       = "<ReadOnly />",
                        IfReadOnly   = true,
                    },
                },
            };

            var result = AnalyzerBase.GetPropertyOutput(readonlyProfile, StringPropertyName, "MyProperty", isReadOnly: false, indent: UnusedIndentValue);

            Assert.AreEqual("<Fallback />", result);
        }
        public void ReadOnlyPropertiesMatchNotReadOnlyRatherThanFallback()
        {
            var readonlyProfile = new Profile
            {
                Name           = "readonlyProfile",
                ClassGrouping  = "Grid",
                FallbackOutput = "<Fallback />",
                Mappings       = new ObservableCollection <Mapping>
                {
                    new Mapping
                    {
                        Type         = StringPropertyName,
                        NameContains = "",
                        Output       = "<ReadAndWrite />",
                        IfReadOnly   = false,
                    },
                },
            };

            var result = AnalyzerBase.GetPropertyOutput(readonlyProfile, StringPropertyName, "MyProperty", isReadOnly: true);

            Assert.AreEqual("<ReadAndWrite />", result);
        }
        public void SingleNameContainsIsIdentified()
        {
            var result = AnalyzerBase.GetPropertyOutput(this.testProfile, "int", "number1", false, UnusedIndentValue);

            Assert.AreEqual(ReadWriteNumberIntOutput, result);
        }
        public void ReadWritePropertyIsIdentified()
        {
            var result = AnalyzerBase.GetPropertyOutput(this.testProfile, "string", "AnotherProperty", true, UnusedIndentValue);

            Assert.AreEqual(ReadonlyStringOutput.Replace("$name$", "AnotherProperty"), result);
        }
        public void GetsNonFilteredOutputIfNameDoesntMatch()
        {
            var result = AnalyzerBase.GetPropertyOutput(this.testProfile, "string", "MyProperty", false, UnusedIndentValue);

            Assert.AreEqual(ReadWriteStringOutput.Replace("$name$", "MyProperty"), result);
        }
        public void GetFallbackIfTypeNotMapped()
        {
            var result = AnalyzerBase.GetPropertyOutput(this.testProfile, "bool", "IsAdmin", false, UnusedIndentValue);

            Assert.AreEqual(FallbackOutput, result);
        }
        public void NameContainsIsCaseInsensitive()
        {
            var result = AnalyzerBase.GetPropertyOutput(this.testProfile, "int", "Number1", false, UnusedIndentValue);

            Assert.AreEqual(ReadWriteNumberIntOutput, result);
        }
        public void ReadOnlyTakesPriorityOverContains()
        {
            var result = AnalyzerBase.GetPropertyOutput(this.testProfile, "string", "EnteredPwd", true, UnusedIndentValue);

            Assert.AreEqual(ReadonlyStringOutput.Replace("$name$", "EnteredPwd"), result);
        }
        public void MultipleNameContainsIsIdentified()
        {
            var result = AnalyzerBase.GetPropertyOutput(this.testProfile, "string", "EnteredPassword", false, UnusedIndentValue);

            Assert.AreEqual(ReadWritePasswordStringOutput.Replace("$name$", "EnteredPassword"), result);
        }
        public void NoNameContainsIsIdentified()
        {
            var result = AnalyzerBase.GetPropertyOutput(this.testProfile, "int", "numero2", false);

            Assert.AreEqual(ReadWriteIntOutput, result);
        }
        public void TypeNameIsCaseInsensitive()
        {
            var result = AnalyzerBase.GetPropertyOutput(this.testProfile, "INT", "number1", false);

            Assert.AreEqual(ReadWriteNumberIntOutput, result);
        }