private List<CustomCompareResult> ConvertToCustomResult(CompareResult compareResult)
{
var convertResult = new List<CustomCompareResult>();
var featureName = string.Empty;
foreach (var featureFolderCompareResult in compareResult.ListFeatureFolderCompareResult)
{
featureName = featureFolderCompareResult.FeatureFolderName;
foreach (var dataFileCompareResult in featureFolderCompareResult.ListDataFileCompareResult)
{
var customCompareResult = new CustomCompareResult();
customCompareResult.Feature = featureName;
switch (dataFileCompareResult.Status)
{
case FileCompareStatus.FirstFolderOnly:
customCompareResult.FileName1 = dataFileCompareResult.FileName;
customCompareResult.FileName2 = string.Empty;
break;
case FileCompareStatus.SecondFolderOnly:
customCompareResult.FileName1 = string.Empty;
customCompareResult.FileName2 = dataFileCompareResult.FileName;
break;
case FileCompareStatus.DifferentContent:
customCompareResult.FileName1 = dataFileCompareResult.FileName;
customCompareResult.FileName2 = dataFileCompareResult.FileName;
break;
}
convertResult.Add(customCompareResult);
}
}
return convertResult;
}
private static void BuildFeatureCompareResultExistInOneFolderOnly(IEnumerable<string> notExistInOtherDir,
List<DirectoryInfo> featureFolderList,
CompareResult compareResult,
bool isFirstFolder)
{
foreach (var feature in notExistInOtherDir)
{
var folder = featureFolderList.First(x => x.Name == feature);
var featureCompareResult = new FeatureFolderCompareResult();
featureCompareResult.FeatureFolderName = folder.Name;
featureCompareResult.FeatureFolderFullName = folder.FullName;
featureCompareResult.Status = isFirstFolder
? FolderCompareStatus.FirstFolderOnly
: FolderCompareStatus.SecondFolderOnly;
var files = folder.GetFiles("*.json").ToList();
foreach (var fileInfo in files)
{
var fileCompareResult = new DataFileCompareResult();
fileCompareResult.FileName = fileInfo.Name;
fileCompareResult.FullName = fileInfo.FullName;
fileCompareResult.Status = isFirstFolder
? FileCompareStatus.FirstFolderOnly
: FileCompareStatus.SecondFolderOnly;
featureCompareResult.ListDataFileCompareResult.Add(fileCompareResult);
}
compareResult.ListFeatureFolderCompareResult.Add(featureCompareResult);
}
}
public void SetUp()
{
this.result = true;
this.name = "Value of name";
this.comparer = "Value of comparer";
this.testObject = new CompareResult(this.result, this.name, this.comparer);
}
public override void Render(IBackForeColor backForeColor, CompareResult compareResult, ColorConfig colorConfig)
{
if (compareResult.IsNormal)
{
backForeColor.BackColor = colorConfig.NormalColor;
}
else
{
backForeColor.BackColor = colorConfig.ExceptionColor;
}
}
private void CreateResult(ResultType resultType, DatabaseStoredProcedure storedProcedure, string script)
{
var result = new CompareResult
{
SchemaObjectType = SchemaObjectType.StoredProcedure,
ResultType = resultType,
Name = storedProcedure.Name,
SchemaOwner = storedProcedure.SchemaOwner,
Script = script
};
_results.Add(result);
}
private void CreateResult(ResultType resultType, DatabasePackage package, string script)
{
var result = new CompareResult
{
SchemaObjectType = SchemaObjectType.Package,
ResultType = resultType,
Name = package.Name,
SchemaOwner = package.SchemaOwner,
Script = script
};
_results.Add(result);
}
private void CreateResult(ResultType resultType, DatabaseSequence sequence, string script)
{
var result = new CompareResult
{
SchemaObjectType = SchemaObjectType.Sequence,
ResultType = resultType,
Name = sequence.Name,
SchemaOwner = sequence.SchemaOwner,
Script = script
};
_results.Add(result);
}
private void CreateResult(ResultType resultType, DatabaseView view, string script)
{
var result = new CompareResult
{
SchemaObjectType = SchemaObjectType.View,
ResultType = resultType,
Name = view.Name,
SchemaOwner = view.SchemaOwner,
Script = script
};
_results.Add(result);
}
private void CreateResult(ResultType resultType, DatabaseFunction function, string script)
{
var result = new CompareResult
{
SchemaObjectType = SchemaObjectType.Function,
ResultType = resultType,
Name = function.Name,
SchemaOwner = function.SchemaOwner,
Script = script
};
_results.Add(result);
}
private void CreateResult(ResultType resultType, DatabaseTable table, string name, string script)
{
var result = new CompareResult
{
SchemaObjectType = SchemaObjectType.Trigger,
ResultType = resultType,
TableName = table.Name,
SchemaOwner = table.SchemaOwner,
Name = name,
Script = script
};
_results.Add(result);
}
private void ProcessMatch(Dictionary<Submission, FriendOf> friends, CompareResult result, Submission submission, double similarity, double min_friend_finder_similarity)
{
FriendOf f;
if (similarity > min_friend_finder_similarity)
{
if (!friends.TryGetValue(submission, out f))
{
friends.Add(submission, f = new FriendOf(submission));
}
f.SumSimilarity += similarity;
f.InMatches.Add(result);
}
}
// POST api/evaluatetext
public CompareResult Post([FromBody]CompareRequest request)
{
if (!ModelState.IsValid)
{
//logg results
return null;
}
StringCompare sc = new StringCompare(request.subtext, request.text);
CompareResult result = new CompareResult(){
Text = request.text,
Subtext = request.subtext,
result = sc.Indexes
};
return result;
}
public IEnumerable<string> Format(CompareResult result)
{
foreach (var serializedEntity in result.Unexpected.Select(_serializer))
{
yield return $"unexpected: {serializedEntity}";
}
foreach (var serializedEntity in result.Missing.Select(_serializer))
{
yield return $"missing: {serializedEntity}";
}
foreach (var serializedEntity in result.Wrong.Select(tuple => Tuple.Create(_serializer.Invoke(tuple.Item1), _serializer.Invoke(tuple.Item2))))
{
Debug.Indent();
yield return $"wrong: actual: {serializedEntity.Item1}, expected: {serializedEntity.Item2}";
}
}
public CompareResult Compare(SchemaSpecification otherSpec)
{
CompareResult result = new CompareResult();
foreach (var eachTable in _tableList)
{
Table otherTable = otherSpec.FindTableByName(eachTable.Name);
if (otherTable == null)
result.AddMissing(eachTable);
else
{
CompareResult compareResult = eachTable.Compare(otherTable);
if (compareResult.HaveValues)
{
var conflict = new SpecificationConflict(new Pair<Table>(eachTable, otherTable), compareResult);
result.AddConflict(conflict);
}
}
}
return result;
}
//expected folder structure
//[folderRoot]\[feature name]\[id].json
public static CompareResult Compare(string pathToFirstFolder, string pathToSecondFolder)
{
var firstDir = new DirectoryInfo(pathToFirstFolder);
var secondDir = new DirectoryInfo(pathToSecondFolder);
if (firstDir.Exists == false || secondDir.Exists == false)
{
throw new ArgumentException("Input path is invalid");
}
//TODO: check read permission on folders and files
var compareResult = new CompareResult();
var firstFeatureFolderList = firstDir.EnumerateDirectories().ToList();
var secondFeatureFolderList = secondDir.EnumerateDirectories().ToList();
var firstFeatureFolderNameList = firstFeatureFolderList.Select(x => x.Name).ToList();
var secondFeatureFolderNameList = secondFeatureFolderList.Select(x => x.Name).ToList();
var notExistInSecondDir = firstFeatureFolderNameList.Except(secondFeatureFolderNameList);
var notExistInFirstDir = secondFeatureFolderNameList.Except(firstFeatureFolderNameList);
BuildFeatureCompareResultExistInOneFolderOnly(notExistInSecondDir, firstFeatureFolderList, compareResult, true);
BuildFeatureCompareResultExistInOneFolderOnly(notExistInFirstDir, secondFeatureFolderList, compareResult, false);
var existInBothDir = firstFeatureFolderNameList.Intersect(secondFeatureFolderNameList);
foreach (var dirName in existInBothDir)
{
var featureCompareResult = CompareFeatureFolders(dirName, firstFeatureFolderList,
secondFeatureFolderList);
compareResult.ListFeatureFolderCompareResult.Add(featureCompareResult);
}
//remove feature that don't have different files
compareResult.ListFeatureFolderCompareResult =
compareResult.ListFeatureFolderCompareResult.Where(x => x.ListDataFileCompareResult.Any()).ToList();
return compareResult;
}
public CompareResult Compare(Table otherTable)
{
// guard clause: Different table names are not comparables
if (!Name.EqualsIgnoreCase(otherTable.Name))
throw new InvalidOperationException("Tables are not comparables. In order to compare two tables they must have the same name.");
CompareResult result = new CompareResult();
foreach (Column eachColumn in _columnList)
{
Column otherColumn = otherTable.FindColumnByName(eachColumn.Name);
if (otherColumn == null)
result.AddMissing(eachColumn);
else
if (!eachColumn.Equals(otherColumn))
{
var conflict = new TableConflict(new Pair<Column>(eachColumn, otherColumn));
result.AddConflict(conflict);
}
}
return result;
}
protected ANALYSIS_RESULT_TYPE Apply(Rule rule, CompareResult compareResult)
{
var fields = _Fields[compareResult.ResultType];
var properties = _Properties[compareResult.ResultType];
foreach (Clause clause in rule.clauses)
{
FieldInfo field = fields.FirstOrDefault(iField => iField.Name.Equals(clause.field));
PropertyInfo property = properties.FirstOrDefault(iProp => iProp.Name.Equals(clause.field));
if (field == null && property == null)
{
//Custom field logic will go here
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
try
{
var complete = false;
var valsToCheck = new List <string>();
if (compareResult.ChangeType == CHANGE_TYPE.CREATED || compareResult.ChangeType == CHANGE_TYPE.MODIFIED)
{
try
{
valsToCheck.Add(GetValueByFieldName(compareResult.Compare, field.Name).ToString());
}
catch (NullReferenceException)
{
}
try
{
valsToCheck.Add(GetValueByPropertyName(compareResult.Compare, property.Name).ToString());
}
catch (NullReferenceException)
{
}
}
if (compareResult.ChangeType == CHANGE_TYPE.DELETED || compareResult.ChangeType == CHANGE_TYPE.MODIFIED)
{
try
{
valsToCheck.Add(GetValueByFieldName(compareResult.Base, field.Name).ToString());
}
catch (NullReferenceException)
{
}
try
{
valsToCheck.Add(GetValueByPropertyName(compareResult.Base, property.Name).ToString());
}
catch (NullReferenceException)
{
}
}
switch (clause.op)
{
case OPERATION.EQ:
foreach (string datum in clause.data)
{
foreach (string val in valsToCheck)
{
complete |= datum.Equals(val);
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.NEQ:
foreach (string datum in clause.data)
{
foreach (string val in valsToCheck)
{
complete |= !datum.Equals(val);
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.CONTAINS:
foreach (string datum in clause.data)
{
foreach (string val in valsToCheck)
{
complete |= val.Contains(datum);
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.GT:
foreach (string val in valsToCheck)
{
complete |= Int32.Parse(val.ToString()) > Int32.Parse(clause.data[0]);
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.LT:
foreach (string val in valsToCheck)
{
complete |= Int32.Parse(val.ToString()) < Int32.Parse(clause.data[0]);
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.REGEX:
foreach (string val in valsToCheck)
{
foreach (string datum in clause.data)
{
var r = new Regex(datum);
if (r.IsMatch(val))
{
complete = true;
}
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.WAS_MODIFIED:
if ((valsToCheck.Count == 2) && (valsToCheck[0] == valsToCheck[1]))
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.ENDS_WITH:
foreach (string datum in clause.data)
{
foreach (var val in valsToCheck)
{
if (val.EndsWith(datum, StringComparison.CurrentCulture))
{
complete = true;
break;
}
}
if (complete)
{
break;
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.STARTS_WITH:
foreach (string datum in clause.data)
{
foreach (var val in valsToCheck)
{
if (val.StartsWith(datum, StringComparison.CurrentCulture))
{
complete = true;
break;
}
}
if (complete)
{
break;
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
default:
Log.Debug("Unimplemented operation {0}", clause.op);
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
catch (Exception e)
{
Logger.DebugException(e);
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
compareResult.Rules.Add(rule);
return(rule.flag);
}
internal void DoAutocomplete(bool forced)
{
if (!Menu.Enabled)
{
Menu.Close();
return;
}
visibleItems.Clear();
selectedItemIndex = 0;
VerticalScroll.Value = 0;
//get fragment around caret
Range fragment = tb.Selection.GetFragment(Menu.SearchPattern);
string text = fragment.Text;
//calc screen point for popup menu
Point point = tb.PlaceToPoint(fragment.End);
point.Offset(2, tb.CharHeight);
if (forced || (text.Length >= Menu.MinFragmentLength && tb.Selection.IsEmpty))
{
Menu.Fragment = fragment;
bool foundSelected = false;
//build popup menu
foreach (var item in sourceItems)
{
item.Parent = Menu;
CompareResult res = item.Compare(text);
if (res == CompareResult.ExactAndReplace)
{
tb.TextSource.Manager.BeginAutoUndoCommands();
try {
DoAutocomplete(item, fragment);
return;
} finally {
tb.TextSource.Manager.EndAutoUndoCommands();
}
}
else if (res != CompareResult.Hidden)
{
visibleItems.Add(item);
}
if (res == CompareResult.VisibleAndSelected && !foundSelected)
{
foundSelected = true;
selectedItemIndex = visibleItems.Count - 1;
}
}
if (foundSelected)
{
AdjustScroll();
DoSelectedVisible();
}
}
//show popup menu
if (Count > 0)
{
if (!Menu.Visible)
{
CancelEventArgs args = new CancelEventArgs();
Menu.OnOpening(args);
if (!args.Cancel)
{
Menu.Show(tb, point);
}
}
else
{
Invalidate();
}
}
else
{
Menu.Close();
}
}
static Task <CompareResult> CompareWithMessage(string stream, string received, IReadOnlyDictionary <string, object> readOnlyDictionary)
{
return(Task.FromResult(CompareResult.NotEqual("theMessage")));
}
private TableCell CreateCell(Key key, Column column, Dictionary <Key, Dictionary <string, object> > aList, Dictionary <Key, Dictionary <string, object> > bList, CompareResult compareResult)
{
var td = new TableCell {
CssClass = "_" + column.Name + " " + compareResult
};
switch (compareResult)
{
case CompareResult.NotFoundInA:
td.Controls.AddLiteral(GetValueString(bList[key][column.Name], column.DataType));
break;
case CompareResult.NotFoundInB:
td.Controls.AddLiteral(GetValueString(aList[key][column.Name], column.DataType));
break;
case CompareResult.NotEqual:
var aValue = aList[key][column.Name];
var bValue = bList[key][column.Name];
if (!TableComparer.ObjectsEqual(aValue, bValue))
{
var p1 = new HtmlGenericControl("p");
p1.Attributes["class"] = "OldValue";
p1.Controls.AddLiteral(GetValueString(bValue, column.DataType));
td.Controls.Add(p1);
var p2 = new HtmlGenericControl("p");
p2.Attributes["class"] = "NewValue";
p2.Controls.AddLiteral(GetValueString(aValue, column.DataType));
td.Controls.Add(p2);
}
else
{
td.Controls.AddLiteral(GetValueString(aValue, column.DataType));
}
break;
default:
break;
}
return(td);
}
static Task <CompareResult> CompareWithMessage(VerifySettings settings, Stream received, Stream verified)
{
return(Task.FromResult(CompareResult.NotEqual("theMessage")));
}
public void TearDown()
{
this.testObject = null;
}
/// <summary> /// /// </summary> /// <param name="backForeColor"></param> public abstract void Render(IBackForeColor backForeColor, CompareResult compareResult, ColorConfig colorConfig);
protected ANALYSIS_RESULT_TYPE Apply(Rule rule, CompareResult compareResult)
{
if (compareResult != null && rule != null)
{
var properties = _Properties[compareResult.ResultType];
foreach (Clause clause in rule.Clauses)
{
PropertyInfo property = properties.FirstOrDefault(iProp => iProp.Name.Equals(clause.Field));
if (property == null)
{
//Custom field logic will go here
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
try
{
var valsToCheck = new List <string>();
List <KeyValuePair <string, string> > dictToCheck = new List <KeyValuePair <string, string> >();
if (property != null)
{
if (compareResult.ChangeType == CHANGE_TYPE.CREATED || compareResult.ChangeType == CHANGE_TYPE.MODIFIED)
{
try
{
if (GetValueByPropertyName(compareResult.Compare, property.Name) is List <string> )
{
foreach (var value in (List <string>)GetValueByPropertyName(compareResult.Compare, property.Name))
{
valsToCheck.Add(value);
}
}
else if (GetValueByPropertyName(compareResult.Compare, property.Name) is Dictionary <string, string> )
{
dictToCheck = ((Dictionary <string, string>)GetValueByPropertyName(compareResult.Compare, property.Name)).ToList();
}
else if (GetValueByPropertyName(compareResult.Compare, property.Name) is List <KeyValuePair <string, string> > )
{
dictToCheck = (List <KeyValuePair <string, string> >)GetValueByPropertyName(compareResult.Compare, property.Name);
}
else
{
valsToCheck.Add(GetValueByPropertyName(compareResult.Compare, property.Name).ToString());
}
}
catch (Exception e)
{
Log.Debug(e, "Error fetching Property {0} of Type {1}", property.Name, compareResult.ResultType);
Dictionary <string, string> ExceptionEvent = new Dictionary <string, string>();
ExceptionEvent.Add("Exception Type", e.GetType().ToString());
AsaTelemetry.TrackEvent("ApplyCreatedModifiedException", ExceptionEvent);
}
}
if (compareResult.ChangeType == CHANGE_TYPE.DELETED || compareResult.ChangeType == CHANGE_TYPE.MODIFIED)
{
try
{
if (GetValueByPropertyName(compareResult.Base, property.Name) is List <string> )
{
foreach (var value in (List <string>)GetValueByPropertyName(compareResult.Base, property.Name))
{
valsToCheck.Add(value);
}
}
else if (GetValueByPropertyName(compareResult.Base, property.Name) is Dictionary <string, string> )
{
dictToCheck = ((Dictionary <string, string>)GetValueByPropertyName(compareResult.Base, property.Name)).ToList();
}
else if (GetValueByPropertyName(compareResult.Base, property.Name) is List <KeyValuePair <string, string> > )
{
dictToCheck = (List <KeyValuePair <string, string> >)GetValueByPropertyName(compareResult.Base, property.Name);
}
else
{
valsToCheck.Add(GetValueByPropertyName(compareResult.Base, property.Name).ToString());
}
}
catch (Exception e)
{
Dictionary <string, string> ExceptionEvent = new Dictionary <string, string>();
ExceptionEvent.Add("Exception Type", e.GetType().ToString());
AsaTelemetry.TrackEvent("ApplyDeletedModifiedException", ExceptionEvent);
}
}
}
int count = 0, dictCount = 0;
switch (clause.Operation)
{
case OPERATION.EQ:
foreach (string datum in clause.Data)
{
foreach (string val in valsToCheck)
{
count += (datum.Equals(val)) ? 1 : 0;
break;
}
}
if (count == clause.Data.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.NEQ:
foreach (string datum in clause.Data)
{
foreach (string val in valsToCheck)
{
if (datum.Equals(val))
{
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
}
break;
case OPERATION.CONTAINS:
if (dictToCheck.Count > 0)
{
foreach (KeyValuePair <string, string> value in clause.DictData)
{
if (dictToCheck.Where((x) => x.Key == value.Key && x.Value == value.Value).Any())
{
dictCount++;
}
}
if (dictCount == clause.DictData.Count)
{
break;
}
}
else if (valsToCheck.Count > 0)
{
foreach (string datum in clause.Data)
{
foreach (string val in valsToCheck)
{
count += (!val.Contains(datum)) ? 1 : 0;
break;
}
}
if (count == clause.Data.Count)
{
break;
}
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.DOES_NOT_CONTAIN:
if (dictToCheck.Count > 0)
{
foreach (KeyValuePair <string, string> value in clause.DictData)
{
if (dictToCheck.Where((x) => x.Key == value.Key && x.Value == value.Value).Any())
{
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
}
else if (valsToCheck.Count > 0)
{
foreach (string datum in clause.Data)
{
if (valsToCheck.Contains(datum))
{
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
}
break;
case OPERATION.GT:
foreach (string val in valsToCheck)
{
count += (int.Parse(val, CultureInfo.InvariantCulture) > int.Parse(clause.Data[0], CultureInfo.InvariantCulture)) ? 1 : 0;
}
if (count == valsToCheck.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.LT:
foreach (string val in valsToCheck)
{
count += (int.Parse(val, CultureInfo.InvariantCulture) < int.Parse(clause.Data[0], CultureInfo.InvariantCulture)) ? 1 : 0;
}
if (count == valsToCheck.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.REGEX:
foreach (string val in valsToCheck)
{
foreach (string datum in clause.Data)
{
var r = new Regex(datum);
if (r.IsMatch(val))
{
count++;
}
}
}
if (count == valsToCheck.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.WAS_MODIFIED:
if ((valsToCheck.Count == 2) && (valsToCheck[0] == valsToCheck[1]))
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.ENDS_WITH:
foreach (string datum in clause.Data)
{
foreach (var val in valsToCheck)
{
if (val.EndsWith(datum, StringComparison.CurrentCulture))
{
count++;
break;
}
}
}
if (count == clause.Data.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.STARTS_WITH:
foreach (string datum in clause.Data)
{
foreach (var val in valsToCheck)
{
if (val.StartsWith(datum, StringComparison.CurrentCulture))
{
count++;
break;
}
}
}
if (count == clause.Data.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
default:
Log.Debug("Unimplemented operation {0}", clause.Operation);
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
catch (Exception e)
{
Log.Debug(e, $"Hit while parsing {JsonConvert.SerializeObject(rule)} onto {JsonConvert.SerializeObject(compareResult)}");
Dictionary <string, string> ExceptionEvent = new Dictionary <string, string>();
ExceptionEvent.Add("Exception Type", e.GetType().ToString());
AsaTelemetry.TrackEvent("ApplyOverallException", ExceptionEvent);
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
compareResult.Rules.Add(rule);
return(rule.Flag);
}
else
{
throw new NullReferenceException();
}
}
public abstract void InsertAnalyzed(CompareResult objIn);
public void Execute(IEnumerable<DatabaseTable> baseTables, IEnumerable<DatabaseTable> compareTables)
{
//find new tables (in compare, but not in base)
var newTables = new List<DatabaseTable>();
foreach (var databaseTable in compareTables)
{
var name = databaseTable.Name;
var schema = databaseTable.SchemaOwner;
var match = baseTables.FirstOrDefault(t => t.Name == name && t.SchemaOwner == schema);
if (match != null) continue;
var script = "-- NEW TABLE " + databaseTable.Name + Environment.NewLine +
_writer.AddTable(databaseTable);
CreateResult(ResultType.Add, databaseTable, script);
newTables.Add(databaseTable);
}
//find dropped and existing tables
foreach (var databaseTable in baseTables)
{
var name = databaseTable.Name;
var schema = databaseTable.SchemaOwner;
var match = compareTables.FirstOrDefault(t => t.Name == name && t.SchemaOwner == schema);
if (match == null)
{
CreateResult(ResultType.Delete, databaseTable, _writer.DropTable(databaseTable));
continue;
}
//table may or may not have been changed
//add, alter and delete columns
var compareColumns = new CompareColumns(_results, _writer);
compareColumns.Execute(databaseTable, match);
//add, alter and delete constraints
var compareConstraints = new CompareConstraints(_results, _writer);
compareConstraints.Execute(databaseTable, match);
//indexes
var compareIndexes = new CompareIndexes(_results, _writer);
compareIndexes.Execute(databaseTable, match);
//triggers
var compareTriggers = new CompareTriggers(_results, _writer);
compareTriggers.Execute(databaseTable, match);
}
//add tables doesn't add foreign key constraints (wait until all tables created)
foreach (var databaseTable in newTables)
{
foreach (var foreignKey in databaseTable.ForeignKeys)
{
var result = new CompareResult
{
SchemaObjectType = SchemaObjectType.Constraint,
ResultType = ResultType.Add,
SchemaOwner = databaseTable.SchemaOwner,
TableName = databaseTable.Name,
Name = foreignKey.Name,
Script = _writer.AddConstraint(databaseTable, foreignKey)
};
_results.Add(result);
}
foreach (var trigger in databaseTable.Triggers)
{
var result = new CompareResult
{
SchemaObjectType = SchemaObjectType.Trigger,
ResultType = ResultType.Add,
Name = trigger.Name,
SchemaOwner = databaseTable.SchemaOwner,
TableName = databaseTable.Name,
Script = _writer.AddTrigger(databaseTable, trigger)
};
_results.Add(result);
}
}
}
public CompareResult Compare(Submission a, Submission b)
{
CompareResult result = new CompareResult(a, b);
var matches = new List<Match>();
// reduce access to properties
var a_length = a.Tokens.Length;
var b_length = b.Tokens.Length;
var a_tokens = a.Tokens;
var b_tokens = b.Tokens;
for (int idx_a = 0; idx_a < a_length; idx_a++)
{
int idx_working_a = idx_a;
int inMatch = 0;
Match currentMatch = null;
for (int idx_working_b = 0; idx_working_b < b_length; idx_working_b++)
{
var working_a = a_tokens[idx_working_a];
var working_b = b_tokens[idx_working_b];
// reduce access to properties
var a_text = working_a.Text;
var b_text = working_b.Text;
if (a_text == b_text)
{
currentMatch = ProcessMatch(working_a, working_b, currentMatch, result);
idx_working_a++;
if (idx_working_a >= a_length) break;
inMatch = 1;
}
else if (inMatch > 0 && a_text != b_text)
{
if (inMatch >= _cfg.MAX_MATCH_DISTANCE)
{
FinishMatch(currentMatch, matches);
currentMatch = null;
inMatch = 0;
}
else
{
currentMatch = ProcessMatch(working_a, working_b, currentMatch, result);
idx_working_a++;
if (idx_working_a >= a_length) break;
inMatch++;
}
}
} // foreach(b)
FinishMatch(currentMatch, matches);
} // foreach(a)
// Find longest match
foreach (var match in matches.OrderByDescending(i => i.TokensA.Count))
{
if (!result.Matches.Any(m => m.TokensA.Any(t => match.TokensA.Contains(t))
|| m.TokensB.Any(t => match.TokensB.Contains(t))))
{
match.Index = result.Matches.Count;
result.Matches.Add(match);
}
}
result.Update();
return result;
}
public Match(CompareResult parent)
{
this.Result = parent;
this.TokensA = new LinkedList<Token>();
this.TokensB = new LinkedList<Token>();
}
private Match ProcessMatch(Token working_a, Token working_b, Match currentMatch, CompareResult result)
{
if (currentMatch == null)
{
currentMatch = new Match(result);
}
currentMatch.TokensA.AddLast(working_a);
currentMatch.TokensB.AddLast(working_b);
return currentMatch;
}
protected ANALYSIS_RESULT_TYPE Apply(Rule rule, CompareResult compareResult)
{
var fields = _Fields[compareResult.ResultType];
foreach (Clause clause in rule.clauses)
{
FieldInfo field = fields.FirstOrDefault(iField => iField.Name.Equals(clause.field));
if (field == null)
{
//Custom field logic will go here
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
var compareVal = default(object);
var baseVal = default(object);
try
{
if (compareResult.Compare != null)
{
compareVal = GetValueByPropertyName(compareResult.Compare, field.Name);
}
if (compareResult.Base != null)
{
baseVal = GetValueByPropertyName(compareResult.Base, field.Name);
}
var complete = false;
var valsToCheck = new List <string>();
if (compareResult.ChangeType == CHANGE_TYPE.CREATED || compareResult.ChangeType == CHANGE_TYPE.MODIFIED)
{
valsToCheck.Add(compareVal.ToString());
}
if (compareResult.ChangeType == CHANGE_TYPE.DELETED || compareResult.ChangeType == CHANGE_TYPE.MODIFIED)
{
valsToCheck.Add(baseVal.ToString());
}
switch (clause.op)
{
case OPERATION.EQ:
foreach (string datum in clause.data)
{
foreach (string val in valsToCheck)
{
if (datum.Equals(val))
{
complete = true;
}
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.NEQ:
foreach (string datum in clause.data)
{
foreach (string val in valsToCheck)
{
if (!datum.Equals(val))
{
complete = true;
}
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.CONTAINS:
foreach (string datum in clause.data)
{
foreach (string val in valsToCheck)
{
if (val.Contains(datum))
{
complete = true;
}
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.GT:
foreach (string val in valsToCheck)
{
if (Int32.Parse(val.ToString()) > Int32.Parse(clause.data[0]))
{
complete = true;
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.LT:
foreach (string val in valsToCheck)
{
if (Int32.Parse(val.ToString()) < Int32.Parse(clause.data[0]))
{
complete = true;
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.REGEX:
foreach (string val in valsToCheck)
{
foreach (string datum in clause.data)
{
var r = new Regex(datum);
if (r.IsMatch(val.ToString()))
{
complete = true;
}
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.WAS_MODIFIED:
foreach (string val in valsToCheck)
{
if (!val.ToString().Equals(baseVal.ToString()))
{
complete = true;
}
}
if (complete)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
default:
Log.Debug("Unimplemented operation {0}", clause.op);
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
catch (Exception e)
{
Log.Debug("{0} {1} {2}", e.GetType().ToString(), e.Message, e.StackTrace);
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
compareResult.Rules.Add(rule);
return(rule.flag);
}
public void VerifyIsAfterOperator()
{
var falseIsAfterObject = new CompareResult()
{
Base = new FileSystemObject("App.exe")
{
SignatureStatus = new Signature(true)
{
SigningCertificate = new SerializableCertificate(Thumbprint: string.Empty, Subject: string.Empty, PublicKey: string.Empty, NotAfter: DateTime.Now, NotBefore: DateTime.Now, Issuer: string.Empty, SerialNumber: string.Empty, CertHashString: string.Empty, Pkcs7: string.Empty)
}
}
};
var trueIsAfterObject = new CompareResult()
{
Base = new FileSystemObject("App.exe")
{
SignatureStatus = new Signature(true)
{
SigningCertificate = new SerializableCertificate(Thumbprint: string.Empty, Subject: string.Empty, PublicKey: string.Empty, NotAfter: DateTime.Now.AddYears(1), NotBefore: DateTime.Now, Issuer: string.Empty, SerialNumber: string.Empty, CertHashString: string.Empty, Pkcs7: string.Empty)
}
}
};
var isAfterRule = new Rule("Is After Rule")
{
ResultType = RESULT_TYPE.FILE,
Flag = ANALYSIS_RESULT_TYPE.FATAL,
Clauses = new List <Clause>()
{
new Clause("SignatureStatus.SigningCertificate.NotAfter", OPERATION.IS_AFTER)
{
Data = new List <string>()
{
DateTime.Now.AddDays(1).ToString()
}
}
}
};
var isAfterAnalyzer = GetAnalyzerForRule(isAfterRule);
Assert.IsTrue(isAfterAnalyzer.Analyze(trueIsAfterObject).Any());
Assert.IsFalse(isAfterAnalyzer.Analyze(falseIsAfterObject).Any());
var isAfterRuleShortDate = new Rule("Is After Short Rule")
{
ResultType = RESULT_TYPE.FILE,
Flag = ANALYSIS_RESULT_TYPE.FATAL,
Clauses = new List <Clause>()
{
new Clause("SignatureStatus.SigningCertificate.NotAfter", OPERATION.IS_AFTER)
{
Data = new List <string>()
{
DateTime.Now.AddDays(1).ToShortDateString()
}
}
}
};
var isAfterShortAnalyzer = GetAnalyzerForRule(isAfterRuleShortDate);
Assert.IsTrue(isAfterShortAnalyzer.Analyze(trueIsAfterObject).Any());
Assert.IsFalse(isAfterShortAnalyzer.Analyze(falseIsAfterObject).Any());
}
protected virtual async Task <IList <WorkItem> > GetWorkItemsInReleaseAsync(GitHubClient client, long repositoryId, ReleaseTag releaseTag)
{
IList <WorkItem> workItems = new List <WorkItem>();
CompareResult commits = null;
var advantageReleaseTags = await GetReleaseTagsAsync(repositoryId);
var orderedReleaseTags = advantageReleaseTags.
OrderByDescending(r => r.Release).
ToList();
var selectedReleaseIndex = orderedReleaseTags.FindIndex(r => r.Release == releaseTag.Release);
string baseSha = String.Empty;
string headSha = String.Empty;
Version releaseVersion = null;
if (selectedReleaseIndex == -1)
{
// Not found
return(workItems);
}
else if (selectedReleaseIndex == orderedReleaseTags.Count)
{
// Latest release
//baseSha = orderedReleaseTags[selectedReleaseIndex-1].CommitSha;
//headSha = orderedReleaseTags[selectedReleaseIndex].CommitSha;
//releaseVersion = orderedReleaseTags[selectedReleaseIndex - 1].Release;
}
else
{
baseSha = orderedReleaseTags[selectedReleaseIndex].CommitSha;
headSha = orderedReleaseTags[selectedReleaseIndex - 1].CommitSha;
releaseVersion = orderedReleaseTags[selectedReleaseIndex].Release;
}
commits = await client.Repository.Commit.Compare
(
repositoryId,
baseSha,
headSha
);
foreach (GitHubCommit commit in commits.Commits)
{
workItems.Add(GetWorkItemFromGitHubCommit(commit, releaseVersion));
}
//for (int i = 1; i < selectedReleaseTags.Count() - 1; i++)
//{
// var selectedBase = selectedReleaseTags[i + 1];
// var selectedHead = selectedReleaseTags[i];
// commits = await client.Repository.Commit.Compare
// (
// repositoryId,
// selectedBase.CommitSha,
// selectedHead.CommitSha
// );
// foreach (GitHubCommit commit in commits.Commits)
// {
// workItems.Add(GetWorkItemFromGitHubCommit(commit, selectedHead.Release));
// }
//}
return(workItems);
}
private string GetMatchStatus(CompareResult item)
{
if (item.ExistsLeft && !item.ExistsRight)
return "Exists on the left";
if (!item.ExistsLeft && item.ExistsRight)
return "Exists on the right";
if (item.Match)
return "Matches";
return "Does not match";
}
public void GenerateCompareReport(CompareResult result, string outputDirectory)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
if (string.IsNullOrWhiteSpace(outputDirectory))
{
throw new ArgumentException("Value cannot be null or whitespace.", nameof(outputDirectory));
}
Log.Verbose("Generating compare report");
var document = new MarkdownDocument();
// Title
document.WriteHeader1($"PostMortem Compare Report for {result.GeneralInfos.OlderDump.DumpFileName.MakeInlineCode()} and {result.GeneralInfos.NewerDump.DumpFileName.MakeInlineCode()}");
document.WriteParagraph($"Report generated: {DateTime.Now:F}");
// General Info
document.WriteHeader2("General Information");
document.WriteParagraph($"Older Dump File Creation Time: {result.GeneralInfos.OlderDump.DumpFileCreationTime:F}");
document.WriteParagraph($"Older Dump File Path: {result.GeneralInfos.OlderDump.DumpFilePath.MakeInlineCode()}");
document.WriteParagraph($"Newer Dump File Creation Time: {result.GeneralInfos.NewerDump.DumpFileCreationTime:F}");
document.WriteParagraph($"Newer Dump File Path: {result.GeneralInfos.NewerDump.DumpFilePath.MakeInlineCode()}");
// Matching threads
document.WriteHeader2("Matching Threads");
foreach (var matchingThread in result.MatchingThreads)
{
if (!matchingThread.MatchingFrames?.Any() ?? true)
{
continue;
}
var prefix = matchingThread.IsFullTraceMatch ? $"{MarkdownEmojis.Snowflake} " : null;
document.WriteHeader3($"{prefix} Thread {matchingThread.ThreadFromOlder.OsThreadId.ToString("x12").MakeInlineCode()}");
if (matchingThread.IsFullTraceMatch)
{
document.WriteParagraph("Both stack traces seem to be equal".MakeMarked());
}
document.WriteHeader4("Matching stack frames");
WriteStackTraceTable(document, matchingThread.MatchingFrames);
}
// Object Differences
document.WriteHeader2("Object Count Differences");
document.WriteTable(
result.ObjectDiffs.OrderByDescending(info => info.Difference).Take(1000),
new []
{
"Type",
"Implements IDisposable",
"Change"
},
info => info.ObjectInfo.TypeName.MakeInlineCode(),
info => $"{info.ObjectInfo.ImplementsIDisposable}{(info.ObjectInfo.ImplementsIDisposable ?? false ? $" {MarkdownEmojis.Warning}" : string.Empty)}",
info =>
{
var suffix = info.Difference > 0
? $" {MarkdownEmojis.ArrowUpSmall}"
: null;
return($"{info.Difference?.ToString("+0;-#;0")}{suffix}");
});
Export(outputDirectory, document, "compare-report");
}
private bool IsNotPresent(CompareResult result)
{
return !(result.ExistsLeft && result.ExistsRight);
}
// methods
#region public bool Add(Get<K> point, T value)
public bool Add(GetIndex <K> point, T value)
{
var nodeToAdd = new Node(value);
if (_root is null)
{
_root = new Node(value);
}
else
{
int dimension = -1;
Node parent = _root;
bool added = false;
while (added == false)
{
// Increment the dimension we're searching in
dimension = (dimension + 1) % _dimensions;
// Does the node we're adding have the same hyperpoint as this node?
if (AreEqual(point, this._locate(parent.Value)))
{
return(false);
}
// Which side does this node sit under in relation to it's parent at this level?
CompareResult compare = this._compareKey(point(dimension), this._locate(parent.Value)(dimension));
switch (compare)
{
case ((Less | Equal)):
if (parent.LeftChild is null)
{
parent.LeftChild = nodeToAdd;
added = true;
}
else
{
parent = parent.LeftChild;
}
break;
case (Greater):
if (parent.RightChild is null)
{
parent.RightChild = nodeToAdd;
added = true;
}
else
{
parent = parent.RightChild;
}
break;
default:
throw new System.NotImplementedException();
}
}
}
this._count++;
return(true);
}
private void FindDups(string DirFirst, string DirSecond)
{
List <string> filesListFirst;
List <string> filesListSecond;
TraverseTree(DirFirst, out filesListFirst);
TraverseTree(DirSecond, out filesListSecond);
List <string> OrigList = new List <string>();
List <string> DupList = new List <string>();
MethodInvoker m;
m = new MethodInvoker(() =>
{
progressBar1.Maximum = filesListFirst.Count();
progressBar1.Value = 1;
}
);
this.Invoke(m);
foreach (string file1 in filesListFirst)
{
if (wannaClose)
{
return;
}
//this.Text = file1;
m = new MethodInvoker(() => this.Text = file1);
this.Invoke(m);
//if app is not active ActiveForm will be null
/*
* if (Form1.ActiveForm != null)
* {
* // //Form1.ActiveForm.Text = file1; // + ":" + fileName2;
* this.Text = file1;
* }
*/
/////////////////
/*
* string pathOnly = Path.GetDirectoryName(file1);
* if (pathOnly.EndsWith("_vti_cnf"))
* {
*
* DirectoryInfo di = new DirectoryInfo(pathOnly);
* if (di.Exists)
* {
* if (!OrigList.Contains(pathOnly))
* {
* //di.Delete(true);
* OrigList.Add(pathOnly);
* }
* }
*
* }
*/
//////////////
m = new MethodInvoker(() => progressBar1.Increment(1));
this.Invoke(m);
foreach (string file2 in filesListSecond)
{
//skip id Path1 and Path2 are the same
//bool cond1 = ((Path.GetDirectoryName(file1) != Path.GetDirectoryName(file2)) && (file1 == file2));
//bool cond2 = ((Path.GetDirectoryName(file1) == Path.GetDirectoryName(file2)) && (file1 != file2));
string pathOnlyFile1 = Path.GetDirectoryName(file1);
string pathOnlyFile2 = Path.GetDirectoryName(file2);
if ((!file1.Equals(file2, StringComparison.CurrentCultureIgnoreCase)) && (!Bypass(pathOnlyFile1, pathOnlyFile2))) //file1 and 2 include the path. So avoid checking file in same folder aginst itself
//if ( (file1 != file2) && (!Bypass(pathOnlyFile1, pathOnlyFile2)) ) //file1 and 2 include the path. So avoid checking file in same folder aginst itself
{
// public enum CompareResult { different, sameSize, sameHash, sameByteForByte };
CompareResult compareResult = CompareFiles(file1, file2);
if (compareResult > CompareResult.different)
{
bool alreadyLoggedBackwards = (OrigList.Contains(file2)) && (DupList.Contains(file1));
if (!alreadyLoggedBackwards) //to avoid adding same pair in reverse.
{
OrigList.Add(file1 + " (" + compareResult.ToString() + ")");
DupList.Add(file2);
}
}
//if (compareResult == CompareResult.sameByteForByte)
//{
// bool alreadyLoggedBackwards = (OrigList.Contains(file2)) && (DupList.Contains(file1));
// if (!alreadyLoggedBackwards) //to avoid adding same pair in reverse.
// {
// OrigList.Add(file1);
// DupList.Add(file2);
// }
//}
//else
//{
// if ( (compareResult >= CompareResult.sameSize) && (compareResult <= CompareResult.sameHash) )
// {
// bool alreadyLoggedBackwards = (OrigList.Contains(file2)) && (DupList.Contains(file1));
// if (!alreadyLoggedBackwards) //to avoid adding same pair in reverse.
// {
// OrigList.Add(file1 + "***SameSizeOnly***");
// DupList.Add(file2 + "***SameSizeOnly***");
// }
// }
//}
}
}
//Thread.Sleep(10);
//if ((DateTime.Now.Second % 5) == 0)
//Application.DoEvents();
}
m = new MethodInvoker(() => tbOriginal.Lines = OrigList.ToArray());
this.Invoke(m);
m = new MethodInvoker(() => tbDuplicate.Lines = DupList.ToArray());
this.Invoke(m);
tbOriginal.Lines = OrigList.ToArray();
tbDuplicate.Lines = DupList.ToArray();
}
public void RemoveAt(GetIndex <K> point)
{
// Is tree empty?
if (_root is null)
{
return;
}
Node node;
if (AreEqual(point, this._locate(this._root.Value)))
{
node = _root;
_root = null;
this._count--;
ReaddChildNodes(node);
return;
}
node = _root;
int dimension = -1;
do
{
dimension = (dimension + 1) % _dimensions;
CompareResult compare = this._compareKey(point(dimension), this._locate(node.Value)(dimension));
switch (compare)
{
case (Less | Equal):
if (node.LeftChild is null)
{
return;
}
else
if (AreEqual(point, this._locate(node.LeftChild.Value)))
{
var nodeToRemove = node.LeftChild;
node.LeftChild = null;
this._count--;
ReaddChildNodes(nodeToRemove);
}
else
{
node = node.LeftChild;
}
break;
case Greater:
if (node.RightChild is null)
{
return;
}
if (AreEqual(point, this._locate(node.RightChild.Value)))
{
var nodeToRemove = node.RightChild;
node.RightChild = null;
this._count--;
ReaddChildNodes(nodeToRemove);
}
else
{
node = node.RightChild;
}
break;
default:
throw new System.NotImplementedException();
}
}while (node is not null);
}
internal void DoAutocomplete(bool forced)
{
if (!Menu.Enabled)
{
Menu.Close();
return;
}
visibleItems.Clear();
FocussedItemIndex = 0;
VerticalScroll.Value = 0;
//some magic for update scrolls
AutoScrollMinSize -= new Size(1, 0);
AutoScrollMinSize += new Size(1, 0);
//get fragment around caret
Range fragment = tb.Selection.GetFragment(Menu.SearchPattern);
string text = fragment.Text;
//calc screen point for popup menu
Point point = tb.PlaceToPoint(fragment.End);
point.Offset(2, tb.CharHeight);
//
if (forced || (text.Length >= Menu.MinFragmentLength &&
tb.Selection.IsEmpty && /*pops up only if selected range is empty*/
(tb.Selection.Start > fragment.Start || text.Length == 0 /*pops up only if caret is after first letter*/)))
{
Menu.Fragment = fragment;
bool foundSelected = false;
//build popup menu
foreach (var item in sourceItems)
{
item.Parent = Menu;
CompareResult res = item.Compare(text);
if (res != CompareResult.Hidden)
{
visibleItems.Add(item);
}
if (res == CompareResult.VisibleAndSelected && !foundSelected)
{
foundSelected = true;
FocussedItemIndex = visibleItems.Count - 1;
}
}
if (foundSelected)
{
AdjustScroll();
DoSelectedVisible();
}
}
//show popup menu
if (Count > 0)
{
if (!Menu.Visible)
{
CancelEventArgs args = new CancelEventArgs();
Menu.OnOpening(args);
if (!args.Cancel)
{
Menu.Show(tb, point);
}
}
DoSelectedVisible();
Invalidate();
}
else
{
Menu.Close();
}
}
internal void AddNearestNeighbours(
Node node,
GetIndex <K> target,
HyperRect <K> rect,
int depth,
NearestNeighbourList <Node, K> nearestNeighbours,
K maxSearchRadiusSquared)
{
if (node is null)
{
return;
}
// Work out the current dimension
int dimension = depth % _dimensions;
// Split our hyper-rect into 2 sub rects along the current
// node's point on the current dimension
var leftRect = rect.Clone();
leftRect.MaxPoint[dimension] = this._locate(node.Value)(dimension);
var rightRect = rect.Clone();
rightRect.MinPoint[dimension] = this._locate(node.Value)(dimension);
// Which side does the target reside in?
CompareResult compareTargetPoint = this._compareKey(target(dimension), this._locate(node.Value)(dimension));
int compareTargetPoint_as_int;
switch (compareTargetPoint)
{
case Equal:
compareTargetPoint_as_int = 0;
break;
case Less:
compareTargetPoint_as_int = -1;
break;
case Greater:
compareTargetPoint_as_int = 1;
break;
default:
throw new System.NotImplementedException();
}
var nearerRect = compareTargetPoint_as_int <= 0 ? leftRect : rightRect;
var furtherRect = compareTargetPoint_as_int <= 0 ? rightRect : leftRect;
var nearerNode = compareTargetPoint_as_int <= 0 ? node.LeftChild : node.RightChild;
var furtherNode = compareTargetPoint_as_int <= 0 ? node.RightChild : node.LeftChild;
// Let's walk down into the nearer branch
if (nearerNode is not null)
{
AddNearestNeighbours(
nearerNode,
target,
nearerRect,
depth + 1,
nearestNeighbours,
maxSearchRadiusSquared);
}
K distanceSquaredToTarget;
// Walk down into the further branch but only if our capacity hasn't been reached
// OR if there's a region in the further rect that's closer to the target than our
// current furtherest nearest neighbour
GetIndex <K> closestPointInFurtherRect = furtherRect.GetClosestPoint(target, this._dimensions);
distanceSquaredToTarget = DistanceSquaredBetweenPoints(closestPointInFurtherRect, target);
if (this._compareKey(distanceSquaredToTarget, maxSearchRadiusSquared) == (Less | Equal))
{
if (nearestNeighbours.IsCapacityReached)
{
if (this._compareKey(distanceSquaredToTarget, nearestNeighbours.GetFurtherestDistance()) is Less)
{
AddNearestNeighbours(
furtherNode,
target,
furtherRect,
depth + 1,
nearestNeighbours,
maxSearchRadiusSquared);
}
}
else
{
AddNearestNeighbours(
furtherNode,
target,
furtherRect,
depth + 1,
nearestNeighbours,
maxSearchRadiusSquared);
}
}
// Try to add the current node to our nearest neighbours list
distanceSquaredToTarget = DistanceSquaredBetweenPoints(this._locate(node.Value), target);
if (this._compareKey(distanceSquaredToTarget, maxSearchRadiusSquared) == (Less | Equal))
{
nearestNeighbours.Add(node, distanceSquaredToTarget);
}
}
public void AndGivenACustomComparerThatThrowsAnException()
{
Configuration = Configuration.UsingComparer((a, b) => CompareResult.Fail("Bar"));
}
public CompareItem()
: base()
{
compareResultTag = CompareResult.Unknown;
itemSourceTag = ItemSource.Unknown;
}
CompareResult CompareCore(XNode n1, XNode n2)
{
if (n1 == n2)
{
return(CompareResult.Same);
}
if (n1.Owner == null)
{
if (n2.Owner == null)
{
// n1 and n2 do not share the same
// top-level node, so return semi-
// random value.
return(CompareResult.Random);
}
CompareResult result = CompareCore(n1, n2.Owner);
switch (result)
{
case CompareResult.Same:
return(CompareResult.Child);
case CompareResult.Child:
case CompareResult.Descendant:
return(CompareResult.Descendant);
case CompareResult.Parent:
case CompareResult.Ancestor:
throw new Exception("INTERNAL ERROR: should not happen");
default:
return(result);
}
}
// else
if (n2.Owner == null)
{
// do reverse
CompareResult rev = CompareCore(n2, n1);
switch (rev)
{
case CompareResult.Parent:
return(CompareResult.Child);
case CompareResult.Child:
return(CompareResult.Parent);
case CompareResult.Ancestor:
return(CompareResult.Descendant);
case CompareResult.Descendant:
return(CompareResult.Ancestor);
case CompareResult.Following:
return(CompareResult.Preceding);
case CompareResult.Preceding:
return(CompareResult.Following);
case CompareResult.Same:
case CompareResult.Random:
return(rev);
}
}
// both have parents
CompareResult ret = CompareCore(n1.Owner, n2.Owner);
switch (ret)
{
case CompareResult.Same:
// n1 and n2 are sibling each other.
return(CompareSibling(n1, n2, CompareResult.Same));
case CompareResult.Child:
return(CompareSibling(n1, n2.Owner, CompareResult.Child));
case CompareResult.Parent:
return(CompareSibling(n1.Owner, n2, CompareResult.Parent));
case CompareResult.Descendant:
for (XNode i2 = n2; ; i2 = i2.Owner)
{
if (i2.Owner == n1.Owner)
{
return(CompareSibling(n1, i2, CompareResult.Descendant));
}
}
case CompareResult.Ancestor:
for (XNode i1 = n1; ; i1 = i1.Owner)
{
if (i1.Owner == n2.Owner)
{
return(CompareSibling(i1, n2, CompareResult.Ancestor));
}
}
default:
return(ret);
}
}
public void VerifyContainsOperator()
{
var trueStringObject = new CompareResult()
{
Base = new FileSystemObject("ContainsStringObject")
};
var falseStringObject = new CompareResult()
{
Base = new FileSystemObject("StringObject")
};
var superFalseStringObject = new CompareResult()
{
Base = new FileSystemObject("NothingInCommon")
};
var stringContains = new Rule("String Contains Rule")
{
ResultType = RESULT_TYPE.FILE,
Flag = ANALYSIS_RESULT_TYPE.FATAL,
Clauses = new List <Clause>()
{
new Clause("Path", OPERATION.CONTAINS)
{
Data = new List <string>()
{
"Contains",
"String",
"Object"
}
}
}
};
var stringAnalyzer = GetAnalyzerForRule(stringContains);
Assert.IsTrue(stringAnalyzer.Analyze(trueStringObject).Any());
Assert.IsFalse(stringAnalyzer.Analyze(falseStringObject).Any());
Assert.IsFalse(stringAnalyzer.Analyze(superFalseStringObject).Any());
var trueListObject = new CompareResult()
{
Base = new RegistryObject("ContainsListObject", Microsoft.Win32.RegistryView.Registry32)
{
Subkeys = new List <string>()
{
"One",
"Two",
"Three"
}
}
};
var falseListObject = new CompareResult()
{
Base = new RegistryObject("ContainsListObject", Microsoft.Win32.RegistryView.Registry32)
{
Subkeys = new List <string>()
{
"One",
"Two",
}
}
};
var superFalseListObject = new CompareResult()
{
Base = new RegistryObject("ContainsListObject", Microsoft.Win32.RegistryView.Registry32)
};
var listContains = new Rule("List Contains Rule")
{
ResultType = RESULT_TYPE.REGISTRY,
Flag = ANALYSIS_RESULT_TYPE.FATAL,
Clauses = new List <Clause>()
{
new Clause("Subkeys", OPERATION.CONTAINS)
{
Data = new List <string>()
{
"One",
"Two",
"Three"
}
}
}
};
var listAnalyzer = GetAnalyzerForRule(listContains);
Assert.IsTrue(listAnalyzer.Analyze(trueListObject).Any());
Assert.IsFalse(listAnalyzer.Analyze(falseListObject).Any());
Assert.IsFalse(listAnalyzer.Analyze(superFalseListObject).Any());
var trueStringDictObject = new CompareResult()
{
Base = new RegistryObject("ContainsStringDictObject", Microsoft.Win32.RegistryView.Registry32)
{
Values = new Dictionary <string, string>()
{
{ "One", "One" },
{ "Two", "Two" },
{ "Three", "Three" }
}
}
};
var falseStringDictObject = new CompareResult()
{
Base = new RegistryObject("ContainsStringDictObject", Microsoft.Win32.RegistryView.Registry32)
{
Values = new Dictionary <string, string>()
{
{ "One", "One" },
{ "Two", "Three" },
}
}
};
var superFalseStringDictObject = new CompareResult()
{
Base = new RegistryObject("ContainsStringDictObject", Microsoft.Win32.RegistryView.Registry32)
{
Values = new Dictionary <string, string>()
{
{ "One", "Two" },
{ "Three", "Four" },
}
}
};
var stringDictContains = new Rule("String Dict Contains Rule")
{
ResultType = RESULT_TYPE.REGISTRY,
Flag = ANALYSIS_RESULT_TYPE.FATAL,
Clauses = new List <Clause>()
{
new Clause("Values", OPERATION.CONTAINS)
{
DictData = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("One", "One"),
new KeyValuePair <string, string>("Two", "Two"),
new KeyValuePair <string, string>("Three", "Three")
}
}
}
};
var stringDictAnalyzer = GetAnalyzerForRule(stringDictContains);
Assert.IsTrue(stringDictAnalyzer.Analyze(trueStringDictObject).Any());
Assert.IsFalse(stringDictAnalyzer.Analyze(falseStringDictObject).Any());
Assert.IsFalse(stringDictAnalyzer.Analyze(superFalseStringDictObject).Any());
var trueListDictObject = new CompareResult()
{
Base = new RegistryObject("ContainsListDictObject", Microsoft.Win32.RegistryView.Registry32)
{
Permissions = new Dictionary <string, List <string> >()
{
{
"User", new List <string>()
{
"Read",
"Execute"
}
}
}
}
};
var falseListDictObject = new CompareResult()
{
Base = new RegistryObject("ContainsListDictObject", Microsoft.Win32.RegistryView.Registry32)
{
Permissions = new Dictionary <string, List <string> >()
{
{
"User", new List <string>()
{
"Read",
}
}
}
}
};
var alsoFalseListDictObject = new CompareResult()
{
Base = new RegistryObject("ContainsListDictObject", Microsoft.Win32.RegistryView.Registry32)
{
Permissions = new Dictionary <string, List <string> >()
{
{
"Contoso", new List <string>()
{
"Read",
"Execute"
}
}
}
}
};
var listDictContains = new Rule("List Dict Contains Rule")
{
ResultType = RESULT_TYPE.REGISTRY,
Flag = ANALYSIS_RESULT_TYPE.FATAL,
Clauses = new List <Clause>()
{
new Clause("Permissions", OPERATION.CONTAINS)
{
DictData = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("User", "Execute"),
new KeyValuePair <string, string>("User", "Read"),
}
}
}
};
var listDictAnalyzer = GetAnalyzerForRule(listDictContains);
Assert.IsTrue(listDictAnalyzer.Analyze(trueListDictObject).Any());
Assert.IsFalse(listDictAnalyzer.Analyze(falseListDictObject).Any());
Assert.IsFalse(listDictAnalyzer.Analyze(alsoFalseListDictObject).Any());
}
private List <CompareResult> Compare(List <string> folderA, List <string> folderB)
{
var results = new List <CompareResult>();
var sideBWorkingSet = new List <string>();
folderB.ForEach(f => sideBWorkingSet.Add(f));
// Go over all the images
foreach (var image in folderA)
{
var imageIndex = LookForImages(image, folderB);
// Duplication found
results.AddRange(imageIndex.Select(i => new CompareResult()
{
FileName = Path.GetFileName(image),
LeftFilePath = image,
LeftCreatedDate = File.GetCreationTime(image),
LeftModifiedDate = File.GetLastWriteTime(image),
Compared = true,
ExistsLeft = true,
ExistsRight = true,
RightFilePath = folderB[i],
Match = true,
RightCreatedDate = File.GetCreationTime(folderB[i]),
RightModifiedDate = File.GetLastWriteTime(folderB[i]),
}));
// Remove duplication from list B
foreach (var i in imageIndex.OrderByDescending(v => v))
{
sideBWorkingSet.RemoveAt(i);
}
// Duplication was not found
if (imageIndex.Count <= 0)
{
results.Add(new CompareResult()
{
FileName = Path.GetFileName(image),
LeftFilePath = image,
LeftCreatedDate = File.GetCreationTime(image),
LeftModifiedDate = File.GetLastWriteTime(image),
Compared = true,
ExistsLeft = true,
ExistsRight = false,
});
}
}
// Files in list B but not in list A
foreach (var image in sideBWorkingSet)
{
var imageResult = new CompareResult()
{
FileName = Path.GetFileName(image),
RightFilePath = image,
RightCreatedDate = File.GetCreationTime(image),
RightModifiedDate = File.GetLastWriteTime(image),
Compared = true,
ExistsLeft = false,
ExistsRight = true
};
results.Add(imageResult);
}
return(results);
}
private CompareResult ProcessEmptyDirectory(string currentFolder, string correspondingFolder, CompareDirection direction)
{
CompareResult result = new CompareResult();
result.FileName = string.Empty;
result.FileExtension = string.Empty;
if (direction == CompareDirection.Left)
{
result.LeftFilePath = currentFolder;
result.RightFilePath = correspondingFolder;
result.LeftCreatedDate = currentFolder != string.Empty ? Directory.GetCreationTime(currentFolder) : DateTime.MinValue;
result.LeftModifiedDate = currentFolder != string.Empty ? Directory.GetLastWriteTime(currentFolder) : DateTime.MinValue;
result.RightCreatedDate = correspondingFolder != string.Empty ? Directory.GetCreationTime(correspondingFolder) : DateTime.MinValue;
result.RightModifiedDate = correspondingFolder != string.Empty ? Directory.GetLastWriteTime(correspondingFolder) : DateTime.MinValue;
result.ExistsLeft = currentFolder != string.Empty;
result.ExistsRight = correspondingFolder != string.Empty;
}
else
{
result.RightFilePath = currentFolder;
result.LeftFilePath = correspondingFolder;
result.RightCreatedDate = currentFolder != string.Empty ? Directory.GetCreationTime(currentFolder) : DateTime.MinValue;
result.RightModifiedDate = currentFolder != string.Empty ? Directory.GetLastWriteTime(currentFolder) : DateTime.MinValue;
result.LeftCreatedDate = correspondingFolder != string.Empty ? Directory.GetCreationTime(correspondingFolder) : DateTime.MinValue;
result.LeftModifiedDate = correspondingFolder != string.Empty ? Directory.GetLastWriteTime(correspondingFolder) : DateTime.MinValue;
result.ExistsRight = currentFolder != string.Empty;
result.ExistsLeft = correspondingFolder != string.Empty;
}
result.Match = currentFolder != string.Empty && correspondingFolder != string.Empty;
result.Compared = true;
return result;
}
public CompareItem(string sourceString) : base(sourceString)
{
compareResultTag = CompareResult.Unknown;
itemSourceTag = ItemSource.Unknown;
}
public CompareOp(CompareResult compareResult)
{
_compareResult = compareResult;
}
public void VerifyEqOperator()
{
var assertTrueObject = new CompareResult()
{
Base = new FileSystemObject("TestPath")
{
IsDirectory = true,
Size = 700
}
};
var assertFalseObject = new CompareResult()
{
Base = new FileSystemObject("TestPath2")
{
IsDirectory = false,
Size = 701
}
};
var stringEquals = new Rule("String Equals Rule")
{
ResultType = RESULT_TYPE.FILE,
Flag = ANALYSIS_RESULT_TYPE.FATAL,
Clauses = new List <Clause>()
{
new Clause("Path", OPERATION.EQ)
{
Data = new List <string>()
{
"TestPath"
}
}
}
};
var boolEquals = new Rule("Bool Equals Rule")
{
ResultType = RESULT_TYPE.FILE,
Flag = ANALYSIS_RESULT_TYPE.FATAL,
Clauses = new List <Clause>()
{
new Clause("IsDirectory", OPERATION.EQ)
{
Data = new List <string>()
{
"True"
}
}
}
};
var intEquals = new Rule("Int Equals Rule")
{
ResultType = RESULT_TYPE.FILE,
Flag = ANALYSIS_RESULT_TYPE.FATAL,
Clauses = new List <Clause>()
{
new Clause("Size", OPERATION.EQ)
{
Data = new List <string>()
{
"700"
}
}
}
};
var boolAnalyzer = GetAnalyzerForRule(boolEquals);
var intAnalyzer = GetAnalyzerForRule(intEquals);
var stringAnalyzer = GetAnalyzerForRule(stringEquals);
Assert.IsTrue(boolAnalyzer.Analyze(assertTrueObject).Any(x => x.Name == "Bool Equals Rule"));
Assert.IsTrue(intAnalyzer.Analyze(assertTrueObject).Any(x => x.Name == "Int Equals Rule"));
Assert.IsTrue(stringAnalyzer.Analyze(assertTrueObject).Any(x => x.Name == "String Equals Rule"));
Assert.IsFalse(boolAnalyzer.Analyze(assertFalseObject).Any(x => x.Name == "Bool Equals Rule"));
Assert.IsFalse(intAnalyzer.Analyze(assertFalseObject).Any(x => x.Name == "Int Equals Rule"));
Assert.IsFalse(stringAnalyzer.Analyze(assertFalseObject).Any(x => x.Name == "String Equals Rule"));
}
private static void GenerateNUnitTestResults(string basePath, string platform, CompareResult compareResult, string buildId)
{
var resultsId = $"{DateTime.Now:yyyyMMdd-hhmmss}";
var resultsFilePath = Path.Combine(basePath, $"Results-{platform}-{resultsId}.xml");
var success = !compareResult.Tests.Any(t => t.ResultRun.LastOrDefault()?.HasChanged ?? false);
var successCount = compareResult.Tests.Count(t => t.ResultRun.LastOrDefault()?.HasChanged ?? false);
var doc = new XmlDocument();
var rootNode = doc.CreateElement("test-run");
doc.AppendChild(rootNode);
rootNode.SetAttribute("id", buildId);
rootNode.SetAttribute("name", resultsId);
rootNode.SetAttribute("testcasecount", compareResult.TotalTests.ToString());
rootNode.SetAttribute("result", success ? "Passed" : "Failed");
rootNode.SetAttribute("time", "0");
rootNode.SetAttribute("total", compareResult.TotalTests.ToString());
rootNode.SetAttribute("errors", (compareResult.TotalTests - compareResult.UnchangedTests).ToString());
rootNode.SetAttribute("passed", successCount.ToString());
rootNode.SetAttribute("failed", "0");
rootNode.SetAttribute("inconclusive", "0");
rootNode.SetAttribute("skipped", "0");
rootNode.SetAttribute("asserts", "0");
var now = DateTimeOffset.Now;
rootNode.SetAttribute("run-date", now.ToString("yyyy-MM-dd"));
rootNode.SetAttribute("start-time", now.ToString("HH:mm:ss"));
rootNode.SetAttribute("end-time", now.ToString("HH:mm:ss"));
var testSuiteAssemblyNode = doc.CreateElement("test-suite");
rootNode.AppendChild(testSuiteAssemblyNode);
testSuiteAssemblyNode.SetAttribute("type", "Assembly");
testSuiteAssemblyNode.SetAttribute("name", platform);
var environmentNode = doc.CreateElement("environment");
testSuiteAssemblyNode.AppendChild(environmentNode);
environmentNode.SetAttribute("machine-name", Environment.MachineName);
environmentNode.SetAttribute("platform", platform);
var testSuiteFixtureNode = doc.CreateElement("test-suite");
testSuiteAssemblyNode.AppendChild(testSuiteFixtureNode);
testSuiteFixtureNode.SetAttribute("type", "TestFixture");
testSuiteFixtureNode.SetAttribute("name", platform + "-" + resultsId);
testSuiteFixtureNode.SetAttribute("executed", "true");
testSuiteFixtureNode.SetAttribute("testcasecount", compareResult.TotalTests.ToString());
testSuiteFixtureNode.SetAttribute("result", success ? "Passed" : "Failed");
testSuiteFixtureNode.SetAttribute("time", "0");
testSuiteFixtureNode.SetAttribute("total", compareResult.TotalTests.ToString());
testSuiteFixtureNode.SetAttribute("errors", (compareResult.TotalTests - compareResult.UnchangedTests).ToString());
testSuiteFixtureNode.SetAttribute("passed", successCount.ToString());
testSuiteFixtureNode.SetAttribute("failed", "0");
testSuiteFixtureNode.SetAttribute("inconclusive", "0");
testSuiteFixtureNode.SetAttribute("skipped", "0");
testSuiteFixtureNode.SetAttribute("asserts", "0");
foreach (var run in compareResult.Tests)
{
var testCaseNode = doc.CreateElement("test-case");
testSuiteFixtureNode.AppendChild(testCaseNode);
var lastTestRun = run.ResultRun.LastOrDefault();
testCaseNode.SetAttribute("name", platform + "-" + SanitizeTestName(run.TestName));
testCaseNode.SetAttribute("fullname", platform + "-" + SanitizeTestName(run.TestName));
testCaseNode.SetAttribute("duration", "0");
testCaseNode.SetAttribute("time", "0");
var testRunSuccess = !(lastTestRun?.HasChanged ?? false);
testCaseNode.SetAttribute("result", testRunSuccess ? "Passed" : "Failed");
if (lastTestRun != null)
{
if (!testRunSuccess)
{
var failureNode = doc.CreateElement("failure");
testCaseNode.AppendChild(failureNode);
var messageNode = doc.CreateElement("message");
failureNode.AppendChild(messageNode);
messageNode.InnerText = $"Results are different";
}
var attachmentsNode = doc.CreateElement("attachments");
testCaseNode.AppendChild(attachmentsNode);
AddAttachment(doc, attachmentsNode, lastTestRun.FilePath, "Result output");
if (!testRunSuccess)
{
AddAttachment(doc, attachmentsNode, lastTestRun.DiffResultImage, "Image diff");
var previousRun = run.ResultRun.ElementAtOrDefault(run.ResultRun.Count - 2);
AddAttachment(doc, attachmentsNode, previousRun.FilePath, "Previous result output");
}
}
}
using (var file = XmlWriter.Create(File.OpenWrite(resultsFilePath), new XmlWriterSettings {
Indent = true
}))
{
doc.WriteTo(file);
}
}
/// <summary>
///
/// </summary>
/// <param name="cr"></param>
/// <returns></returns>
public static DataGridViewCellStyle GetCellStyle(DataGridViewCellStyle baseCellStyle, CompareResult cr)
{
DataGridViewCellStyle cs = baseCellStyle;
if (Config.Default.RendererType == RendererType.Fore)
{
switch (cr.CompareResultEnum)
{
case CompareResultEnum.Normal:
cs.ForeColor = Config.Default.ColorConifg.NormalColor;
break;
case CompareResultEnum.LowAlarm:
cs.ForeColor = Config.Default.ColorConifg.LowColor;
break;
case CompareResultEnum.HighAlarm:
cs.ForeColor = Config.Default.ColorConifg.HighColor;
break;
case CompareResultEnum.LowLowalarm:
cs.ForeColor = Config.Default.ColorConifg.LowLowColor;
break;
case CompareResultEnum.HighHighAlarm:
cs.ForeColor = Config.Default.ColorConifg.HighHighColor;
break;
default:
throw new ArgumentException(cr.CompareResultEnum.ToString());
}
}
else
{
switch (cr.CompareResultEnum)
{
case CompareResultEnum.Normal:
cs.BackColor = Config.Default.ColorConifg.NormalColor;
break;
case CompareResultEnum.LowAlarm:
cs.BackColor = Config.Default.ColorConifg.LowColor;
break;
case CompareResultEnum.HighAlarm:
cs.BackColor = Config.Default.ColorConifg.HighColor;
break;
case CompareResultEnum.LowLowalarm:
cs.BackColor = Config.Default.ColorConifg.LowLowColor;
break;
case CompareResultEnum.HighHighAlarm:
cs.BackColor = Config.Default.ColorConifg.HighHighColor;
break;
default:
throw new ArgumentException(cr.CompareResultEnum.ToString());
}
}
return cs;
}
private static void GenerateHTMLResults(string basePath, string platform, CompareResult result)
{
string path = basePath;
var resultsId = $"{DateTime.Now:yyyyMMdd-hhmmss}";
string diffPath = Path.Combine(basePath, $"Results-{platform}-{resultsId}");
string resultsFilePath = Path.Combine(basePath, $"Results-{platform}-{resultsId}.html");
Directory.CreateDirectory(path);
Directory.CreateDirectory(diffPath);
var sb = new StringBuilder();
sb.AppendLine("<html><body>");
sb.AppendLine("<p>How to read this table:</p>");
sb.AppendLine("<ul>");
sb.AppendLine("<li>This tool compares the binary content of successive runs screenshots of the same test output</li>");
sb.AppendLine("<li>Each line represents a test result screen shot.</li>");
sb.AppendLine("<li>Each cell number represent an unique image ID.</li>");
sb.AppendLine("<li>A red cell means the image has changed from the previous run (not that the results are incorrect).</li>");
sb.AppendLine("<li>Subtle changes can be visualized using a XOR filtering between images</li>");
sb.AppendLine("</ul>");
sb.AppendLine("<ul>");
foreach (var folder in result.Folders)
{
sb.AppendLine($"<li>{folder.index}: {folder.path}</li>");
}
sb.AppendLine("</ul>");
sb.AppendLine("<table>");
sb.AppendLine("<tr><td/>");
foreach (var folder in result.Folders)
{
sb.AppendLine($"<td>{folder.index}</td>");
}
sb.AppendLine("</tr>");
var changedList = new List <string>();
foreach (var testFile in result.Tests)
{
if (testFile.HasChanged)
{
sb.AppendLine($"<tr rowspan=\"3\"><td>{testFile.TestName}</td></tr>");
for (int platformIndex = 0; platformIndex < 1; platformIndex++)
{
sb.AppendLine("<tr>");
sb.AppendLine($"<td></td>");
for (int folderIndex = 0; folderIndex < testFile.ResultRun.Count; folderIndex++)
{
var resultRun = testFile.ResultRun[folderIndex];
var hasChanged = resultRun.HasChanged;
var color = resultRun.ImageId == -1 ? "#555" : hasChanged ? "#f00" : "#0f0";
sb.AppendLine($"<td bgcolor=\"{color}\" width=20 height=20>");
if (resultRun.ImageId != -1)
{
var relativePath = resultRun.FilePath.Replace(basePath, "").Replace("\\", "/").TrimStart('/');
sb.AppendLine($"<a href=\"{relativePath}\">{resultRun.ImageId}</a><!--{resultRun.ImageSha}-->");
var previousRun = testFile.ResultRun.ElementAtOrDefault(folderIndex - 1);
if (resultRun.HasChanged && resultRun.DiffResultImage != null)
{
var diffRelativePath = resultRun.DiffResultImage.Replace(basePath, "").Replace("\\", "/").TrimStart('/');
sb.AppendLine($"<a href=\"{diffRelativePath}\">D</a>");
}
else
{
sb.AppendLine($"D");
}
}
sb.AppendLine("</td>");
}
sb.AppendLine("</tr>");
}
}
}
sb.AppendLine("</table>");
sb.AppendLine($"{result.UnchangedTests} samples unchanged, {result.TotalTests} files total.");
sb.AppendLine("</body></html>");
File.WriteAllText(resultsFilePath, sb.ToString());
Console.WriteLine($"{platform}: {result.UnchangedTests} samples unchanged, {result.TotalTests} files total. Changed files:");
foreach (var changedFile in changedList)
{
Console.WriteLine($"\t- {changedFile}");
}
}
/// <summary>
/// Compares all the common collectors between two runs.
/// </summary>
/// <param name="firstRunId">The Base run id.</param>
/// <param name="secondRunId">The Compare run id.</param>
public void Compare(string firstRunId, string secondRunId)
{
if (firstRunId == null)
{
throw new ArgumentNullException(nameof(firstRunId));
}
if (secondRunId == null)
{
throw new ArgumentNullException(nameof(secondRunId));
}
List <RawCollectResult> addObjects = DatabaseManager.GetMissingFromFirst(firstRunId, secondRunId);
List <RawCollectResult> removeObjects = DatabaseManager.GetMissingFromFirst(secondRunId, firstRunId);
List <RawModifiedResult> modifyObjects = DatabaseManager.GetModified(firstRunId, secondRunId);
Parallel.ForEach(addObjects,
(added =>
{
var obj = new CompareResult()
{
Compare = Hydrate(added),
BaseRunId = firstRunId,
CompareRunId = secondRunId,
CompareRowKey = added.RowKey,
ChangeType = CHANGE_TYPE.CREATED,
ResultType = added.ResultType,
Identity = added.Identity
};
Log.Debug($"Adding {obj.Identity}");
Results[$"{added.ResultType.ToString()}_{CHANGE_TYPE.CREATED.ToString()}"].Enqueue(obj);
}));
Parallel.ForEach(removeObjects,
(removed =>
{
var obj = new CompareResult()
{
Base = Hydrate(removed),
BaseRunId = firstRunId,
CompareRunId = secondRunId,
BaseRowKey = removed.RowKey,
ChangeType = CHANGE_TYPE.DELETED,
ResultType = removed.ResultType,
Identity = removed.Identity
};
Results[$"{removed.ResultType.ToString()}_{CHANGE_TYPE.DELETED.ToString()}"].Enqueue(obj);
}));
Parallel.ForEach(modifyObjects,
(modified =>
{
var first = Hydrate(modified.First);
var second = Hydrate(modified.Second);
var obj = new CompareResult()
{
Base = first,
Compare = second,
BaseRunId = firstRunId,
CompareRunId = secondRunId,
BaseRowKey = modified.First.RowKey,
CompareRowKey = modified.Second.RowKey,
ChangeType = CHANGE_TYPE.MODIFIED,
ResultType = modified.First.ResultType,
Identity = modified.First.Identity
};
var properties = first.GetType().GetProperties();
foreach (var prop in properties)
{
try
{
var propName = prop.Name;
List <Diff> diffs;
object added = null;
object removed = null;
object changed = new object();
object firstProp = prop.GetValue(first);
object secondProp = prop.GetValue(second);
if (firstProp == null && secondProp == null)
{
continue;
}
else if (firstProp == null && secondProp != null)
{
added = prop.GetValue(second);
diffs = GetDiffs(prop, added, null);
}
else if (secondProp == null && firstProp != null)
{
removed = prop.GetValue(first);
diffs = GetDiffs(prop, null, removed);
}
else if (firstProp != null && secondProp != null && firstProp.Equals(secondProp))
{
continue;
}
else
{
var firstVal = prop.GetValue(first);
var secondVal = prop.GetValue(second);
if (firstVal is List <string> )
{
added = ((List <string>)prop.GetValue(second)).Except((List <string>)prop.GetValue(first));
removed = ((List <string>)prop.GetValue(first)).Except((List <string>)prop.GetValue(second));
if (!((IEnumerable <string>)added).Any())
{
added = null;
}
if (!((IEnumerable <string>)removed).Any())
{
removed = null;
}
}
else if (firstVal is List <KeyValuePair <string, string> > )
{
added = ((List <KeyValuePair <string, string> >)prop.GetValue(second)).Except((List <KeyValuePair <string, string> >)prop.GetValue(first));
removed = ((List <KeyValuePair <string, string> >)prop.GetValue(first)).Except((List <KeyValuePair <string, string> >)prop.GetValue(second));
if (!((IEnumerable <KeyValuePair <string, string> >)added).Any())
{
added = null;
}
if (!((IEnumerable <KeyValuePair <string, string> >)removed).Any())
{
removed = null;
}
}
else if (firstVal is Dictionary <string, string> )
{
added = ((Dictionary <string, string>)secondVal)
.Except((Dictionary <string, string>)firstVal)
.ToDictionary(x => x.Key, x => x.Value);
removed = ((Dictionary <string, string>)firstVal)
.Except((Dictionary <string, string>)secondVal)
.ToDictionary(x => x.Key, x => x.Value);
if (!((IEnumerable <KeyValuePair <string, string> >)added).Any())
{
added = null;
}
if (!((IEnumerable <KeyValuePair <string, string> >)removed).Any())
{
removed = null;
}
}
else if (firstVal is string || firstVal is int || firstVal is bool)
{
obj.Diffs.Add(new Diff()
{
Field = prop.Name, Before = firstVal, After = secondVal
});
}
else
{
obj.Diffs.Add(new Diff()
{
Field = prop.Name, Before = firstVal, After = secondVal
});
}
diffs = GetDiffs(prop, added, removed);
}
foreach (var diff in diffs)
{
obj.Diffs.Add(diff);
}
}
catch (InvalidCastException e)
{
Log.Debug(e, $"Failed to cast {JsonConvert.SerializeObject(prop)}");
}
catch (Exception e)
{
Log.Debug(e, "Generic exception. Tell a programmer.");
}
}
Results[$"{modified.First.ResultType.ToString()}_{CHANGE_TYPE.MODIFIED.ToString()}"].Enqueue(obj);
}));
foreach (var empty in Results.Where(x => x.Value.Count == 0))
{
Results.Remove(empty.Key, out _);
}
}
protected ANALYSIS_RESULT_TYPE Apply(Rule rule, CompareResult compareResult)
{
var fields = _Fields[compareResult.ResultType];
var properties = _Properties[compareResult.ResultType];
foreach (Clause clause in rule.clauses)
{
FieldInfo field = fields.FirstOrDefault(iField => iField.Name.Equals(clause.field));
PropertyInfo property = properties.FirstOrDefault(iProp => iProp.Name.Equals(clause.field));
if (field == null && property == null)
{
//Custom field logic will go here
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
try
{
var valsToCheck = new List <string>();
List <KeyValuePair <string, string> > dictToCheck = new List <KeyValuePair <string, string> >();
if (field != null)
{
if (compareResult.ChangeType == CHANGE_TYPE.CREATED || compareResult.ChangeType == CHANGE_TYPE.MODIFIED)
{
try
{
if (GetValueByFieldName(compareResult.Compare, field.Name) is List <string> )
{
foreach (var value in (List <string>)GetValueByFieldName(compareResult.Compare, field.Name))
{
valsToCheck.Add(value);
}
}
else if (GetValueByFieldName(compareResult.Compare, field.Name) is Dictionary <string, string> )
{
dictToCheck = ((Dictionary <string, string>)GetValueByFieldName(compareResult.Compare, field.Name)).ToList();
}
else if (GetValueByFieldName(compareResult.Compare, field.Name) is List <KeyValuePair <string, string> > )
{
dictToCheck = (List <KeyValuePair <string, string> >)GetValueByFieldName(compareResult.Compare, field.Name);
}
else
{
valsToCheck.Add(GetValueByFieldName(compareResult.Compare, field.Name).ToString());
}
}
catch (Exception e)
{
Log.Debug(e, "Error fetching Property {0} of Type {1}", field.Name, compareResult.ResultType);
}
}
if (compareResult.ChangeType == CHANGE_TYPE.DELETED || compareResult.ChangeType == CHANGE_TYPE.MODIFIED)
{
try
{
if (GetValueByFieldName(compareResult.Base, field.Name) is List <string> )
{
foreach (var value in (List <string>)GetValueByFieldName(compareResult.Base, field.Name))
{
valsToCheck.Add(value);
}
}
else if (GetValueByFieldName(compareResult.Base, field.Name) is Dictionary <string, string> )
{
dictToCheck = ((Dictionary <string, string>)GetValueByFieldName(compareResult.Base, field.Name)).ToList();
}
else if (GetValueByFieldName(compareResult.Base, field.Name) is List <KeyValuePair <string, string> > )
{
dictToCheck = (List <KeyValuePair <string, string> >)GetValueByFieldName(compareResult.Base, field.Name);
}
else
{
valsToCheck.Add(GetValueByFieldName(compareResult.Base, field.Name).ToString());
}
}
catch (Exception e)
{
Log.Debug(e, "Error fetching Property {0} of Type {1}", field.Name, compareResult.ResultType);
}
}
}
if (property != null)
{
if (compareResult.ChangeType == CHANGE_TYPE.CREATED || compareResult.ChangeType == CHANGE_TYPE.MODIFIED)
{
try
{
if (GetValueByPropertyName(compareResult.Compare, property.Name) is List <string> )
{
foreach (var value in (List <string>)GetValueByPropertyName(compareResult.Compare, property.Name))
{
valsToCheck.Add(value);
}
}
else if (GetValueByPropertyName(compareResult.Compare, property.Name) is Dictionary <string, string> )
{
dictToCheck = ((Dictionary <string, string>)GetValueByPropertyName(compareResult.Compare, property.Name)).ToList();
}
else if (GetValueByPropertyName(compareResult.Compare, property.Name) is List <KeyValuePair <string, string> > )
{
dictToCheck = (List <KeyValuePair <string, string> >)GetValueByPropertyName(compareResult.Compare, property.Name);
}
else
{
valsToCheck.Add(GetValueByPropertyName(compareResult.Compare, property.Name).ToString());
}
}
catch (Exception e)
{
Log.Debug(e, "Error fetching Property {0} of Type {1}", property.Name, compareResult.ResultType);
}
}
if (compareResult.ChangeType == CHANGE_TYPE.DELETED || compareResult.ChangeType == CHANGE_TYPE.MODIFIED)
{
try
{
if (GetValueByPropertyName(compareResult.Base, property.Name) is List <string> )
{
foreach (var value in (List <string>)GetValueByPropertyName(compareResult.Base, property.Name))
{
valsToCheck.Add(value);
}
}
else if (GetValueByPropertyName(compareResult.Base, property.Name) is Dictionary <string, string> )
{
dictToCheck = ((Dictionary <string, string>)GetValueByPropertyName(compareResult.Base, property.Name)).ToList();
}
else if (GetValueByPropertyName(compareResult.Base, property.Name) is List <KeyValuePair <string, string> > )
{
dictToCheck = (List <KeyValuePair <string, string> >)GetValueByPropertyName(compareResult.Base, property.Name);
}
else
{
valsToCheck.Add(GetValueByPropertyName(compareResult.Base, property.Name).ToString());
}
}
catch (Exception e)
{
Log.Debug(e, "Error fetching Property {0} of Type {1}", property.Name, compareResult.ResultType);
}
}
}
int count = 0, dictCount = 0;
switch (clause.op)
{
case OPERATION.EQ:
foreach (string datum in clause.data)
{
foreach (string val in valsToCheck)
{
count += (datum.Equals(val)) ? 1 : 0;
break;
}
}
if (count == clause.data.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.NEQ:
foreach (string datum in clause.data)
{
foreach (string val in valsToCheck)
{
if (datum.Equals(val))
{
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
}
break;
case OPERATION.CONTAINS:
if (dictToCheck.Count > 0)
{
foreach (KeyValuePair <string, string> value in clause.dictData)
{
if (dictToCheck.Where((x) => x.Key == value.Key && x.Value == value.Value).Count() > 0)
{
dictCount++;
}
}
if (dictCount == clause.dictData.Count)
{
break;
}
}
else if (valsToCheck.Count > 0)
{
foreach (string datum in clause.data)
{
foreach (string val in valsToCheck)
{
count += (!val.Contains(datum)) ? 1 : 0;
break;
}
}
if (count == clause.data.Count)
{
break;
}
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.DOES_NOT_CONTAIN:
if (dictToCheck.Count > 0)
{
foreach (KeyValuePair <string, string> value in clause.dictData)
{
if (dictToCheck.Where((x) => x.Key == value.Key && x.Value == value.Value).Count() > 0)
{
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
}
else if (valsToCheck.Count > 0)
{
foreach (string datum in clause.data)
{
if (valsToCheck.Contains(datum))
{
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
}
break;
case OPERATION.GT:
foreach (string val in valsToCheck)
{
count += (Int32.Parse(val.ToString()) > Int32.Parse(clause.data[0])) ? 1 : 0;
}
if (count == valsToCheck.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.LT:
foreach (string val in valsToCheck)
{
count += (Int32.Parse(val.ToString()) < Int32.Parse(clause.data[0])) ? 1 : 0;
}
if (count == valsToCheck.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.REGEX:
foreach (string val in valsToCheck)
{
foreach (string datum in clause.data)
{
var r = new Regex(datum);
if (r.IsMatch(val))
{
count++;
}
}
}
if (count == valsToCheck.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.WAS_MODIFIED:
if ((valsToCheck.Count == 2) && (valsToCheck[0] == valsToCheck[1]))
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.ENDS_WITH:
foreach (string datum in clause.data)
{
foreach (var val in valsToCheck)
{
if (val.EndsWith(datum, StringComparison.CurrentCulture))
{
count++;
break;
}
}
}
if (count == clause.data.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
case OPERATION.STARTS_WITH:
foreach (string datum in clause.data)
{
foreach (var val in valsToCheck)
{
if (val.StartsWith(datum, StringComparison.CurrentCulture))
{
count++;
break;
}
}
}
if (count == clause.data.Count)
{
break;
}
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
default:
Log.Debug("Unimplemented operation {0}", clause.op);
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
catch (Exception e)
{
Logger.DebugException(e);
return(DEFAULT_RESULT_TYPE_MAP[compareResult.ResultType]);
}
}
compareResult.Rules.Add(rule);
return(rule.flag);
}
/// <summary>
/// Compare object with parameters
/// </summary>
/// <param name="objectA"></param>
/// <param name="objectB"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public static CompareResult Compare(object objectA, object objectB, params CompareParameter[] parameters)
{
var result = new CompareResult();
if (objectA == null || objectB == null)
{
result.IsEqual = objectA == objectB;
return result;
}
if (parameters == null)
{
return new CompareResult { IsEqual = objectA.Equals(objectB) };
}
var typeA = objectA.GetType();
var typeB = objectB.GetType();
foreach (var parameter in parameters)
{
try
{
parameter.ObjectBPropertyName = parameter.ObjectBPropertyName ?? parameter.ObjectAPropertyName;
var propertyA = typeA.GetProperty(parameter.ObjectAPropertyName);
var propertyB = typeB.GetProperty(parameter.ObjectBPropertyName);
if (propertyA == null || propertyB == null)
{
return new CompareResult { Exception = new Exception("propertyA or propertyB is null") };
}
var valueA = propertyA.GetValue(objectA, null);
var valueB = propertyB.GetValue(objectB, null);
bool isEqual;
if (valueA == null || valueB == null)
{
isEqual = valueA == valueB;
}
else
{
if (parameter.CompareType != TypeCode.Empty)
{
valueA = Convert.ChangeType(valueA, parameter.CompareType);
valueB = Convert.ChangeType(valueB, parameter.CompareType);
}
isEqual = parameter.EqualComparer == null
? valueA.Equals(valueB)
: parameter.EqualComparer.Equals(valueA, valueB);
}
if (isEqual)
{
result.SamePropertyList.Add(new PropertyResult
{
ObjectAPropertyName = parameter.ObjectAPropertyName,
ObjectBPropertyName = parameter.ObjectBPropertyName,
ObjectAValue = valueA,
ObjectBValue = valueB
});
}
else
{
result.DifferentPropertyList.Add(new PropertyResult
{
ObjectAPropertyName = parameter.ObjectAPropertyName,
ObjectBPropertyName = parameter.ObjectBPropertyName,
ObjectAValue = valueA,
ObjectBValue = valueB
});
}
}
catch (Exception ex)
{
return new CompareResult { Exception = ex };
}
}
result.IsEqual = result.DifferentPropertyList.Count == 0;
return result;
}
static void Main()
{
Console.WriteLine("You are runnning the Mathematics example.");
Console.WriteLine("==========================================");
Console.WriteLine();
#region Basic Operations
Console.WriteLine(" Basics----------------------------------------------");
Console.WriteLine();
// Variables
Fraction <short> clampA = new Fraction <short>(-123, 9); // -123 / 9
Fraction <short> clampB = new Fraction <short>(7, 12); // 7 / 12
Fraction <short> clampC = new Fraction <short>(14, 15); // 14 / 15
double[] values = new double[4];
Stepper <double> valueStepper = values.ToStepper();
values.Format(x => random.NextDouble());
// Examples
double negation = Negation(7);
Console.WriteLine(" Negate(7): " + negation);
decimal addition = Addition(7m, 7m);
Console.WriteLine(" Add(7, 7): " + addition);
double summation = Σ(valueStepper);
Console.WriteLine(" Σ (" + string.Join(", ", values.Select(x => Format(x))) + ") = " + summation);
float subtraction = Subtraction(14f, 7f);
Console.WriteLine(" Subtract(14, 7): " + subtraction);
long multiplication = Multiplication(7L, 7L);
Console.WriteLine(" Multiply(7, 7): " + multiplication);
double product = Π(valueStepper);
Console.WriteLine(" Π (" + string.Join(", ", values.Select(x => Format(x))) + ") = " + product);
short division = Division((short)14, (short)7);
Console.WriteLine(" Divide(14, 7): " + division);
double absoluteValue = AbsoluteValue(-7d);
Console.WriteLine(" AbsoluteValue(-7): " + absoluteValue);
Fraction <short> clamp = Clamp(clampA, clampB, clampC);
Console.WriteLine(" Clamp(" + clampA + ", " + clampB + ", " + clampC + "): " + clamp);
int maximum = Maximum(1, 2, 3);
Console.WriteLine(" Maximum(1, 2, 3): " + maximum);
int minimum = Minimum(1, 2, 3);
Console.WriteLine(" Minimum(1, 2, 3): " + minimum);
bool lessThan = LessThan((Fraction <int>) 1, (Fraction <int>) 2);
Console.WriteLine(" LessThan(1, 2): " + lessThan);
bool greaterThan = GreaterThan((Fraction <int>) 1, (Fraction <int>) 2);
Console.WriteLine(" GreaterThan(1, 2): " + greaterThan);
CompareResult compare = Comparison((Fraction <short>) 7, (Fraction <short>) 7);
Console.WriteLine(" Compare(7, 7): " + compare);
bool equality = EqualTo(7, 6);
Console.WriteLine(" Equate(7, 6): " + equality);
bool equalsLeniency = EqualToLeniency(2, 1, 1);
Console.WriteLine(" EqualsLeniency(2, 1, 1): " + equalsLeniency);
Console.WriteLine();
#endregion
#region More Numeric Mathematics
Console.WriteLine(" More Numeric Mathematics----------------------------");
Console.WriteLine();
// some random ints for the examples
int random1 = random.Next(1, 100000);
int random2 = random.Next(1, 1000);
int random3 = random.Next(1, 1000);
int random4 = random.Next(1, 1000);
int random5 = random.Next(1, 1000);
int random6 = random.Next(1, 1000);
int random7 = random.Next(6, 10);
int random8 = random.Next(1, 100000);
int[] randomInts1 = new int[3];
randomInts1.Format(x => random.Next(1, 500) * 2);
Stepper <int> randomInts1Stepper = randomInts1.ToStepper();
int[] randomInts2 = new int[3];
randomInts2.Format(x => random.Next(1, 500) * 2);
Stepper <int> randomInts2Stepper = randomInts2.ToStepper();
bool isPrime = IsPrime(random1);
Console.WriteLine(" IsPrime(" + random1 + "): " + isPrime);
bool isNegative = IsNegative(random2);
Console.WriteLine(" IsNegative(" + random2 + "): " + isNegative);
bool isNonNegative = IsNonNegative(random3);
Console.WriteLine(" IsNonNegative(" + random3 + "): " + isNonNegative);
bool isPositive = IsPositive(random4);
Console.WriteLine(" IsPositive(" + random4 + "): " + isPositive);
bool isOdd = IsOdd(random5);
Console.WriteLine(" IsOdd(" + random5 + "): " + isOdd);
bool isEven = IsEven(random6);
Console.WriteLine(" IsEven(" + random6 + "): " + isEven);
int greatestCommonFactor = GreatestCommonFactor(randomInts1Stepper);
Console.WriteLine(" GCF(" + string.Join(", ", randomInts1) + "): " + greatestCommonFactor);
int leastCommonMultiple = LeastCommonMultiple(randomInts2Stepper);
Console.WriteLine(" LCM(" + string.Join(", ", randomInts2) + "): " + leastCommonMultiple);
int factorial = Factorial(random7);
Console.WriteLine(" " + random7 + "!: " + factorial);
int combinations = Combinations(7, Ɐ(3, 4));
Console.WriteLine(" 7! / (3! * 4!): " + combinations);
int binomialCoefficient = BinomialCoefficient(7, 2);
Console.WriteLine(" 7 choose 2: " + binomialCoefficient);
Console.Write(" Prime Factors(" + random8 + "): ");
FactorPrimes(random8, prime => Console.Write(prime + " "));
Console.WriteLine();
Console.WriteLine();
#endregion
#region Trigonometry
Console.WriteLine(" Trigonometry -----------------------------------------");
Console.WriteLine();
double randomDouble = random.NextDouble();
Angle <double> randomAngle = new Angle <double>(randomDouble, Angle.Units.Radians);
double sineTaylorSeries = SineTaylorSeries(randomAngle);
Console.WriteLine(" SinTaylorSeries(" + randomAngle + ") = " + Format(sineTaylorSeries));
double cosineTaylorSeries = CosineTaylorSeries(randomAngle);
Console.WriteLine(" CosinTaylorSeries(" + randomAngle + ") = " + Format(cosineTaylorSeries));
Console.WriteLine();
#endregion
#region Statistics
Console.WriteLine(" Statistics-----------------------------------------");
Console.WriteLine();
// Data Generation
double mode_temp = random.NextDouble() * 100;
double[] dataArray = new double[random.Next(5, 7)];
dataArray.Format(x => random.NextDouble() * 100);
// Lets copy a value in the array to ensure there is at least one
// duplicate (so the "Mode" example will has something to show)
dataArray[^ 1] = dataArray[0];
/// <summary>Inverts a comparison value.</summary> /// <returns>The invert of the comparison value.</returns> public static CompareResult Invert(this CompareResult compareResult) => (CompareResult)(-(int)compareResult);
private CompareResult ProcessFileInternal(string fileOrFolder, string file, CompareDirection direction)
{
CompareResult result = new CompareResult();
result.FileName = fileOrFolder.GetFileName();
result.FileExtension = fileOrFolder.GetFileExtension();
if (direction == CompareDirection.Left)
{
result.LeftFilePath = fileOrFolder;
result.LeftCreatedDate = File.GetCreationTime(fileOrFolder);
result.LeftModifiedDate = File.GetLastWriteTime(fileOrFolder);
result.LeftHash = file != string.Empty ? MD5Hash.HashFile(fileOrFolder) : string.Empty;
result.RightFilePath = file != string.Empty ? file : string.Empty;
result.RightCreatedDate = file != string.Empty ? File.GetCreationTime(file) : DateTime.MinValue;
result.RightModifiedDate = file != string.Empty ? File.GetLastWriteTime(file) : DateTime.MinValue;
result.RightHash = file != string.Empty ? MD5Hash.HashFile(file) : string.Empty;
result.ExistsLeft = true;
result.ExistsRight = file != string.Empty;
}
else
{
result.RightFilePath = fileOrFolder;
result.RightCreatedDate = File.GetCreationTime(fileOrFolder);
result.RightModifiedDate = File.GetLastWriteTime(fileOrFolder);
result.RightHash = file != string.Empty ? MD5Hash.HashFile(fileOrFolder) : string.Empty;
result.LeftFilePath = file != string.Empty ? file : string.Empty;
result.LeftCreatedDate = file != string.Empty ? File.GetCreationTime(file) : DateTime.MinValue;
result.LeftModifiedDate = file != string.Empty ? File.GetLastWriteTime(file) : DateTime.MinValue;
result.LeftHash = file != string.Empty ? MD5Hash.HashFile(file) : string.Empty;
result.ExistsRight = true;
result.ExistsLeft = file != string.Empty;
}
result.Match = file != string.Empty ? result.LeftHash == result.RightHash : false;
result.Compared = true;
result.IsFile = true;
return result;
}
