protected void CheckEnums(string name, int expectedTypes, string[] expected, string[] notExpected) { C5.HashSet <string> valsToFind = new C5.HashSet <string>( ); valsToFind.AddAll(expected); C5.HashSet <string> valsNotToFind = new C5.HashSet <string>( ); valsNotToFind.AddAll(notExpected); AssemblyHelper.CheckAssembly(name, expectedTypes, delegate(TypeDefinition typeDef) { return(typeDef.BaseType.FullName == "System.Enum"); }, delegate(TypeDefinition typeDef) { // num expected + num unexpected + field storage int totalValues = expected.Length + notExpected.Length + 1; Assert.AreEqual(totalValues, typeDef.Fields.Count, String.Format("Type should have {0} values.", totalValues)); foreach (FieldDefinition field in typeDef.Fields) { Assert.IsFalse(valsNotToFind.Contains(field.Name), String.Format( "Did not expect to find event '{0}'.", field.Name)); valsToFind.Remove(field.Name); } Assert.IsFalse(valsToFind.Count > 0, "Failed to find all expected values."); }); }
public void CheckNestedTypes() { string xml = String.Format( @"<?xml version='1.0'?>" + @"<Obfuscator>" + @"<Var name='InPath' value='{0}' />" + @"<Var name='OutPath' value='{1}' />" + @"<Module file='$(InPath)\AssemblyWithNestedTypes.dll'>" + @"<SkipType name='TestClasses.ClassA/NestedClassA' />" + @"</Module>" + @"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath); TestHelper.BuildAndObfuscate("AssemblyWithNestedTypes", string.Empty, xml); HashSet <string> typesToFind = new HashSet <string> (); typesToFind.Add("A.A"); typesToFind.Add("A.A/a"); typesToFind.Add("A.A/a/B"); typesToFind.Add("A.A/NestedClassA"); AssemblyHelper.CheckAssembly("AssemblyWithNestedTypes", 1, delegate { return(true); }, delegate(TypeDefinition typeDef) { Assert.IsTrue(typesToFind.Contains(typeDef.ToString()), "Type {0} not expected.", typeDef.ToString()); typesToFind.Remove(typeDef.ToString()); }); Assert.IsTrue(typesToFind.Count == 0, "Not all types found."); }
public void CheckModuleInclude() { string outputPath = TestHelper.OutputPath; string xml = string.Format( @"<?xml version='1.0'?>" + @"<Obfuscator>" + @" <Var name='InPath' value='{0}' />" + @" <Var name='OutPath' value='{1}' />" + @" <Module file='$(InPath){2}SkipVirtualMethodTest1.dll'>" + @" <Include path='$(InPath){2}TestIncludeModule.xml' />" + @" </Module>" + @"</Obfuscator>", TestHelper.InputPath, outputPath, Path.DirectorySeparatorChar); File.Copy(Path.Combine(TestHelper.InputPath, @"..", "TestIncludeModule.xml"), Path.Combine(TestHelper.InputPath, "TestIncludeModule.xml"), true); TestHelper.BuildAndObfuscate("SkipVirtualMethodTest", "1", xml); string[] expected = new string[] { "Method1" }; string[] notExpected = new string[] { "Method2" }; AssemblyHelper.CheckAssembly(Path.Combine(outputPath, "SkipVirtualMethodTest1.dll"), 2, expected, notExpected, delegate(TypeDefinition typeDef) { return(!typeDef.IsInterface); }, CheckType); }
public void CheckDefault() { string outputPath = TestHelper.OutputPath; string xml = string.Format( @"<?xml version='1.0'?>" + @"<Obfuscator>" + @"<Var name='InPath' value='{0}' />" + @"<Var name='OutPath' value='{1}' />" + @"<Var name='HidePrivateApi' value='true' />" + @"<Var name='KeepPublicApi' value='true' />" + @"<Module file='$(InPath){2}AssemblyWithNestedTypes2.dll'>" + @"</Module>" + @"</Obfuscator>", TestHelper.InputPath, outputPath, Path.DirectorySeparatorChar); TestHelper.BuildAndObfuscate("AssemblyWithNestedTypes2", string.Empty, xml); HashSet <string> typesToFind = new HashSet <string> (); typesToFind.Add("TestClasses.ClassA"); typesToFind.Add("TestClasses.ClassA/A"); typesToFind.Add("TestClasses.ClassA/NestedClassB"); typesToFind.Add("TestClasses.ClassA/NestedClassB/NestedClassC"); AssemblyHelper.CheckAssembly(Path.Combine(outputPath, "AssemblyWithNestedTypes2.dll"), 1, delegate { return(true); }, delegate(TypeDefinition typeDef) { Assert.True(typesToFind.Contains(typeDef.ToString()), string.Format("Type {0} not expected.", typeDef.ToString())); typesToFind.Remove(typeDef.ToString()); }); Assert.True(typesToFind.Count == 0, "Not all types found."); }
public void CheckSkipsVirtualMethodFromClass() { string outputPath = TestHelper.OutputPath; string xml = string.Format( @"<?xml version='1.0'?>" + @"<Obfuscator>" + @"<Var name='InPath' value='{0}' />" + @"<Var name='OutPath' value='{1}' />" + @"<Var name='KeepPublicApi' value='true' />" + @"<Var name='HidePrivateApi' value='true' />" + @"<Module file='$(InPath){2}SkipVirtualMethodTest2.dll'>" + @"<SkipMethod type='SkipVirtualMethodTest.Class1' name='Method1' />" + @"</Module>" + @"</Obfuscator>", TestHelper.InputPath, outputPath, Path.DirectorySeparatorChar); TestHelper.BuildAndObfuscate("SkipVirtualMethodTest", "2", xml); string[] expected = new string[] { "Method1" }; string[] notExpected = new string[] { "Method2" }; AssemblyHelper.CheckAssembly(Path.Combine(outputPath, "SkipVirtualMethodTest2.dll"), 2, expected, notExpected, delegate(TypeDefinition typeDef) { return(!typeDef.IsInterface); }, CheckType); }
public void CheckSkipsVirtualMethodFromClass() { string xml = String.Format( @"<?xml version='1.0'?>" + @"<Obfuscator>" + @"<Var name='InPath' value='{0}' />" + @"<Var name='OutPath' value='{1}' />" + @"<Module file='$(InPath)\SkipVirtualMethodTest2.dll'>" + @"<SkipMethod type='SkipVirtualMethodTest.Class1' name='Method1' />" + @"</Module>" + @"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath); TestHelper.BuildAndObfuscate("SkipVirtualMethodTest", "2", xml); string[] expected = new string[] { "Method1" }; string[] notExpected = new string[] { "Method2" }; AssemblyHelper.CheckAssembly("SkipVirtualMethodTest2", 2, expected, notExpected, delegate(TypeDefinition typeDef) { return(!typeDef.IsInterface); }, CheckType); }
public void CheckHidePrivateApiTrue() { string xml = String.Format( @"<?xml version='1.0'?>" + @"<Obfuscator>" + @"<Var name='InPath' value='{0}' />" + @"<Var name='OutPath' value='{1}' />" + @"<Module file='$(InPath)\AssemblyWithTypes.dll'>" + @"</Module>" + @"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath); var obfuscator = TestHelper.BuildAndObfuscate("AssemblyWithTypes", string.Empty, xml); var map = obfuscator.Mapping; HashSet <string> typesToFind = new HashSet <string> (); typesToFind.Add("TestClasses.ClassA"); AssemblyHelper.CheckAssembly("AssemblyWithTypes", 2, delegate { return(true); }, delegate(TypeDefinition typeDef) { if (typesToFind.Contains(typeDef.ToString())) { typesToFind.Remove(typeDef.ToString()); } }); Assert.IsTrue(typesToFind.Count == 1, "could find ClassA, which should have been obfuscated."); }
public void CheckHidePrivateApiFalse() { string xml = String.Format( @"<?xml version='1.0'?>" + @"<Obfuscator>" + @"<Var name='InPath' value='{0}' />" + @"<Var name='OutPath' value='{1}' />" + @"<Var name='HidePrivateApi' value='false' />" + @"<Module file='$(InPath)\AssemblyWithTypes.dll'>" + @"</Module>" + @"</Obfuscator>", TestHelper.InputPath, TestHelper.OutputPath); var obfuscator = TestHelper.BuildAndObfuscate("AssemblyWithTypes", string.Empty, xml); var map = obfuscator.Mapping; HashSet <string> typesToFind = new HashSet <string> (); typesToFind.Add("TestClasses.ClassA"); AssemblyHelper.CheckAssembly("AssemblyWithTypes", 2, delegate { return(true); }, delegate(TypeDefinition typeDef) { if (typesToFind.Contains(typeDef.ToString())) { typesToFind.Remove(typeDef.ToString()); } }); Assert.IsTrue(typesToFind.Count == 1, "could not find ClassA, which should not have been obfuscated."); string assmName = "AssemblyWithTypes.dll"; AssemblyDefinition inAssmDef = AssemblyDefinition.ReadAssembly( Path.Combine(TestHelper.InputPath, assmName)); AssemblyDefinition outAssmDef = AssemblyDefinition.ReadAssembly( Path.Combine(TestHelper.OutputPath, assmName)); TypeDefinition classAType = inAssmDef.MainModule.GetType("TestClasses.ClassB"); MethodDefinition classAmethod1 = FindByName(classAType, "TestA"); MethodDefinition classAmethod2 = FindByName(classAType, "TestB"); ObfuscatedThing classAMethod1 = map.GetMethod(new MethodKey(classAmethod1)); ObfuscatedThing classAMethod2 = map.GetMethod(new MethodKey(classAmethod2)); Assert.IsTrue(classAMethod1.Status == ObfuscationStatus.Skipped, "private method is obfuscated."); Assert.IsTrue(classAMethod2.Status == ObfuscationStatus.Renamed, "pubilc method is not obfuscated."); }
protected void CheckProperties(string name, int expectedTypes, string[] expected, string[] notExpected) { C5.HashSet <string> propsToFind = new C5.HashSet <string> (); propsToFind.AddAll(expected); C5.HashSet <string> propsNotToFind = new C5.HashSet <string> (); propsNotToFind.AddAll(notExpected); string[] expectedMethods = new string[expected.Length * 2]; for (int i = 0; i < expected.Length; i++) { expectedMethods [i * 2 + 0] = "get_" + expected [i]; expectedMethods [i * 2 + 1] = "set_" + expected [i]; } string[] notExpectedMethods = new string[notExpected.Length * 2]; for (int i = 0; i < notExpected.Length; i++) { notExpectedMethods [i * 2 + 0] = "get_" + notExpected [i]; notExpectedMethods [i * 2 + 1] = "set_" + notExpected [i]; } AssemblyHelper.CheckAssembly(name, expectedTypes, expectedMethods, notExpectedMethods, delegate(TypeDefinition typeDef) { return(true); }, delegate(TypeDefinition typeDef) { Assert.AreEqual(expected.Length, typeDef.Properties.Count, expected.Length == 1 ? "Type should have 1 property (others dropped by default)." : String.Format("Type should have {0} properties (others dropped by default).", expected.Length)); foreach (PropertyDefinition prop in typeDef.Properties) { Assert.IsFalse(propsNotToFind.Contains(prop.Name), String.Format( "Did not expect to find property '{0}'.", prop.Name)); propsToFind.Remove(prop.Name); } Assert.IsFalse(propsToFind.Count > 0, "Failed to find all expected properties."); }); }
protected void CheckEvents(string name, int expectedTypes, string[] expected, string[] notExpected) { C5.HashSet <string> eventsToFind = new C5.HashSet <string>( ); eventsToFind.AddAll(expected); C5.HashSet <string> eventsNotToFind = new C5.HashSet <string>( ); eventsNotToFind.AddAll(notExpected); C5.HashSet <string> methodsToFind = new C5.HashSet <string>( ); for (int i = 0; i < expected.Length; i++) { methodsToFind.Add("add_" + expected[i]); methodsToFind.Add("remove_" + expected[i]); } C5.HashSet <string> methodsNotToFind = new C5.HashSet <string>( ); for (int i = 0; i < notExpected.Length; i++) { methodsNotToFind.Add("add_" + notExpected[i]); methodsNotToFind.Add("remove_" + notExpected[i]); } bool foundDelType = false; AssemblyHelper.CheckAssembly(name, expectedTypes, delegate(TypeDefinition typeDef) { if (typeDef.BaseType.FullName == "System.MulticastDelegate") { foundDelType = true; return(false); } else { return(true); } }, delegate(TypeDefinition typeDef) { // make sure we have enough methods... // 2 methods / event + a method to fire them Assert.AreEqual(methodsToFind.Count + methodsNotToFind.Count + 1, typeDef.Methods.Count, "Some of the methods for the type are missing."); foreach (MethodDefinition method in typeDef.Methods) { Assert.IsFalse(methodsNotToFind.Contains(method.Name), String.Format( "Did not expect to find method '{0}'.", method.Name)); methodsToFind.Remove(method.Name); } Assert.AreEqual(expected.Length, typeDef.Events.Count, expected.Length == 1 ? "Type should have 1 event (others dropped by default)." : String.Format("Type should have {0} events (others dropped by default).", expected.Length)); foreach (EventDefinition evt in typeDef.Events) { Assert.IsFalse(eventsNotToFind.Contains(evt.Name), String.Format( "Did not expect to find event '{0}'.", evt.Name)); eventsToFind.Remove(evt.Name); } Assert.IsFalse(methodsToFind.Count > 0, "Failed to find all expected methods."); Assert.IsFalse(eventsToFind.Count > 0, "Failed to find all expected events."); }); Assert.IsTrue(foundDelType, "Should have found the delegate type."); }