Skip to content

Add test coverage table of Base API #2

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
hj-na-park wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Add test coverage table of Base API #2

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
238 changes: 170 additions & 68 deletions APIMap.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,9 @@ class APIMap
List<API> apis = new List<API>();
Dictionary<MemberInfo, API> nameMap = new Dictionary<MemberInfo, API>();

List<API> apisOfBase = new List<API>();
Dictionary<MemberInfo, API> nameMapOfBase = new Dictionary<MemberInfo, API>();

public APIMap(IEnumerable<string> paths)
{
foreach (var path in paths)
Expand All @@ -25,6 +28,9 @@ public APIMap(IEnumerable<string> paths)
public IEnumerable<API> APIList => apis;
public Dictionary<MemberInfo, API> NameMap => nameMap;

public IEnumerable<API> BaseAPIList => apisOfBase;
public Dictionary<MemberInfo, API> NameMapOfBase => nameMapOfBase;

void Load(string path)
{
var assembly = AssemblyLoader.GetAssembly(path);
Expand All @@ -37,88 +43,184 @@ void Load(string path)

foreach (Type type in types)
{
string typeName = type.Name;
var t = new API(Category.Type, typeName);
apis.Add(t);
LoadBaseType(type);
LoadType(type);
}
}

var staticFieldsInfo = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly)
.Where(f => f.IsFamily || f.IsPublic);
foreach (var field in staticFieldsInfo)
void LoadBaseType(Type type)
{
Type baseType = type.BaseType;
string parentName = baseType.Name + " of " + type.Name;
var bt = new API(Category.Type, parentName);
apisOfBase.Add(bt);

var staticFieldsInfoOfBase = baseType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly)
.Where(f => f.IsFamily || f.IsPublic);
foreach (var field in staticFieldsInfoOfBase)
{
var api = new API(bt, Category.StaticField, field.Name, field.FieldType.Name);
apisOfBase.Add(api);
NameMapOfBase[field] = api;
}

var propertyInfoOfBase = baseType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
.Where(p => (p.GetMethod != null && !p.GetMethod.IsPrivate) || (p.SetMethod != null && !p.SetMethod.IsPrivate));
foreach (var property in propertyInfoOfBase)
{
var api = new API(bt, Category.Property, property.Name, property.PropertyType.Name);
apisOfBase.Add(api);

if (property.GetMethod != null)
{
var api = new API(t, Category.StaticField, field.Name, field.FieldType.Name);
apis.Add(api);
NameMap[field] = api;
NameMapOfBase[property.GetMethod] = api;
//Console.WriteLine($"{property.GetMethod.Name} => {property.GetMethod.GetMetadataToken():x} / {property.GetMethod.MetadataToken:x}");
}

var propertyInfo = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
.Where(p => (p.GetMethod != null && !p.GetMethod.IsPrivate) || (p.SetMethod != null && !p.SetMethod.IsPrivate));
foreach (var property in propertyInfo)
if (property.SetMethod != null)
{
var api = new API(t, Category.Property, property.Name, property.PropertyType.Name);
apis.Add(api);

if (property.GetMethod != null)
{
NameMap[property.GetMethod] = api;
//Console.WriteLine($"{property.GetMethod.Name} => {property.GetMethod.GetMetadataToken():x} / {property.GetMethod.MetadataToken:x}");
}
if (property.SetMethod != null)
{
NameMap[property.SetMethod] = api;
//Console.WriteLine($"{property.SetMethod.Name} => {property.SetMethod.GetMetadataToken():x} / {property.SetMethod.MetadataToken:x}");
}
NameMapOfBase[property.SetMethod] = api;
//Console.WriteLine($"{property.SetMethod.Name} => {property.SetMethod.GetMetadataToken():x} / {property.SetMethod.MetadataToken:x}");
}
}

var methodInfo = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static).Where(m => {
if (!m.IsPublic)
{
return false;
}
var method = m as MethodBase;
return method == null || !method.IsSpecialName;
});
foreach (var method in methodInfo)
var methodInfoOfBase = baseType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static).Where(m =>
{
if (!m.IsFamily && !m.IsPublic)
{
return false;
}
var method = m as MethodBase;
return method == null || !method.IsSpecialName;
});
foreach (var method in methodInfoOfBase)
{
var pars = method.GetParameters();
var psb = new StringBuilder();
psb.Append(' ');
foreach (var p in pars)
{
var pars = method.GetParameters();
var psb = new StringBuilder();
psb.Append(p.ParameterType.Name);
psb.Append(' ');
foreach (var p in pars)
{
psb.Append(p.ParameterType.Name);
psb.Append(' ');
psb.Append(p.Name);
psb.Append(' ');
}

var api = new API(t, Category.Method, $"{method.Name}({psb.ToString()})", method.ReturnType.Name);
apis.Add(api);
NameMap[method] = api;
psb.Append(p.Name);
psb.Append(' ');
}

var api = new API(bt, Category.Method, $"{method.Name}({psb.ToString()})", method.ReturnType.Name);
apisOfBase.Add(api);
NameMapOfBase[method] = api;
}

var fieldsInfoOfBase = baseType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
.Where(m => m.IsFamily || m.IsPublic);
foreach (var field in fieldsInfoOfBase)
{
var api = new API(bt, Category.Field, field.Name, field.FieldType.Name);
apisOfBase.Add(api);
NameMapOfBase[field] = api;
}

var eventsInfoOfBase = baseType.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
.Where(e => !e.AddMethod.IsPrivate || !e.RemoveMethod.IsPrivate);
foreach (var evnt in eventsInfoOfBase)
{
var api = new API(bt, Category.Event, evnt.Name, evnt.EventHandlerType.Name);
apisOfBase.Add(api);

if (evnt.AddMethod != null)
{
NameMapOfBase[evnt.AddMethod] = api;
}
if (evnt.RemoveMethod != null)
{
NameMapOfBase[evnt.RemoveMethod] = api;
}
}
}

void LoadType(Type type)
{
string typeName = type.Name;
var t = new API(Category.Type, typeName);
apis.Add(t);

var staticFieldsInfo = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly)
.Where(f => f.IsFamily || f.IsPublic);
foreach (var field in staticFieldsInfo)
{
var api = new API(t, Category.StaticField, field.Name, field.FieldType.Name);
apis.Add(api);
NameMap[field] = api;
}

var propertyInfo = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
.Where(p => (p.GetMethod != null && !p.GetMethod.IsPrivate) || (p.SetMethod != null && !p.SetMethod.IsPrivate));
foreach (var property in propertyInfo)
{
var api = new API(t, Category.Property, property.Name, property.PropertyType.Name);
apis.Add(api);

if (property.GetMethod != null)
{
NameMap[property.GetMethod] = api;
//Console.WriteLine($"{property.GetMethod.Name} => {property.GetMethod.GetMetadataToken():x} / {property.GetMethod.MetadataToken:x}");
}
if (property.SetMethod != null)
{
NameMap[property.SetMethod] = api;
//Console.WriteLine($"{property.SetMethod.Name} => {property.SetMethod.GetMetadataToken():x} / {property.SetMethod.MetadataToken:x}");
}
}

var fieldsInfo = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
.Where(m => m.IsFamily || m.IsPublic);
foreach (var field in fieldsInfo)
var methodInfo = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Static).Where(m =>
{
if (!m.IsPublic)
{
return false;
}
var method = m as MethodBase;
return method == null || !method.IsSpecialName;
});
foreach (var method in methodInfo)
{
var pars = method.GetParameters();
var psb = new StringBuilder();
psb.Append(' ');
foreach (var p in pars)
{
var api = new API(t, Category.Field, field.Name, field.FieldType.Name);
apis.Add(api);
NameMap[field] = api;
psb.Append(p.ParameterType.Name);
psb.Append(' ');
psb.Append(p.Name);
psb.Append(' ');
}

var eventsInfo = type.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
.Where(e => !e.AddMethod.IsPrivate || !e.RemoveMethod.IsPrivate);
foreach (var evnt in eventsInfo)
var api = new API(t, Category.Method, $"{method.Name}({psb.ToString()})", method.ReturnType.Name);
apis.Add(api);
NameMap[method] = api;
}

var fieldsInfo = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
.Where(m => m.IsFamily || m.IsPublic);
foreach (var field in fieldsInfo)
{
var api = new API(t, Category.Field, field.Name, field.FieldType.Name);
apis.Add(api);
NameMap[field] = api;
}

var eventsInfo = type.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)
.Where(e => !e.AddMethod.IsPrivate || !e.RemoveMethod.IsPrivate);
foreach (var evnt in eventsInfo)
{
var api = new API(t, Category.Event, evnt.Name, evnt.EventHandlerType.Name);
apis.Add(api);

if (evnt.AddMethod != null)
{
NameMap[evnt.AddMethod] = api;
}
if (evnt.RemoveMethod != null)
{
var api = new API(t, Category.Event, evnt.Name, evnt.EventHandlerType.Name);
apis.Add(api);

if (evnt.AddMethod != null)
{
NameMap[evnt.AddMethod] = api;
}
if (evnt.RemoveMethod != null)
{
NameMap[evnt.RemoveMethod] = api;
}
NameMap[evnt.RemoveMethod] = api;
}
}
}
Expand Down
34 changes: 22 additions & 12 deletions ILFinder.cs
100644 → 100755
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,25 +28,35 @@ public static void Find(IEnumerable<string> paths, FoundDelegater onFound)

foreach (var type in types)
{
var methods = type.GetMethods(
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance |
BindingFlags.CreateInstance | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.InvokeMethod |
BindingFlags.SetField | BindingFlags.GetField | BindingFlags.FlattenHierarchy | BindingFlags.DeclaredOnly);
FindType(type, onFound);

foreach (var method in methods)
if (type.BaseType != null)
{
Find(method, onFound);
}

var ctors = type.GetConstructors(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (var ctor in ctors)
{
Find(ctor, onFound);
Type baseType = type.BaseType;
FindType(baseType, onFound);
}
}
}
}

static void FindType(Type type, FoundDelegater onFound)
{
var methods = type.GetMethods(
BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance |
BindingFlags.CreateInstance | BindingFlags.GetProperty | BindingFlags.SetProperty | BindingFlags.InvokeMethod |
BindingFlags.SetField | BindingFlags.GetField | BindingFlags.FlattenHierarchy | BindingFlags.DeclaredOnly);
foreach (var method in methods)
{
Find(method, onFound);
}

var ctors = type.GetConstructors(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (var ctor in ctors)
{
Find(ctor, onFound);
}
}

static void Find(MethodBase methodInfo, FoundDelegater onFound)
{
var body = methodInfo.GetMethodBody();
Expand Down
Empty file modified MarkdownTemplate.cs
100644 → 100755
View file
Open in desktop
Empty file.
11 changes: 10 additions & 1 deletion OptionParser.cs
100644 → 100755
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,9 +9,11 @@ class OptionParser
{
IEnumerable<string> _sources;
IEnumerable<string> _targets;
bool _isbase;

const string SourceOption = "-s";
const string TargetOption = "-t";
const string BaseOption = "-b";
const string HelpOption = "-h";

string option = null;
Expand All @@ -21,6 +23,7 @@ public OptionParser(string[] args)
List<string> sources = new List<string>();
List<string> targets = new List<string>();
List<string> others = new List<string>();
bool isbase = false;

foreach (var arg in args)
{
Expand All @@ -32,9 +35,12 @@ public OptionParser(string[] args)
{
option = TargetOption;
}
else if (arg == BaseOption)
{
isbase = true;
}
else if (arg == HelpOption)
{
Help();
return;
}
else
Expand All @@ -61,17 +67,20 @@ public OptionParser(string[] args)

_sources = sources;
_targets = targets;
_isbase = isbase;
}

public void Help()
{
var name = this.GetType().Assembly.GetName().Name;
Console.WriteLine($"Usage: {name} <source dll>");
Console.WriteLine($"Usage: {name} [{SourceOption}] <source dlls> [{TargetOption}] <target dlls>");
Console.WriteLine($"Usage: {name} [{BaseOption}] [{SourceOption}] <source dlls> [{TargetOption}] <target dlls>");
Console.WriteLine($"Usage: {name} [{HelpOption}]");
}

public IEnumerable<string> Sources => _sources;
public IEnumerable<string> Targets => _targets;
public bool IsBase => _isbase;
}
}
Loading