public void Output_is_different_from_input_when_is_specified(string args)
        {
            var settings = AssemblyReducerSettings.ParseArguments(args.Split(' ').ToArray());

            Assert.Equal("hello", settings.Input);
            Assert.Equal("world", settings.Output);
        }
        public void Output_is_same_as_input_when_not_specified(string args)
        {
            var settings = AssemblyReducerSettings.ParseArguments(args.Split(' ').ToArray());

            Assert.Equal("hello", settings.Input);
            Assert.Equal("hello", settings.Output);
        }
示例#3
0
        public static void Main(string[] args)
        {
            var settings = AssemblyReducerSettings.ParseArguments(args);

            settings.Validate();
            var reducer = new AssemblyReducer(settings);

            reducer.Execute();
        }
        public void Invalid_input_path(string input)
        {
            var settings = new AssemblyReducerSettings
            {
                Input = input
            };
            var ex = Assert.Throws <ArgumentException>(() => settings.Validate());

            Assert.Equal("input file not found.", ex.Message);
        }
        public void Invalid_strong_name_key_path()
        {
            var settings = new AssemblyReducerSettings
            {
                Input         = "Niam.Xrm.AssemblyReduce.Tests.dll",
                StrongNameKey = "not_exist.dll"
            };
            var ex = Assert.Throws <ArgumentException>(() => settings.Validate());

            Assert.Equal("strong name key file not found.", ex.Message);
        }
示例#6
0
        public void Can_remove_unused_types()
        {
            var fileName = "Niam.Xrm.TestAssembly.test.dll";
            var settings = new AssemblyReducerSettings
            {
                Input         = fileName,
                StrongNameKey = "open-source.snk",
                KeepTypes     = new[]
                {
                    "Niam.Xrm.TestAssembly.UsedAsGenericParamConstraintClass",
                    "Niam.Xrm.TestAssembly.UnusedButKeepClass",
                    "Niam.Xrm.TestAssembly.Unused.*"
                }
            };

            new AssemblyReducer(settings).Execute();

            var testAssembly = Assembly.LoadFrom(fileName);
            var testTypes    = testAssembly.GetTypes();

            foreach (var testType in testTypes.OrderBy(t => t.FullName))
            {
                _output.WriteLine($"- {testType.FullName}");
            }

            var testAssemblyName = testAssembly.GetName();

            Assert.Equal(_expectedPublicKey, testAssemblyName.GetPublicKey());
            Assert.Equal(_expectedPublicKeyToken, testAssemblyName.GetPublicKeyToken());

            Assert.DoesNotContain(testTypes, t => t.FullName == "Niam.Xrm.TestAssembly.UnusedClass");

            var existingTypes = new[]
            {
                "Niam.Xrm.TestAssembly.UnusedButKeepClass",
                "Niam.Xrm.TestAssembly.Unused.AnotherUnusedClass",
                "Niam.Xrm.TestAssembly.Unused.AnotherUnusedClass2",

                "Niam.Xrm.TestAssembly.UsedAsGenericParamConstraintClass",
                "Niam.Xrm.TestAssembly.UsedAsGenericParamConstraintClass2",

                "Niam.Xrm.TestAssembly.DirectImplementPlugin",
                "Niam.Xrm.TestAssembly.PluginBase",
                "Niam.Xrm.TestAssembly.UsingCustomBasePlugin",
                "Niam.Xrm.TestAssembly.PluginBaseGeneric`1",
                "Niam.Xrm.TestAssembly.GenericPlugin`1"
            };

            foreach (var fullname in existingTypes)
            {
                Assert.Contains(testTypes, t => t.FullName == fullname);
            }
        }
        public void Can_parse_strong_name_key(string args)
        {
            var settings = AssemblyReducerSettings.ParseArguments(args.Split(' ').ToArray());

            Assert.Equal("path/to/snk/file", settings.StrongNameKey);
        }
        public void Can_parse_namespaces(string keeptypes)
        {
            var settings = AssemblyReducerSettings.ParseArguments(new[] { keeptypes });

            Assert.Equal(new[] { "first", "second" }, settings.KeepTypes);
        }