public static DisjunctiveExamplesSpec WitnessK(GrammarRule rule, int parameter, DisjunctiveExamplesSpec spec) { var kExamples = new Dictionary<State, IEnumerable<object>>(); foreach (State input in spec.ProvidedInputs) { var v = (StringRegion) input[rule.Body[0]]; var positions = new List<object>(); foreach (uint pos in spec.DisjunctiveExamples[input]) { positions.Add((int) pos + 1 - (int) v.Start); positions.Add((int) pos - (int) v.End - 1); } kExamples[input] = positions; } return DisjunctiveExamplesSpec.From(kExamples); }
static DisjunctiveExamplesSpec WitnessK(GrammarRule rule, int parameter, DisjunctiveExamplesSpec spec) { var result = new Dictionary<State, IEnumerable<object>>(); foreach (var example in spec.DisjunctiveExamples) { State inputState = example.Key; var ks = new HashSet<int?>(); var inp = (string)inputState[rule.Body[0]]; foreach (int? pos in example.Value) { ks.Add(pos); ks.Add(pos - inp.Length - 1); } if (ks.Count == 0) return null; result[inputState] = ks.Cast<object>(); } return new DisjunctiveExamplesSpec(result); }
static DisjunctiveExamplesSpec WitnessRegexPair(GrammarRule rule, int parameter, DisjunctiveExamplesSpec spec) { var result = new Dictionary<State, IEnumerable<object>>(); foreach (var example in spec.DisjunctiveExamples) { State inputState = example.Key; var inp = (string)inputState[rule.Body[0]]; List<Tuple<Match, Regex>>[] leftMatches, rightMatches; BuildStringMatches(inp, out leftMatches, out rightMatches); var regexes = new List<Tuple<Regex, Regex>>(); foreach (int? pos in example.Value) { regexes.AddRange(from l in leftMatches[pos.Value] from r in rightMatches[pos.Value] select Tuple.Create(l.Item2, r.Item2)); } if (regexes.Count == 0) return null; result[inputState] = regexes; } return new DisjunctiveExamplesSpec(result); }
public static DisjunctiveExamplesSpec WitnessRegexCount(GrammarRule rule, int parameter, DisjunctiveExamplesSpec spec, ExampleSpec regexBinding) { var kExamples = new Dictionary<State, IEnumerable<object>>(); foreach (State input in spec.ProvidedInputs) { var v = (StringRegion) input[rule.Body[0]]; var rr = (Tuple<RegularExpression, RegularExpression>) regexBinding.Examples[input]; var ks = new List<object>(); foreach (uint pos in spec.DisjunctiveExamples[input]) { var ms = rr.Item1.Run(v).Where(m => rr.Item2.MatchesAt(v, m.Right)).ToArray(); int index = ms.BinarySearchBy(m => m.Right.CompareTo(pos)); if (index < 0) return null; ks.Add(index + 1); ks.Add(index - ms.Length); } kExamples[input] = ks; } return DisjunctiveExamplesSpec.From(kExamples); }
public static DisjunctiveExamplesSpec WitnessRegexPair(GrammarRule rule, int parameter, DisjunctiveExamplesSpec spec) { var rrExamples = new Dictionary<State, IEnumerable<object>>(); foreach (State input in spec.ProvidedInputs) { var v = (StringRegion) input[rule.Body[0]]; var regexes = new List<Tuple<RegularExpression, RegularExpression>>(); foreach (uint pos in spec.DisjunctiveExamples[input]) { Dictionary<Token, TokenMatch> rightMatches; if (!v.Cache.TryGetAllMatchesStartingAt(pos, out rightMatches)) continue; Dictionary<Token, TokenMatch> leftMatches; if (!v.Cache.TryGetAllMatchesEndingAt(pos, out leftMatches)) continue; var leftRegexes = leftMatches.Keys.Select(RegularExpression.Create).Append(Epsilon); var rightRegexes = rightMatches.Keys.Select(RegularExpression.Create).Append(Epsilon); var regexPairs = from l in leftRegexes from r in rightRegexes select Tuple.Create(l, r); regexes.AddRange(regexPairs); } rrExamples[input] = regexes; } return DisjunctiveExamplesSpec.From(rrExamples); }
static DisjunctiveExamplesSpec WitnessKForRegexPair(GrammarRule rule, int parameter, DisjunctiveExamplesSpec spec, ExampleSpec rrSpec) { var result = new Dictionary<State, IEnumerable<object>>(); foreach (var example in spec.DisjunctiveExamples) { State inputState = example.Key; var inp = (string)inputState[rule.Body[0]]; var regexPair = (Tuple<Regex, Regex>)rrSpec.Examples[inputState]; Regex left = regexPair.Item1; Regex right = regexPair.Item2; var rightMatches = right.Matches(inp).Cast<Match>().ToDictionary(m => m.Index); var matchPositions = new List<int>(); foreach (Match m in left.Matches(inp)) { if (rightMatches.ContainsKey(m.Index + m.Length)) matchPositions.Add(m.Index + m.Length); } var ks = new HashSet<int?>(); foreach (int? pos in example.Value) { int occurrence = matchPositions.BinarySearch(pos.Value); if (occurrence < 0) continue; ks.Add(occurrence); ks.Add(occurrence - matchPositions.Count); } if (ks.Count == 0) return null; result[inputState] = ks.Cast<object>(); } return new DisjunctiveExamplesSpec(result); }
internal DisjunctiveExamplesSpec WitnessSelectWithWhereColumnArray(GrammarRule rule, DisjunctiveExamplesSpec spec, ExampleSpec conditionSpec) { var ppExamples = new Dictionary <State, IEnumerable <object> >(); var conditionTable = (DataTable)conditionSpec.Examples.Values.First(); foreach (State input in spec.ProvidedInputs) { DataTable inputTable = ((DataTable[])input[rule.Grammar.InputSymbol])[0]; var desiredOutput = (DataTable)spec.DisjunctiveExamples[input].First(); // conditionTable; var allPossibleSolutions = new List <object>(); allPossibleSolutions.Add(desiredOutput.Columns.Cast <DataColumn>().ToArray()); ppExamples[input] = allPossibleSolutions; } //Complete the rows return(DisjunctiveExamplesSpec.From(ppExamples)); }
internal DisjunctiveExamplesSpec WitnessComparatorConstValue(GrammarRule rule, DisjunctiveExamplesSpec spec, ExampleSpec columnSpec, ExampleSpec cmpSymbolSpec) { /* Inverse for the constValue field */ var ppExamples = new Dictionary <State, IEnumerable <object> >(); foreach (State input in spec.ProvidedInputs) { // Add a for loop here & Iterate over it to add everything to all possible solutions var allPossibleSolutions = new List <object>(); foreach (DataTable outputTable in spec.DisjunctiveExamples[input]) { DataTable inputTable = ((DataTable[])input[rule.Grammar.InputSymbol])[0]; if (outputTable.Rows.Count == 0) { ppExamples[input] = allPossibleSolutions; continue; } string cmpSymbol = (string)cmpSymbolSpec.Examples[cmpSymbolSpec.ProvidedInputs.First()]; // Get the comparison symbol DataColumn column = (DataColumn)columnSpec.Examples[columnSpec.ProvidedInputs.First()]; // Column bool flag = true; if (column.DataType == typeof(string)) { var mappedCmpSymbol = ""; string valueToCompare = ""; switch (cmpSymbol) { case "==": mappedCmpSymbol = "="; var valuesInColumn = outputTable.Rows.Cast <DataRow>().Select(t => t[column.ColumnName]).Distinct(); // TODO: Get a linq guy to look this up if (valuesInColumn.Count() != 1) { flag = false; } else { valueToCompare = (string)valuesInColumn.First(); } // else, Keep it as empty break; default: // TODO: Unsupported datatype flag = false; break; } if (flag) { var countRowsInput = inputTable.Select(column.ColumnName + mappedCmpSymbol + "'" + valueToCompare + "'").Count(); // var countRowsOutput = outputTable.Select(column.ColumnName + mappedCmpSymbol + "'" + valueToCompare + "'").Count(); var countRowsOutput = outputTable.Rows.Count; // This seems more correct if (flag && countRowsInput == countRowsOutput) { allPossibleSolutions.Add((object)valueToCompare); } } } else if (column.DataType == typeof(double)) { double valueToCompare = 0; var mappedCmpSymbol = ""; switch (cmpSymbol) { case "==": mappedCmpSymbol = "="; var valuesInColumn = outputTable.Rows.Cast <DataRow>().Select(t => t[column.ColumnName]).Distinct(); // TODO: Get a linq guy to look this up if (valuesInColumn.Count() != 1) { flag = false; } else { valueToCompare = (double)valuesInColumn.First(); } // else, Keep it as empty break; case ">=": { mappedCmpSymbol = ">="; valueToCompare = (double)outputTable.Rows.Cast <DataRow>().Select(t => t[column.ColumnName]).Min(); break; } case "<=": { mappedCmpSymbol = "<="; valueToCompare = (double)outputTable.Rows.Cast <DataRow>().Select(t => t[column.ColumnName]).Max(); break; } case "<": { mappedCmpSymbol = "<"; var excludedRow1 = inputTable.AsEnumerable().Where(r => !outputTable.AsEnumerable() .Select(x => x[column.ColumnName]) .ToList() .Contains(r[column.ColumnName]) ); if (excludedRow1 != null && excludedRow1.Count() != 0) { valueToCompare = (double) ((excludedRow1).ToList()).Cast <DataRow>().Select(t => t[column.ColumnName]).Min(); if (valueToCompare <= (double)outputTable .Rows.Cast <DataRow>() .Select(t => t[column.ColumnName]).Max() ) { flag = false; } } else { flag = false; } break; } case ">": mappedCmpSymbol = ">"; var excludedRow = inputTable.AsEnumerable().Where(r => !outputTable.AsEnumerable().Select(x => x[column.ColumnName]).ToList().Contains(r[column.ColumnName])); if (excludedRow != null && excludedRow.Count() != 0) { valueToCompare = (double) (excludedRow.ToList()).Cast <DataRow>().Select(t => t[column.ColumnName]).Max(); if (valueToCompare >= (double)outputTable .Rows.Cast <DataRow>() .Select(t => t[column.ColumnName]).Min() ) { flag = false; } } else { flag = false; } break; case "!=": mappedCmpSymbol = "<>"; var excluded2 = inputTable.AsEnumerable().Where(r => !outputTable.AsEnumerable() .Select(x => x[column.ColumnName]).ToList() .Contains(r[column.ColumnName]) ); var valuesExcludedInColumn = ((excluded2).ToList()).Cast <DataRow>().Select(t => t[column.ColumnName]).Distinct(); // TODO: Get a linq guy to look this up if (valuesExcludedInColumn.Count() != 1) { flag = false; } else { valueToCompare = (double)valuesExcludedInColumn.First(); } // else, Keep it as empty break; default: // TODO: Unsupported datatype flag = false; break; } if (flag) { var countRowsInput = inputTable.Select(column.ColumnName + mappedCmpSymbol + valueToCompare).Count(); var countRowsOutput = outputTable.Select(column.ColumnName + mappedCmpSymbol + valueToCompare).Count(); // This seems more correct // var countRowsOutput = outputTable.Rows.Count; if (flag && countRowsInput == countRowsOutput && (countRowsInput != 0 || outputTable.Rows.Count == 0)) { allPossibleSolutions.Add((object)valueToCompare); } } } } ppExamples[input] = allPossibleSolutions; } return(DisjunctiveExamplesSpec.From(ppExamples)); }
internal DisjunctiveExamplesSpec WitnessComparatorCmpSymbol(GrammarRule rule, DisjunctiveExamplesSpec spec) { /* Inverse for the constValue field */ var ppExamples = new Dictionary <State, IEnumerable <object> >(); foreach (State input in spec.ProvidedInputs) { var allPossibleSolutions = Semantics.CmpGen; ppExamples[input] = allPossibleSolutions; } return(DisjunctiveExamplesSpec.From(ppExamples)); }
internal DisjunctiveExamplesSpec WitnessConcatTree2(GrammarRule rule, DisjunctiveExamplesSpec spec, DisjunctiveExamplesSpec tree1Spec) { var result = new Dictionary <State, IEnumerable <object> >(); foreach (KeyValuePair <State, IEnumerable <object> > example in spec.DisjunctiveExamples) { State inputState = example.Key; List <IReadOnlyList <Node> > possibleCombinations = new List <IReadOnlyList <Node> >(); foreach (IReadOnlyList <Node> tree1NodeList in tree1Spec.DisjunctiveExamples[inputState]) { IEnumerable <Node> temp = from output in example.Value from outNode in (IReadOnlyList <Node>)output where tree1NodeList.All( tree1Node => Semantics.NodeValue(tree1Node, Path) != Semantics.NodeValue(outNode, Path)) select outNode; possibleCombinations.Add(temp.ToList()); } result[inputState] = possibleCombinations; } return(DisjunctiveExamplesSpec.From(result)); }
internal DisjunctiveExamplesSpec WitnessApplyAction(GrammarRule rule, DisjunctiveExamplesSpec spec) { return(spec); }
internal DisjunctiveExamplesSpec WitnessSelectDownstreamPath(GrammarRule rule, DisjunctiveExamplesSpec spec) { var result = new Dictionary <State, IEnumerable <object> >(); foreach (KeyValuePair <State, IEnumerable <object> > example in spec.DisjunctiveExamples) { State inputState = example.Key; var input = example.Key[Grammar.InputSymbol] as MergeConflict; result[inputState] = SelectPath(example.Value, input.Downstream); } return(DisjunctiveExamplesSpec.From(result)); }
internal DisjunctiveExamplesSpec WitnessRemoveTree2(GrammarRule rule, DisjunctiveExamplesSpec spec, DisjunctiveExamplesSpec tree1Spec) { var result = new Dictionary <State, IEnumerable <object> >(); foreach (KeyValuePair <State, IEnumerable <object> > example in spec.DisjunctiveExamples) { State inputState = example.Key; List <IReadOnlyList <Node> > possibleCombinations = new List <IReadOnlyList <Node> >(); foreach (IReadOnlyList <Node> output in example.Value) { foreach (IReadOnlyList <Node> tree1NodeList in tree1Spec.DisjunctiveExamples[inputState]) { possibleCombinations.Add( tree1NodeList.Where(n => !output.Select(Utils.GetPath).Contains(n.GetPath())).ToList()); } } result[inputState] = possibleCombinations; } return(DisjunctiveExamplesSpec.From(result)); }