public InstallationForm(TargetAssembly targetAssembly, IPrerequisite[] missingPrerequisites)
{
_targetAssembly = targetAssembly;
_missingPrerequisites = missingPrerequisites;
InitializeComponent();
}
public virtual void Public_api_arguments_should_not_have_redundant_not_null_annotation()
{
var parametersWithRedundantAttribute
= (from type in GetAllTypes(TargetAssembly.GetTypes())
where type.GetTypeInfo().IsVisible&& !typeof(Delegate).GetTypeInfo().IsAssignableFrom(type.GetTypeInfo())
let interfaceMappings = type.GetInterfaces().Select(i => type.GetTypeInfo().GetRuntimeInterfaceMap(i))
let events = type.GetEvents()
from method in type.GetMethods(AnyInstance | BindingFlags.Static | BindingFlags.DeclaredOnly)
.Concat <MethodBase>(type.GetConstructors())
where method.IsPublic || method.IsFamily || method.IsFamilyOrAssembly
from parameter in method.GetParameters()
let parameterType = parameter.ParameterType.IsByRef ? parameter.ParameterType.GetElementType() : parameter.ParameterType
let attributes = parameter.GetCustomAttributes(inherit: false)
where (!ShouldHaveNotNullAnnotation(method, type) ||
!type.GetTypeInfo().IsInterface&& interfaceMappings.Any(im => im.TargetMethods.Contains(method)) ||
events.Any(e => e.AddMethod == method || e.RemoveMethod == method) ||
parameterType.GetTypeInfo().IsValueType&& !parameterType.GetTypeInfo().IsNullableType()) &&
attributes.Any(a => a.GetType().Name == nameof(NotNullAttribute) || a.GetType().Name == nameof(CanBeNullAttribute)) ||
parameterType.GetTypeInfo().IsValueType &&
parameterType.GetTypeInfo().IsNullableType() &&
attributes.Any(a => a.GetType().Name == nameof(CanBeNullAttribute))
select type.FullName + "." + method.Name + "[" + parameter.Name + "]").ToList();
Assert.False(
parametersWithRedundantAttribute.Count > 0,
"\r\n-- Redundant NotNull annotations --\r\n" + string.Join(Environment.NewLine, parametersWithRedundantAttribute));
}
public override bool Execute()
{
DateTime start = DateTime.Now;
Log.LogMessage(MessageImportance.High, "Amending {0}", TargetAssembly.Select(a => a.ItemSpec).ToArray());
try
{
Program.Amend(TargetAssembly.First().ItemSpec, AmendmentAssemblies.Select(a => a.ItemSpec).ToArray(), ReferenceAssemblies.Select(a => a.ItemSpec).ToArray());
}
catch (ReflectionTypeLoadException rtle)
{
Log.LogErrorFromException(rtle);
foreach (var le in rtle.LoaderExceptions)
{
Log.LogErrorFromException(le);
}
}
catch (Exception e)
{
Log.LogErrorFromException(e);
throw;
}
Log.LogMessage(MessageImportance.High, "Amending Complete ({0:0.000} seconds)", DateTime.Now.Subtract(start).TotalSeconds);
return(true);
}
public void Public_api_arguments_should_have_not_null_annotation()
{
var parametersMissingAttribute
= (from type in GetAllTypes(TargetAssembly.GetTypes())
where type.GetTypeInfo().IsVisible&& !typeof(Delegate).GetTypeInfo().IsAssignableFrom(type.GetTypeInfo())
let interfaceMappings = type.GetInterfaces().Select(i => type.GetTypeInfo().GetRuntimeInterfaceMap(i))
let events = type.GetEvents()
from method in type.GetMethods(AnyInstance | BindingFlags.Static)
.Concat <MethodBase>(type.GetConstructors())
where (method.DeclaringType == type) &&
(method.IsPublic || method.IsFamily || method.IsFamilyOrAssembly) &&
(method is ConstructorInfo ||
(((MethodInfo)method).GetBaseDefinition().DeclaringType == method.DeclaringType))
//&& (method.Name != nameof(DbContext.OnConfiguring))
//&& (method.Name != nameof(DbContext.OnModelCreating))
where type.GetTypeInfo().IsInterface || !interfaceMappings.Any(im => im.TargetMethods.Contains(method))
where !events.Any(e => (e.AddMethod == method) || (e.RemoveMethod == method))
from parameter in method.GetParameters()
let parameterType = parameter.ParameterType.IsByRef
? parameter.ParameterType.GetElementType()
: parameter.ParameterType
where !parameterType.GetTypeInfo().IsValueType &&
!parameter.GetCustomAttributes()
.Any(
a => (a.GetType().Name == nameof(NotNullAttribute)) ||
(a.GetType().Name == nameof(CanBeNullAttribute)))
select type.FullName + "." + method.Name + "[" + parameter.Name + "]")
.ToList();
Assert.False(
parametersMissingAttribute.Any(),
"\r\n-- Missing NotNull annotations --\r\n" + string.Join(Environment.NewLine, parametersMissingAttribute));
}
public static void AchieveInitialize(AchievementManager __instance)
{
dynamic _this = __instance.AsDynamic();
_this.achivs = Array.CreateInstance(AchievementBaseT, 30);
dynamic achivs = _this.achivs.RealObject;
dynamic achivName = R_AchivName();
dynamic achivIndex = R_AchivIndex();
for (int i = 0; i < achivName.Length; i++)
{
for (int j = 0; j < achivName[i].Length; j++)
{
if (achivIndex[i] + j < achivs.Length)
{
achivs[achivIndex[i] + j] =
(dynamic)TargetAssembly.CreateInstance("THMHJ.Achievements." + achivClassNames[i][j]);
}
}
}
dynamic specialData = _this.LoadSpecialData().RealObject;
for (int k = 0; k < specialData.ach.Length; k++)
{
for (int l = 0; l < specialData.ach[k].achiv.Length; l++)
{
achivs[achivIndex[k] + l].get = specialData.ach[k].achiv[l].get;
for (int m = 0; m < achivs[achivIndex[k] + l].finishedlevel.Length; m++)
{
achivs[achivIndex[k] + l].finishedlevel[m] = specialData.ach[k].achiv[l].level[m];
}
}
}
}
public void Public_api_arguments_should_have_not_null_annotation()
{
var parametersMissingAttribute
= (from type in GetAllTypes(TargetAssembly.GetTypes())
where type.IsVisible && !typeof(Delegate).IsAssignableFrom(type)
let interfaceMappings = type.GetInterfaces().Select(type.GetInterfaceMap)
let events = type.GetEvents()
from method in type.GetMethods(PublicInstance | BindingFlags.Static)
.Concat <MethodBase>(type.GetConstructors())
where method.DeclaringType == type
where type.IsInterface || !interfaceMappings.Any(im => im.TargetMethods.Contains(method))
where !events.Any(e => e.AddMethod == method || e.RemoveMethod == method)
from parameter in method.GetParameters()
where !parameter.ParameterType.IsValueType &&
!parameter.GetCustomAttributes()
.Any(
a => a.GetType().Name == "NotNullAttribute" ||
a.GetType().Name == "CanBeNullAttribute")
select type.FullName + "." + method.Name + "[" + parameter.Name + "]")
.ToList();
Assert.False(
parametersMissingAttribute.Any(),
"\r\n-- Missing NotNull annotations --\r\n" + string.Join("\r\n", parametersMissingAttribute));
}
private bool PromptInstallation(
TargetAssembly targetAssembly,
IPrerequisite[] missingPrerequisites)
{
// Installation must be requested explicitly by setting the environment variable
var isInstallationAccepted = string.Equals(
Environment.GetEnvironmentVariable(PromptEnvironmentVariableName),
"true",
StringComparison.OrdinalIgnoreCase
);
if (!isInstallationAccepted)
{
using (ConsoleEx.WithForegroundColor(ConsoleColor.DarkRed))
{
Console.Error.WriteLine($"Your system is missing runtime components required by {targetAssembly.Title}:");
foreach (var prerequisite in missingPrerequisites)
{
Console.Error.WriteLine($" - {prerequisite.DisplayName}");
}
Console.Error.WriteLine();
}
using (ConsoleEx.WithForegroundColor(ConsoleColor.Gray))
{
Console.Error.Write("To install the missing components automatically, set the environment variable ");
using (ConsoleEx.WithForegroundColor(ConsoleColor.DarkCyan))
Console.Error.Write(PromptEnvironmentVariableName);
Console.Error.Write(" to ");
using (ConsoleEx.WithForegroundColor(ConsoleColor.DarkCyan))
Console.Error.Write("true");
Console.Error.Write(", and then run the application again:");
Console.Error.WriteLine();
}
using (ConsoleEx.WithForegroundColor(ConsoleColor.White))
{
Console.Error.Write($" set {PromptEnvironmentVariableName}=true");
using (ConsoleEx.WithForegroundColor(ConsoleColor.DarkGray))
Console.Error.Write(" (Command Prompt)");
Console.Error.WriteLine();
Console.Error.Write($" $env:{PromptEnvironmentVariableName}=\"true\"");
using (ConsoleEx.WithForegroundColor(ConsoleColor.DarkGray))
Console.Error.Write(" (Powershell)");
Console.Error.WriteLine();
}
return(false);
}
return(true);
}
private void TreeView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
if (e.NewValue is InspectorTreeItem treeItem && treeItem.ShowMethods)
{
ViewModel.Methods.Clear();
var type = TargetAssembly.GetType(treeItem.FullName);
type.GetMethods().ToList().ForEach(AddItemToViewModel);
}
public override bool Execute()
{
DateTime start = DateTime.Now;
Log.LogMessage(MessageImportance.High, "Amending {0}", TargetAssembly.Select(a => a.ItemSpec).ToArray());
Program.Amend(TargetAssembly.First().ItemSpec, AmendmentAssemblies.Select(a => a.ItemSpec).ToArray(), ReferenceAssemblies.Select(a => a.ItemSpec).ToArray());
Log.LogMessage(MessageImportance.High, "Amending Complete ({0:0.000} seconds)", DateTime.Now.Subtract(start).TotalSeconds);
return(true);
}
public void WriteTo(string path)
{
Log.Information("Writing assembly {@OrigName:l} [{@OrigPath:l}] to location {@DestPath:l}",
TargetAssembly.Name.Name,
PathHelper.GetUserFriendlyPath(TargetAssembly.MainModule.FullyQualifiedName),
PathHelper.GetUserFriendlyPath(path));
TargetAssembly.Write(path);
Log.Information("Write completed successfuly.");
}
public void TestSetup()
{
Console.Write(Assembly.GetExecutingAssembly().Location);
string currentPath = System.IO.Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var assembly = Assembly.LoadFrom(currentPath + @"\Test.DataAccess.dll");
Assert.IsNotNull(assembly);
this.tartgetAssembly = new TargetAssembly(assembly);
}
/// <summary>
/// Writes the assembly info.
/// </summary>
/// <param name="xw">The xw.</param>
/// <param name="forReadability">if set to <c>true</c> [for readability].</param>
protected virtual void WriteAssemblyInfo(XmlWriter xw, bool forReadability)
{
if (TargetAssembly != null)
{
xw.WriteStartElement("Assembly");
TargetAssembly.WriteAttributes(xw);
xw.WriteEndElement();
}
}
public AssemblyOptions(string targetAssemblyName, string?defaultNamespace = null, string?rootFolder = null)
{
TargetAssembly = AssemblyOptions.LoadAssembly(targetAssemblyName);
DefaultNamespace = defaultNamespace;
RootFolder = rootFolder;
if (TargetAssembly is not null && string.IsNullOrWhiteSpace(DefaultNamespace))
{
DefaultNamespace = TargetAssembly.GetName().Name;
}
}
public bool GenerateForAllUsedIncomplete()
{
var allAssemblyTypes = new Dictionary<string, Type>();
foreach (Type t in TargetAssembly.GetTypes().Where(t => t.IsPublic))
{
if (!allAssemblyTypes.ContainsKey(t.Name))
allAssemblyTypes.Add(t.Name, t);
}
bool added = false;
foreach (Type type in UsedTypes.ToArray())
{
if (!TypeIsWrapped(type))
throw new InvalidOperationException();
if (!CompleteTypes.ContainsKey(type))
{
var wci = new WrapperClassInfo(type, this);
CompleteTypes.Add(type, wci);
foreach (
Type inheritedType in
allAssemblyTypes.Values.Where(t => t.IsSubclassOf(wci.WrappedType) && t.IsPublic)
.Where(TypeIsWrapped))
{
if (inheritedType.GetCustomAttributes(typeof(ObsoleteAttribute), true).Count() == 0
&& !UsedTypes.Contains(inheritedType))
UsedTypes.Add(inheritedType);
}
var sb = new StringBuilder();
if (wci.IsInterface)
wci.GenerateInterfaceCode(sb);
else
wci.GenerateClassCode(sb);
if (wci.FilePathBase.IndexOfAny(new[] { '\\', '/' }) != -1)
Directory.CreateDirectory(Path.GetDirectoryName(wci.FilePathBase));
WriteTextToFile(wci.FilePathBase + ".cs", sb.ToString(), true);
wci.GenerateUserClassFile();
added = true;
}
}
return added;
}
public Type GetListTypeFor(WrapperPropInfo wpi)
{
if (wpi.PropertyType.IsArray)
{
return(wpi.PropertyType.DeclaringType);
}
string fullPropName = wpi.FullNameDest;
Type listType;
string listTypeName;
listType = LoadListTypeForProperty(fullPropName);
if (listType != null)
{
return(listType);
}
// Try to find type from get*BySomething))
if (fullPropName.EndsWith("s"))
{
string singularName = wpi.Name.Substring(0, wpi.Name.Length - 1);
string singularGetNameStart = "get" + singularName + "By";
Type guessedReturnType = wpi.ClassInfo.WrappedType
.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Where(mi => mi.ReturnType != typeof(void))
.Where(mi => mi.Name.StartsWith(singularGetNameStart))
.Where(mi => mi.Name.Length > singularGetNameStart.Length)
.Select(mi => mi.ReturnType)
.FirstOrDefault();
if (guessedReturnType == null)
{
// Try to find type from name
guessedReturnType = TargetAssembly.GetTypes()
.Where(t => t.Name == "Html" + singularName || t.Name == singularName).FirstOrDefault();
}
if (guessedReturnType != null)
{
Console.WriteLine("Guessed list type " + guessedReturnType.FullName + " for " + fullPropName);
return(guessedReturnType);
}
}
listType = GetListTypeFor(fullPropName);
return(listType);
}
protected override bool InstallPrerequisites(
TargetAssembly targetAssembly,
IPrerequisite[] missingPrerequisites)
{
// Prompt the user
if (!PromptInstallation(targetAssembly, missingPrerequisites))
{
return(false);
}
// Perform the installation
return(PerformInstallation(targetAssembly, missingPrerequisites));
}
public virtual void All_test_bases_must_be_implemented()
{
var concreteTests = TargetAssembly.GetTypes().Where(c => c.BaseType != typeof(object) && !c.IsAbstract).ToList();
var nonImplementedBases
= (from baseType in GetBaseTestClasses()
where !IgnoredTestBases.Contains(baseType) &&
!concreteTests.Any(c => Implements(c, baseType))
select baseType.FullName)
.ToList();
Assert.False(
nonImplementedBases.Count > 0,
"\r\n-- Missing derived classes for --\r\n" + string.Join(Environment.NewLine, nonImplementedBases));
}
public virtual void Async_methods_should_have_overload_with_cancellation_token_and_end_with_async_suffix()
{
var asyncMethods
= (from type in GetAllTypes(TargetAssembly.GetTypes())
where type.GetTypeInfo().IsVisible
from method in type.GetMethods(AnyInstance | BindingFlags.Static)
where method.DeclaringType == type &&
(method.IsPublic || method.IsFamily || method.IsFamilyOrAssembly)
where typeof(Task).GetTypeInfo().IsAssignableFrom(method.ReturnType.GetTypeInfo())
select method).ToList();
var asyncMethodsWithToken
= (from method in asyncMethods
where method.GetParameters().Any(pi => pi.ParameterType == typeof(CancellationToken))
select method).ToList();
var asyncMethodsWithoutToken
= (from method in asyncMethods
where method.GetParameters().All(pi => pi.ParameterType != typeof(CancellationToken))
select method).ToList();
var missingOverloads
= (from methodWithoutToken in asyncMethodsWithoutToken
where !asyncMethodsWithToken
.Any(
methodWithToken => methodWithoutToken.Name == methodWithToken.Name &&
methodWithoutToken.DeclaringType == methodWithToken.DeclaringType)
// ReSharper disable once PossibleNullReferenceException
select methodWithoutToken.DeclaringType.Name + "." + methodWithoutToken.Name)
.Except(GetCancellationTokenExceptions())
.ToList();
Assert.False(
missingOverloads.Count > 0,
"\r\n-- Missing async overloads --\r\n" + string.Join(Environment.NewLine, missingOverloads));
var missingSuffixMethods
= asyncMethods
.Where(method => !method.Name.EndsWith("Async") && method.DeclaringType != null)
.Select(method => method.DeclaringType.Name + "." + method.Name)
.Except(GetAsyncSuffixExceptions())
.ToList();
Assert.False(
missingSuffixMethods.Count > 0,
"\r\n-- Missing async suffix --\r\n" + string.Join(Environment.NewLine, missingSuffixMethods));
}
public int Run(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += (_, e) => ReportError(e.ExceptionObject.ToString());
try
{
var targetAssembly = TargetAssembly.Resolve();
try
{
// Hot path: attempt to run the target first without any checks
return(targetAssembly.Run(args));
}
// Possible exception causes:
// - .NET host not found (DirectoryNotFoundException)
// - .NET host failed to initialize (ApplicationException)
catch
{
// Check for and install missing prerequisites
var missingPrerequisites = targetAssembly.GetMissingPrerequisites();
if (missingPrerequisites.Any())
{
var isInstallationSuccessful = InstallPrerequisites(targetAssembly, missingPrerequisites);
// User canceled installation or reboot is required
if (!isInstallationSuccessful)
{
return(0xB007);
}
// Reset environment to update PATH and other variables
// that may have been changed by the installation process.
EnvironmentEx.RefreshEnvironmentVariables();
}
// Attempt to run the target again, this time without ignoring exceptions
return(targetAssembly.Run(args));
}
}
catch (Exception ex)
{
ReportError(ex.ToString());
return(0xDEAD);
}
}
public void Async_methods_should_have_overload_with_cancellation_token_and_end_with_async_suffix()
{
var asyncMethods
= (from type in GetAllTypes(TargetAssembly.GetTypes())
where type.IsVisible
from method in type.GetMethods(PublicInstance /* | BindingFlags.Static*/)
where GetBasestTypeInAssembly(method.DeclaringType) == type
where typeof(Task).IsAssignableFrom(method.ReturnType)
select method).ToList();
var asyncMethodsWithToken
= (from method in asyncMethods
where method.GetParameters().Any(pi => pi.ParameterType == typeof(CancellationToken))
select method).ToList();
var asyncMethodsWithoutToken
= (from method in asyncMethods
where method.GetParameters().All(pi => pi.ParameterType != typeof(CancellationToken))
select method).ToList();
var missingOverloads
= (from methodWithoutToken in asyncMethodsWithoutToken
where !asyncMethodsWithToken
.Any(methodWithToken => methodWithoutToken.Name == methodWithToken.Name &&
methodWithoutToken.ReflectedType == methodWithToken.ReflectedType)
// ReSharper disable once PossibleNullReferenceException
select methodWithoutToken.DeclaringType.Name + "." + methodWithoutToken.Name)
.Except(GetCancellationTokenExceptions())
.ToList();
Assert.False(
missingOverloads.Any(),
"\r\n-- Missing async overloads --\r\n" + string.Join("\r\n", missingOverloads));
var missingSuffixMethods
= asyncMethods
.Where(method => !method.Name.EndsWith("Async"))
.Select(method => method.DeclaringType.Name + "." + method.Name)
.Except(GetAsyncSuffixExceptions())
.ToList();
Assert.False(
missingSuffixMethods.Any(),
"\r\n-- Missing async suffix --\r\n" + string.Join("\r\n", missingSuffixMethods));
}
public IEnumerable <Type> GetDetectableTypes()
{
var list = TargetAssembly.GetTypes().Where(t => t.BaseType == BaseDetectableType)
.Select(t =>
{
var attrib = t.GetCustomAttribute(typeof(DetectAttribute), false) as DetectAttribute;
var order = (attrib == null) ? 100 : attrib.Priority;
return(new
{
Order = order,
Type = t
});
})
.OrderBy(t => t.Order)
.Select(t => t.Type);
return(list);
}
public void Public_inheritable_apis_should_be_virtual()
{
var nonVirtualMethods
= (from type in GetAllTypes(TargetAssembly.GetTypes())
where type.IsVisible &&
!type.IsSealed &&
type.GetConstructors(AnyInstance).Any(c => c.IsPublic || c.IsFamily || c.IsFamilyOrAssembly) &&
type.Namespace != null &&
!type.Namespace.EndsWith(".Compiled")
from method in type.GetMethods(PublicInstance)
where method.DeclaringType == type &&
!(method.IsVirtual && !method.IsFinal)
select type.FullName + "." + method.Name)
.ToList();
Assert.False(
nonVirtualMethods.Any(),
"\r\n-- Missing virtual APIs --\r\n" + string.Join("\r\n", nonVirtualMethods));
}
public void Public_inheritable_apis_should_be_virtual()
{
var nonVirtualMethods
= (from t in GetAllTypes(TargetAssembly.GetTypes())
where t.IsVisible &&
!t.IsSealed &&
t.GetConstructors(PublicInstance).Any() &&
t.Namespace != null &&
!t.Namespace.EndsWith(".Compiled")
from m in t.GetMethods(PublicInstance)
where m.DeclaringType != null &&
m.DeclaringType.Assembly == TargetAssembly &&
!(m.IsVirtual && !m.IsFinal)
select t.Name + "." + m.Name)
.ToList();
Assert.False(
nonVirtualMethods.Any(),
"\r\n-- Missing virtual APIs --\r\n" + string.Join("\r\n", nonVirtualMethods));
}
public void Async_methods_should_end_with_async_suffix()
{
var asyncMethods
= (from type in GetAllTypes(TargetAssembly.GetTypes())
where type.IsVisible
from method in type.GetMethods(PublicInstance /* | BindingFlags.Static*/)
where GetBasestTypeInAssembly(method.DeclaringType) == type
where typeof(Task).IsAssignableFrom(method.ReturnType)
select method).ToList();
var missingSuffixMethods
= asyncMethods
.Where(method => !method.Name.EndsWith("Async"))
.Select(method => method.DeclaringType.Name + "." + method.Name)
.Except(GetAsyncSuffixExceptions())
.ToList();
Assert.False(
missingSuffixMethods.Any(),
"\r\n-- Missing async suffix --\r\n" + string.Join("\r\n", missingSuffixMethods));
}
public void Async_methods_should_have_overload_with_cancellation_token_and_end_with_async_suffix()
{
var asyncMethodsWithToken
= (from t in GetAllTypes(TargetAssembly.GetTypes())
where t.IsVisible
from m in t.GetMethods(PublicInstance)
where typeof(Task).IsAssignableFrom(m.ReturnType) &&
m.GetParameters().Any(pi => pi.ParameterType == typeof(CancellationToken))
select m).ToList();
var asyncMethodsWithoutToken
= (from t in GetAllTypes(TargetAssembly.GetTypes())
where t.IsVisible
from m in t.GetMethods(PublicInstance)
where typeof(Task).IsAssignableFrom(m.ReturnType) &&
m.GetParameters().All(pi => pi.ParameterType != typeof(CancellationToken))
select m).ToList();
var missingOverloads
= (from m1 in asyncMethodsWithoutToken
where !asyncMethodsWithToken
.Any(m2 => m1.Name == m2.Name &&
m1.ReflectedType == m2.ReflectedType)
// ReSharper disable once PossibleNullReferenceException
select m1.DeclaringType.Name + "." + m1.Name).ToList();
Assert.False(
missingOverloads.Any(),
"\r\n-- Missing async overloads --\r\n" + string.Join("\r\n", missingOverloads));
var missingSuffixMethods
= asyncMethodsWithToken
.Where(mi => !mi.Name.EndsWith("Async"))
.Select(mi => mi.DeclaringType.Name + "." + mi.Name)
.ToList();
Assert.False(
missingSuffixMethods.Any(),
"\r\n-- Missing async suffix --\r\n" + string.Join("\r\n", missingSuffixMethods));
}
public virtual void Public_inheritable_apis_should_be_virtual()
{
var nonVirtualMethods
= (from type in GetAllTypes(TargetAssembly.GetTypes())
where type.GetTypeInfo().IsVisible &&
!type.GetTypeInfo().IsSealed &&
type.GetConstructors(AnyInstance).Any(c => c.IsPublic || c.IsFamily || c.IsFamilyOrAssembly) &&
type.Namespace?.EndsWith(".Compiled") == false &&
ShouldHaveVirtualMethods(type)
from method in type.GetMethods(AnyInstance)
where method.DeclaringType == type &&
!(method.IsVirtual && !method.IsFinal) &&
!method.Name.StartsWith("add_") &&
!method.Name.StartsWith("remove_") &&
(method.IsPublic || method.IsFamily || method.IsFamilyOrAssembly) &&
method.Name != "GenerateCacheKeyCore"
select type.FullName + "." + method.Name)
.ToList();
Assert.False(
nonVirtualMethods.Count > 0,
"\r\n-- Missing virtual APIs --\r\n" + string.Join(Environment.NewLine, nonVirtualMethods));
}
protected override bool InstallPrerequisites(
TargetAssembly targetAssembly,
IPrerequisite[] missingPrerequisites)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// Prompt the user
using (var promptForm = new InstallationPromptForm(targetAssembly, missingPrerequisites))
{
Application.Run(promptForm);
if (!promptForm.Result)
{
return(false);
}
}
// Perform the installation
using (var installationForm = new InstallationForm(targetAssembly, missingPrerequisites))
{
Application.Run(installationForm);
return(installationForm.Result);
}
}
public void Public_api_arguments_should_have_not_null_annotation()
{
var parametersMissingAttribute
= (from t in GetAllTypes(TargetAssembly.GetTypes())
where t.IsVisible
let ims = t.GetInterfaces().Select(t.GetInterfaceMap)
from m in t.GetMethods(PublicInstance | BindingFlags.Static)
.Concat <MethodBase>(t.GetConstructors())
where m.DeclaringType != null &&
m.DeclaringType.Assembly == TargetAssembly
where t.IsInterface || !ims.Any(im => im.TargetMethods.Contains(m))
from p in m.GetParameters()
where !p.ParameterType.IsValueType &&
!p.GetCustomAttributes()
.Any(
a => a.GetType().Name == "NotNullAttribute" ||
a.GetType().Name == "CanBeNullAttribute")
select t.Name + "." + m.Name + "[" + p.Name + "]")
.ToList();
Assert.False(
parametersMissingAttribute.Any(),
"\r\n-- Missing NotNull annotations --\r\n" + string.Join("\r\n", parametersMissingAttribute));
}
public virtual void Public_api_bool_parameters_should_not_be_prefixed()
{
var prefixes = new[]
{
"is",
"can",
"has"
};
var parameters = (
from type in GetAllTypes(TargetAssembly.GetExportedTypes())
where !type.Namespace.Contains("Internal")
from method in type.GetTypeInfo().DeclaredMethods
where !method.IsPrivate
from parameter in method.GetParameters()
where parameter.ParameterType.UnwrapNullableType() == typeof(bool) &&
prefixes.Any(parameter.Name.StartsWith)
select $"{type.FullName}.{method.Name}[{parameter.Name}]")
.ToList();
Assert.False(
parameters.Count > 0,
"\r\n-- Prefixed bool parameteres --\r\n" + string.Join(Environment.NewLine, parameters));
}
private bool PerformInstallation(
TargetAssembly targetAssembly,
IPrerequisite[] missingPrerequisites)
{
using (ConsoleEx.WithForegroundColor(ConsoleColor.White))
Console.Out.WriteLine($"{targetAssembly.Title}: installing prerequisites");
var currentStep = 1;
var totalSteps = missingPrerequisites.Length * 2;
// Download
var installers = new List <IPrerequisiteInstaller>();
foreach (var prerequisite in missingPrerequisites)
{
Console.Out.Write($"[{currentStep}/{totalSteps}] ");
Console.Out.Write($"Downloading {prerequisite.DisplayName}... ");
using (var progress = new ConsoleProgress(Console.Error))
{
var installer = prerequisite.DownloadInstaller(progress.Report);
installers.Add(installer);
}
Console.Out.Write("Done");
Console.Out.WriteLine();
currentStep++;
}
// Install
var isRebootRequired = false;
foreach (var installer in installers)
{
Console.Out.Write($"[{currentStep}/{totalSteps}] ");
Console.Out.Write($"Installing {installer.Prerequisite.DisplayName}... ");
var installationResult = installer.Run();
Console.Out.Write("Done");
Console.Out.WriteLine();
FileEx.TryDelete(installer.FilePath);
if (installationResult == PrerequisiteInstallerResult.RebootRequired)
{
isRebootRequired = true;
}
currentStep++;
}
using (ConsoleEx.WithForegroundColor(ConsoleColor.White))
Console.Out.WriteLine("Prerequisites installed successfully.");
Console.Out.WriteLine();
// Finalize
if (isRebootRequired)
{
using (ConsoleEx.WithForegroundColor(ConsoleColor.DarkYellow))
{
Console.Out.WriteLine($"You need to restart Windows before you can run {targetAssembly.Title}.");
Console.Out.WriteLine("Would you like to do it now? [y/n]");
}
var isRebootAccepted = Console.ReadKey(true).Key == ConsoleKey.Y;
if (isRebootAccepted)
{
OperatingSystem.Reboot();
}
return(false);
}
return(true);
}
