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; }