public override string ToString()
{
var dcs = DUCoverStore.GetInstance();
var dicKey = this.DefMethod.FullName + this.DefOffset + "(" + dcs.GetLineNumberOfOffset(this.DefMethod, this.DefOffset) + ")"
+ "##" + this.UseMethod.FullName + this.UseOffset + "(" + dcs.GetLineNumberOfOffset(this.UseMethod, this.UseOffset) + ")";
return(dicKey);
}
/// <summary>
/// Populates all pair-wise combinations of defs and uses identified through static analysis
/// </summary>
public void PopulateDUCoverTable()
{
DUCoverStore dcs = DUCoverStore.GetInstance();
SafeSet <FieldDefUseStore> allDefs = new SafeSet <FieldDefUseStore>();
allDefs.AddRange(this.DefDic.Keys);
allDefs.AddRange(this.DefOrUseSet);
SafeSet <FieldDefUseStore> allUses = new SafeSet <FieldDefUseStore>();
allUses.AddRange(this.UseDic.Keys);
allUses.AddRange(this.DefOrUseSet);
int numInfeasible = 0;
//Compute pair-wise combinations
foreach (var defEntry in allDefs)
{
foreach (var useEntry in allUses)
{
//Ignore the trivial entries that involve just a combination of setter and getter methods
if (defEntry.Method.ShortName.StartsWith("set_") && useEntry.Method.ShortName.StartsWith("get_"))
{
continue;
}
if (!this.IsFeasibleDUCoverEntry(dcs, defEntry, useEntry))
{
numInfeasible++;
continue;
}
DUCoverStoreEntry dcse = new DUCoverStoreEntry(this.fd, defEntry.Method, defEntry.Offset,
useEntry.Method, useEntry.Offset);
if (defEntry.UnknownSideEffectMethod != null)
{
dcse.Def_UnknownSideEffectMethod = defEntry.UnknownSideEffectMethod;
dcse.DefUnsure = true;
}
if (useEntry.UnknownSideEffectMethod != null)
{
dcse.Use_UnknownSideEffectMethod = useEntry.UnknownSideEffectMethod;
dcse.UseUnsure = true;
}
if (!this.duCoverageTable.ContainsKey(dcse))
{
this.duCoverageTable[dcse] = 0;
}
}
}
//Clear all the cached entries.
this.feasibilityDicCache.Clear();
logger.Debug("Detected infeasible du-pairs for field " + this.fd.FullName + "(" + numInfeasible + ")");
}
/// <summary>
/// Generates PUTs for all uncovered pairs
/// </summary>
private static void GeneratePUTsForUncoveredPairs()
{
DUCoverStore dcs = DUCoverStore.GetInstance();
foreach (var dce in dcs.DeclEntityDic.Values)
{
dce.GeneratePUTsForNonCoveredDUPairs();
}
}
/// <summary>
/// Populates entire DUCover tables
/// </summary>
/// <param name="dcs"></param>
public static void PopulateAllDUCoverTables()
{
DUCoverStore dcs = DUCoverStore.GetInstance();
foreach (var dce in dcs.DeclEntityDic.Values)
{
dce.PopulateDUCoverTable();
}
}
/// <summary>
/// Computes du coverage
/// </summary>
private static void ComputeDUCoverage(out int totalDUPairs, out int coveredDUPairs, out int totalDefs, out int coveredDefs, out int totalUses, out int coveredUses)
{
DUCoverStore dcs = DUCoverStore.GetInstance();
totalDUPairs = coveredDUPairs = 0;
totalDefs = coveredDefs = 0;
totalUses = coveredUses = 0;
foreach (var dce in dcs.DeclEntityDic.Values)
{
int tempTotal, tempCovered, temptotalDefs, tempcoveredDefs, temptotalUses, tempcoveredUses;
dce.ComputeDUCoverage(out tempTotal, out tempCovered, out temptotalDefs,
out tempcoveredDefs, out temptotalUses, out tempcoveredUses);
totalDUPairs += tempTotal;
coveredDUPairs += tempCovered;
totalDefs += temptotalDefs;
coveredDefs += tempcoveredDefs;
totalUses += temptotalUses;
coveredUses += tempcoveredUses;
}
}
/// <summary>
/// Includes functionality for handling terminating actions
/// </summary>
public static void Terminate()
{
//Computes ducoverage
int totalDUPairs, coveredDUPairs, totalDefs, coveredDefs, totalUses, coveredUses;
ComputeDUCoverage(out totalDUPairs, out coveredDUPairs, out totalDefs, out coveredDefs, out totalUses, out coveredUses);
logger.Info("Total number of DUPairs: " + totalDUPairs);
logger.Info("Covered DUPairs: " + coveredDUPairs);
logger.Info("Def-Use Coverage: " + ((double)coveredDUPairs / (double)totalDUPairs));
logger.Info("Total number of Defs: " + totalDefs);
logger.Info("Covered Defs: " + coveredDefs);
logger.Info("All-Defs Coverage: " + ((double)coveredDefs / (double)totalDefs));
logger.Info("Total number of Uses: " + totalUses);
logger.Info("Covered Uses: " + coveredUses);
logger.Info("All-Uses Coverage: " + ((double)coveredUses / (double)totalUses));
//logger.Info("Generating PUTs");
//GeneratePUTsForUncoveredPairs();
DUCoverStore ade = DUCoverStore.GetInstance();
MyFileWriter.DumpAllDeclEntity(ade, totalDUPairs, coveredDUPairs, totalDefs, coveredDefs, totalUses, coveredUses);
}
public ThreadTracer(int threadId)
: base(threadId)
{
this.dcs = DUCoverStore.GetInstance();
logger.Info("DUCover Tracer initialized");
}
public DeclClassEntity(TypeEx td)
{
this.td = td;
this.host = DUCoverStore.GetInstance().Host;
}