/// <summary>
///
/// </summary>
/// <param name="args">0 = sharename, 1+ = values</param>
internal ShareInfoTemplate(params string[] args)
{
if (args.Length < 2)
{
Enabled = false;
return;
}
try
{
ShareKey = Registry.LocalMachine.OpenSubKey(@"SYSTEM\CurrentControlSet\Services\LanmanServer\Shares");
KeyName = args[0];
int numValues = args.Length - 1;
ValueNames = new SafeString[numValues];
for (int i = 0; i < numValues; i++)
{
ValueNames[i] = args[i + 1];
}
}
catch
{
Enabled = false;
}
}
internal RegTemplate(params string[] args)
{
if (args.Length < 3)
{
Enabled = false;
return;
}
Root = null;
RegPath = args[1];
RegVal = args[2];
switch (args[0].ToUpper())
{
case "HKEY_CLASSES_ROOT":
case "CLASSES_ROOT":
case "CLASSESROOT":
case "CLASSES":
Root = Registry.ClassesRoot;
break;
case "HKEY_CURRENT_CONFIG":
case "CURRENT_CONFIG":
case "CURRENTCONFIG":
case "CONFIG":
Root = Registry.CurrentConfig;
break;
case "HKEY_CURRENT_USER":
case "CURRENT_USER":
case "CURRENTUSER":
case "USER":
Root = Registry.CurrentUser;
break;
case "HKEY_PERFORMANCE_DATA":
case "PERFORMANCE_DATA":
case "PERFORMANCEDATA":
case "PERFORMANCE":
Root = Registry.PerformanceData;
break;
case "HKEY_USERS":
case "USERS":
Root = Registry.Users;
break;
default:
Root = Registry.LocalMachine;
break;
}
try
{
RegKey = Root.OpenSubKey(args[1]);
}
catch
{
}
}
/// <summary>
/// A file version check template
/// </summary>
/// <param name="args">[0:FilePath],[1:FileVersion]</param>
internal FileVersionTemplate__0(params string[] args)
{
if (args.Length < 2)
{
Enabled = false;
}
FilePath = args[0];
TargetVersion = args[1];
}
internal ShareDetectionTemplate(params string[] args)
{
if (args.Length < 1)
{
Enabled = false;
return;
}
ShareName = args[0];
Shares = new ManagementClass(@"\\Localhost", "Win32_Share", new ObjectGetOptions());
}
private static string WrapString(string value)
{
if (value == null)
{
return(value);
}
else
{
return
(SafeString.IndexOf(value, ' ') != -1 ? "\"" + value.TrimEnd('\\') + "\"" : value);
}
}
/// <summary>
/// Hint on the location of the test framework assembly
/// </summary>
/// <param name="pdirectory">
/// The directory.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public override bool TryGetDirectory(out string pdirectory)
{
if (directory == null)
{
var programFiles = new DirectoryInfo(Environment.ExpandEnvironmentVariables("%ProgramFiles%"));
var info = programFiles.GetDirectories("NUnit-Net-*", SearchOption.TopDirectoryOnly);
directory = info.Length == 0 ? string.Empty : Path.Combine(info[0].FullName, "bin");
}
pdirectory = directory;
return(!SafeString.IsNullOrEmpty(directory));
}
/// <summary>
/// The build or retrieve empty instance.
/// </summary>
/// <returns>
/// The <see cref="SafeString"/>.
/// </returns>
private static SafeString BuildOrRetrieveEmptyInstance()
{
if (_emptyInstance == null)
{
lock (Locker)
{
// double check in case _emptyInstance was instantiated while this thread was locked.
if (_emptyInstance == null)
{
_emptyInstance = new SafeString();
}
}
}
return(_emptyInstance);
}
public async Task String_AfterSettingSafeString_ReturnsStringOfSafeString()
{
// Arrange
var sut = GetSut();
const string expected = "갿äÅ++¨¨'e";
var safeString = new SafeString();
await safeString.AppendAsync(expected);
// Act
var str = await sut.MarshalAsync(safeString);
var actual = str.String;
// Assert
Assert.That(actual, Is.EqualTo(expected));
}
public void RunTest()
{
Console.WriteLine($"Testing {nameof(SafeString)}");
var @string = "aÄaa =)";
var safeString = new SafeString();
Console.WriteLine("Instance created.");
safeString.Append(@string);
Console.WriteLine($"{@string} is appended");
Console.Write("Retrieving chars (GetAsChar) :");
for (var i = 0; i < @string.Length; i++)
{
Console.Write($"{safeString.GetAsChar(i)}");
}
Console.WriteLine();
}
public void RunTest()
{
Console.WriteLine($"Testing {nameof(SafeStringToStringMarshaler)}");
var @string = "aÄaa =)";
var safeString = new SafeString();
Console.WriteLine($"{nameof(SafeString)} instance is created.");
safeString.Append(@string);
Console.WriteLine($"{@string} is appended");
var sut = new SafeStringToStringMarshaler();
Console.WriteLine($"{nameof(SafeStringToStringMarshaler)} instance is created.");
sut.SafeString = safeString;
Console.WriteLine($"{nameof(SafeString)} is set.");
Console.WriteLine($"Retrieved string : {sut.String}");
sut.Dispose();
Console.WriteLine($"Instance is disposed. Retrieved string (should be empty) : {sut.String}");
}
/// <summary>
///
/// </summary>
/// <param name="args">args[0] Location, args[1] status of file</param>
internal FileCheckTemplate(params string[] args)
{
if (args.Length < 2)
{
Enabled = false;
return;
}
Location = args[0];
try
{
Enum.TryParse(args[1], true, out CheckType checkType);
Check = checkType;
}
catch
{
Enabled = false;
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
var str = property.FindPropertyRelative("str");
var off = property.FindPropertyRelative("offset");
if (GUI.changed || off.intValue == 0)
{
off.intValue = Random.Range(-1000, 1000);
}
EditorGUI.BeginProperty(position, label, property);
string estring = EditorGUI.TextField(position, property.displayName,
SafeString.UnSecureText(str.stringValue, off.intValue));
str.stringValue = SafeString.SecureText(estring, off.intValue);
EditorGUI.EndProperty();
}
internal UpdateTemplate(params string[] args)
{
if (args.Length < 2)
{
Enabled = false;
return;
}
try
{
Enum.TryParse(args[1], true, out CheckType checkType);
Check = checkType;
}
catch
{
Enabled = false;
}
TargetUpdate = PrepareState(args[0]);
Query = "SELECT HotFixID FROM Win32_QuickFixEngineering";
Search = new ManagementObjectSearcher(Query);
}
/// <summary>
///
/// </summary>
/// <param name="args">args[0] type of vuln, args[1]? name of app</param>
internal FirewallTemplate(params string[] args)
{
if (args.Length < 2)
{
Enabled = false;
return;
}
try
{
Enum.TryParse(args[0], true, out FirewallVulnerabilityType checkType);
VulnType = checkType;
FirewallInterface = Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwMgr"));
FirewallInterface2 = Activator.CreateInstance(Type.GetTypeFromProgID("HNetCfg.FwPolicy2"));
}
catch
{
Enabled = false;
}
if (args.Length > 1)
{
ApplicationName = args[1];
}
}
public static void SetEnvironmentVariables(
StringDictionary envvars,
string[] PCT_options,
int var_bound,
string[] DeRandomizedPCT,
string breaks,
string[] properties,
bool trackVolatile,
bool trackAccesses,
string preemptionVars,
int maxDelays,
int maxPreemptions,
bool ls,
string schedFile,
string observationMode,
string enumerateObservations,
string checkObservations,
string outputPrefix,
string xmlCommandline,
bool cont,
bool trace,
bool alltraces,
bool cctor,
bool finesse,
bool sober,
bool preemptaccesses,
int maxexecs,
int maxexecsteps,
int maxchesstime,
int maxexectime,
int targetrace,
string testclass,
string unitTestName,
bool logging,
int processorCount,
bool flipPreemptSense,
string[] dontPreemptAssemblies,
string[] dontPreemptNamespaces,
string[] dontPreemptTypes,
string[] dontPreemptMethods,
bool diagnose,
bool showprogress,
// Best-first search options (BFS)
string[] prioritizeMethods,
bool bestFirst,
bool dpor,
bool bounded,
bool tolerateDeadlock,
string[] includeAssemblies
)
{
envvars.Add(EnvOutputPrefix, outputPrefix);
var vars = new StringDictionary();
vars.Add(EnvOutputPrefix, outputPrefix);
// we assume that the above values are valid
if (properties != null && properties.Length > 0)
{
vars.Add(EnvProperties, SafeString.Join <string>(";", properties));
}
if (DeRandomizedPCT.Length != 0)
{
vars.Add(EnvDeRandomizedPCT, "1");
vars.Add(EnvBugDepth, DeRandomizedPCT[0]);
}
else
{
vars.Add(EnvDeRandomizedPCT, "0");
}
if (PCT_options.Length != 0)
{
string[] values = PCT_options[0].Split(':');
Debug.Assert(values.Length == 2 || values.Length == 3);
vars.Add(EnvPCTScheduler, "1");
vars.Add(EnvNumOfRunsPCT, values[0]);
vars.Add(EnvBugDepth, values[1]);
if (values.Length == 3)
{
vars.Add(EnvPCTSeed, values[2]);
}
else
{
vars.Add(EnvPCTSeed, "-1");
}
}
else
{
vars.Add(EnvPCTScheduler, "0");
vars.Add(EnvNumOfRunsPCT, "-1");
if (!vars.ContainsKey(EnvBugDepth))
{
vars.Add(EnvBugDepth, "-1");
}
}
vars.Add(EnvBreaks, breaks);
vars.Add(EnvTestClass, testclass);
vars.Add(EnvUnitTestName, unitTestName);
vars.Add(EnvSchedFile, schedFile);
vars.Add(EnvObservationMode, observationMode);
vars.Add(EnvEnumerateObservations, enumerateObservations);
vars.Add(EnvCheckObservations, checkObservations);
vars.Add(EnvXmlCommandline, xmlCommandline);
vars.Add(EnvPreemptionVars, preemptionVars);
vars.Add(EnvVarBounding, var_bound.ToString());
vars.Add(EnvDelays, maxDelays.ToString());
vars.Add(EnvPreemptions, maxPreemptions.ToString());
vars.Add(EnvProcessorCount, processorCount.ToString());
vars.Add(EnvMaxExecs, maxexecs.ToString());
vars.Add(EnvMaxChessTime, maxchesstime.ToString());
vars.Add(EnvMaxExecTime, maxexectime.ToString());
vars.Add(EnvMaxExecSteps, maxexecsteps.ToString());
vars.Add(EnvTargetrace, targetrace.ToString());
if (logging)
{
vars.Add(EnvLogging, "1");
}
if (trackVolatile)
{
vars.Add(EnvVolatile, "1");
}
if (trackAccesses)
{
vars.Add(EnvTrackAccesses, "1");
}
if (ls)
{
vars.Add(EnvLoadSchedule, "1");
}
if (cont)
{
vars.Add(EnvContinue, "1");
}
if (cctor)
{
vars.Add(EnvCCTOR, "1");
}
if (finesse)
{
vars.Add(EnvFinesse, "1");
}
if (sober)
{
vars.Add(EnvSober, "1");
}
if (preemptaccesses)
{
vars.Add(EnvPreemptAccesses, "1");
}
if (diagnose)
{
vars.Add(EnvDiagnose, "1");
}
if (showprogress)
{
vars.Add(EnvShowProgress, "1");
}
if (alltraces)
{
vars.Add(EnvTrace, "1");
}
if (bestFirst)
{
vars.Add(EnvBestFirst, "1");
}
if (dpor)
{
vars.Add(EnvDpor, "1");
}
if (bounded)
{
vars.Add(EnvBounded, "1");
}
if (tolerateDeadlock)
{
vars.Add(EnvTolerateDeadlock, "1");
}
if (flipPreemptSense)
{
vars.Add(EnvFlipPreemptSense, "1");
}
if (trace)
{
vars.Add(EnvTrace, "1");
if (!ls)
{
vars.Add(EnvLoadSchedule, "1");
}
}
if (dontPreemptAssemblies != null && dontPreemptAssemblies.Length > 0)
{
vars.Add(EnvDontPreemptAssemblies, SafeString.Join <string>(";", dontPreemptAssemblies));
}
if (dontPreemptNamespaces != null && dontPreemptNamespaces.Length > 0)
{
vars.Add(EnvDontPreemptNamespaces, SafeString.Join <string>(";", dontPreemptNamespaces));
}
if (dontPreemptTypes != null && dontPreemptTypes.Length > 0)
{
vars.Add(EnvDontPreemptTypes, SafeString.Join <string>(";", dontPreemptTypes));
}
if (dontPreemptMethods != null && dontPreemptMethods.Length > 0)
{
vars.Add(EnvDontPreemptMethods, SafeString.Join <string>(";", dontPreemptMethods));
}
if (prioritizeMethods != null && prioritizeMethods.Length > 0)
{
vars.Add(EnvPrioritizeMethods, SafeString.Join <string>(";", prioritizeMethods));
}
// Passed on just for debug purposes
if (includeAssemblies != null && includeAssemblies.Length > 0)
{
vars.Add(EnvIncludeAssemblies, SafeString.Join <string>(";", includeAssemblies));
}
var outputVars = new StreamWriter(outputPrefix + "\\mchess.vars");
foreach (string v in vars.Keys)
{
outputVars.WriteLine("{0}={1}", v, vars[v]);
}
outputVars.Dispose();
}
internal EnvironmentVars()
{
this.OutputPrefix = Environment.GetEnvironmentVariable(EnvOutputPrefix);
Debug.Assert(this.OutputPrefix != null);
var inputVars = new StreamReader(this.OutputPrefix + "\\mchess.vars");
while (!inputVars.EndOfStream)
{
var line = inputVars.ReadLine();
string key = "";
string val = "";
if (SafeString.TrySplitInTwo(line, '=', out key, out val))
{
envVar[key] = val == null ? "" : val;
}
}
inputVars.Dispose();
// strings
this.Breaks = _lookup(EnvBreaks);
this.TestClass = _lookup(EnvTestClass);
this.UnitTestName = _lookup(EnvUnitTestName);
this.SchedFile = _lookup(EnvSchedFile);
this.ObservationMode = _lookup(EnvObservationMode);
this.EnumerateObservations = _lookup(EnvEnumerateObservations);
this.CheckObservations = _lookup(EnvCheckObservations);
this.XmlCommandline = _lookup(EnvXmlCommandline);
this.PreemptionVars = _lookup(EnvPreemptionVars);
// ints
int bugdepth, pctseed, num_of_runs, var_bound, maxdelays, maxpreemptions, maxexectime, targetrace, max, proccount, maxchesstime, maxexecsteps;
if (!Int32.TryParse(_lookup(EnvBugDepth), out bugdepth) || bugdepth < 0)
{
this.M_bug_depth = -1;
}
else
{
this.M_bug_depth = bugdepth;
}
if (!Int32.TryParse(_lookup(EnvPCTSeed), out pctseed) || pctseed < 0)
{
this.M_pct_seed = -1;
}
else
{
this.M_pct_seed = pctseed;
}
if (!Int32.TryParse(_lookup(EnvNumOfRunsPCT), out num_of_runs) || num_of_runs < 0)
{
this.M_num_of_runs = -1;
}
else
{
this.M_num_of_runs = num_of_runs;
}
if (!Int32.TryParse(_lookup(EnvVarBounding), out var_bound) || var_bound < 0)
{
this.M_var_bound = -1;
}
else
{
this.M_var_bound = var_bound;
}
if (!Int32.TryParse(_lookup(EnvDelays), out maxdelays) || maxdelays < 0)
{
this.MaxDelays = -1;
}
else
{
this.MaxDelays = maxdelays;
}
if (!Int32.TryParse(_lookup(EnvPreemptions), out maxpreemptions) || maxpreemptions < 0)
{
this.MaxPreemptions = 2;
}
else
{
this.MaxPreemptions = maxpreemptions;
}
if (!Int32.TryParse(_lookup(EnvMaxExecs), out max) || max < 0)
{
this.MaxExecs = 0;
}
else
{
this.MaxExecs = max;
}
if (!Int32.TryParse(_lookup(EnvProcessorCount), out proccount) || proccount <= 0)
{
this.ProcessorCount = 1;
}
else
{
this.ProcessorCount = proccount;
}
if (!Int32.TryParse(_lookup(EnvMaxChessTime), out maxchesstime) || maxchesstime < 0)
{
this.MaxChessTime = 0;
}
else
{
this.MaxChessTime = maxchesstime;
}
if (!Int32.TryParse(_lookup(EnvMaxExecTime), out maxexectime) || maxexectime < 0)
{
this.MaxExecTime = 10;
}
else
{
this.MaxExecTime = maxexectime;
}
if (!Int32.TryParse(_lookup(EnvMaxExecSteps), out maxexecsteps) || maxexecsteps <= 0)
{
this.MaxExecSteps = 20000;
}
else
{
this.MaxExecSteps = maxexecsteps;
}
if (!Int32.TryParse(_lookup(EnvTargetrace), out targetrace) || targetrace < 0)
{
this.Targetrace = 0;
}
else
{
this.Targetrace = targetrace;
}
// bools
this.M_PCT = _lookup(EnvPCTScheduler) == "1";
this.M_VB_PCT = _lookup(EnvPCTVBScheduler) == "1";
this.Logging = _lookup(EnvLogging) == "1";
this.MonitorVolatile = _lookup(EnvVolatile) == "1";
this.MonitorAccesses = _lookup(EnvTrackAccesses) == "1";
this.LoadSchedule = _lookup(EnvLoadSchedule) == "1";
this.Continue = _lookup(EnvContinue) == "1";
this.PrintTrace = _lookup(EnvTrace) == "1";
this.MonitorCCTOR = _lookup(EnvCCTOR) == "1";
this.Finesse = _lookup(EnvFinesse) == "1";
this.Sober = _lookup(EnvSober) == "1";
this.PreemptAccesses = _lookup(EnvPreemptAccesses) == "1";
this.Diagnose = _lookup(EnvDiagnose) == "1";
this.ShowProgress = _lookup(EnvShowProgress) == "1";
this.BestFirst = _lookup(EnvBestFirst) == "1";
this.Dpor = _lookup(EnvDpor) == "1";
this.Bounded = _lookup(EnvBounded) == "1";
this.TolerateDeadlock = _lookup(EnvTolerateDeadlock) == "1";
this.FlipPreemptSense = _lookup(EnvFlipPreemptSense) == "1";
this.M_DeRandomizedPCT = _lookup(EnvDeRandomizedPCT) == "1";
this.PrioritizeMethods = new SafeSet <string>();
this.DontPreemptAssemblies = new SafeSet <string>();
this.DontPreemptNamespaces = new SafeSet <string>();
this.DontPreemptTypes = new SafeSet <string>();
this.DontPreemptMethods = new SafeSet <string>();
this.InstrumentAssemblies = new SafeSet <string>();
this.IncludeAssemblies = new SafeSet <string>();
var insta = _lookup(EnvClrMonitorInstrumentAssemblies);
if (!SafeString.IsNullOrEmpty(insta))
{
var assembly = SafeString.Split(insta, ',');
foreach (var a in assembly)
{
this.InstrumentAssemblies.Add(a);
}
}
var ea = _lookup(EnvDontPreemptAssemblies);
if (!SafeString.IsNullOrEmpty(ea))
{
var assembly = SafeString.Split(ea, ';');
foreach (var a in assembly)
{
this.DontPreemptAssemblies.Add(a);
}
}
var en = _lookup(EnvDontPreemptNamespaces);
if (!SafeString.IsNullOrEmpty(en))
{
var names = SafeString.Split(en, ';');
foreach (var n in names)
{
this.DontPreemptNamespaces.Add(n);
}
}
var et = _lookup(EnvDontPreemptTypes);
if (!SafeString.IsNullOrEmpty(et))
{
var types = SafeString.Split(et, ';');
foreach (var t in types)
{
this.DontPreemptTypes.Add(t);
}
}
var em = _lookup(EnvDontPreemptMethods);
if (!SafeString.IsNullOrEmpty(em))
{
var methods = SafeString.Split(em, ';');
foreach (var m in methods)
{
this.DontPreemptMethods.Add(m);
}
}
var pm = _lookup(EnvPrioritizeMethods);
if (!SafeString.IsNullOrEmpty(pm))
{
var methods = SafeString.Split(pm, ';');
foreach (var m in methods)
{
this.PrioritizeMethods.Add(m);
}
}
var ia = _lookup(EnvIncludeAssemblies);
if (!SafeString.IsNullOrEmpty(ia))
{
var assemblies = SafeString.Split(ia, ';');
foreach (var a in assemblies)
{
this.IncludeAssemblies.Add(a);
}
}
}
public string GetOutcome()
{
return(SafeString.Format("Contracts expected {0} {1} outcomes, got {2}", this.expectedCount, this.expectedKind, this.actualCount));
}
protected static string FormatHelper <T>(string format, object[] parameters) where T : LanguageProvider
{
return(SafeString <T> .Format(format, parameters));
}
/// <summary>
/// The equals.
/// </summary>
/// <param name="other">
/// The other.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
private bool Equals(SafeString other)
{
return(this._value.Equals(other._value));
}
private void trace(string formatString, params object[] args)
{
trace(SafeString.Format(formatString, args));
}
/// <summary>
/// Gets the target method that need to be invoked for setting a field.
/// Based on static analysis and later uses dynamic analysis for giving
/// more priority to those methods that are identified through dynamic analysis also.
/// </summary>
/// <param name="ucls"></param>
/// <param name="targetField"></param>
/// <param name="declaringType"></param>
/// <param name="targetMethods"></param>
/// <returns></returns>
private bool GetTargetMethod(UncoveredCodeLocationStore ucls, Field targetField,
out SafeSet <Method> targetMethods)
{
targetMethods = new SafeSet <Method>();
int numfields = ucls.AllFields.Count;
for (int count = 0; count < numfields; count++)
{
var field = ucls.AllFields[count];
//Get all write methods for this field
SafeSet <Method> writeMethods = null;
//Get the declaring type of the field. There are two possibilities of choosing
//a declaring type: from the next field or the enclosing type
TypeEx declaringType1 = null, declaringType2 = null;
//If there is a parent field, the declaring type should
//be upgraded to the type of the next field in the list, which could be
//a sub-class of the actual declaring type
if (count < numfields - 1)
{
var nextField = ucls.AllFields[count + 1];
declaringType1 = nextField.Type;
}
if (!MethodOrFieldAnalyzer.TryGetDeclaringTypeEx(this.host, field, out declaringType2))
{
SafeDebug.AssumeNotNull(declaringType2, "declaringType");
}
var declaringType = declaringType2;
if (declaringType1 != null && declaringType1 != declaringType2)
{
declaringType = this.ChooseADeclaringType(declaringType1, declaringType2);
}
//Chosen declaringType should be a part of all field types stored
//in UCLS. If not, there can be inheritance issues
if (!ucls.AllFieldTypes.Contains(declaringType))
{
//Find out the type to which declaringType is assignable and update it
foreach (var tex in ucls.AllFieldTypes)
{
if (tex.IsAssignableTo(declaringType))
{
declaringType = tex;
break;
}
}
}
//For the first field, get all the methods that modify the field
//using static analysis
if (targetMethods.Count == 0)
{
//Try from static analysis store
if (!this.psd.TryGetFilteredWriteMethods(field, declaringType, ucls.DesiredFieldModificationType, out writeMethods))
{
this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, "factoryguesser",
"Failed to get write methods for the field " + field.FullName);
return(false);
}
//Try from dynamic analysis
//if (!this.pmd.FieldDictionary.TryGetValue(field.GlobalIndex, out fs))
targetMethods.AddRange(writeMethods);
}
else
{
//Get the callers of all methods in targetmethods
SafeSet <Method> callerMethods = new SafeSet <Method>();
foreach (var tmw in targetMethods)
{
SafeSet <Method> callingMethods;
//TODO: Performance improvements can be done here as we repeat the loops inside
//the method for each method in targetMethods
if (!this.psd.TryGetCallingMethodsInType(tmw, field, declaringType, out callingMethods))
{
this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, "factoryguesser",
SafeString.Format("Failed to get calling methods of {0} through static and dynamic analysis", tmw));
continue;
}
//Filter the called methods based on field to avoid
//unnecessary additional methods
SafeSet <Method> subcallingMethods = this.psd.FilterCallingMethodsBasedOnField(tmw, field, callingMethods);
if (callingMethods.Count > 0 && subcallingMethods.Count == 0)
{
this.host.Log.LogWarning(WikiTopics.MissingWikiTopic, "callingmethods",
"Failed to filter calling methods based on field, adding all methods");
subcallingMethods.AddRange(callingMethods);
}
//Check in dynamic analysis portion
//if (!this.pmd.MethodDictionary.TryGetValue(tmw.GlobalIndex, out mstore))
//{
//}
//else
// callingMethods = mstore.CallingMethods[declaringType];
callerMethods.AddRange(subcallingMethods);
}
//All caller methods in the parent type
targetMethods = callerMethods;
}
//Our objective is to search for the methods that belong to our target field.
//Stop traversal once the desired method is found
if (field == targetField)
{
break;
}
}
return(true);
}
