public static Collection <FileInfo> Reduce(Collection <FileInfo> tests) { Dictionary <EquivClass, TestCase> representatives = new Dictionary <EquivClass, TestCase>(); Dictionary <EquivClass, FileInfo> representativesFileInfos = new Dictionary <EquivClass, FileInfo>(); foreach (FileInfo file in tests) { TestCase testCase; try { testCase = new TestCase(file); } catch (Exception) { // File does not contain a valid test case, or // test case is malformed. continue; } EquivClass partition = new EquivClass(testCase); // If there are no representatives for this partition, // use testCase as the representative. if (!representatives.ContainsKey(partition)) { representatives[partition] = testCase; representativesFileInfos[partition] = file; } // if testCase is smaller than the current representative, // use testCase as the representative. // Delete the old representative. else if (testCase.NumTestLines < representatives[partition].NumTestLines) { //representativesFileInfos[partition].Delete(); representativesFileInfos[partition].MoveTo(representativesFileInfos[partition].FullName + ".reduced"); representatives[partition] = testCase; representativesFileInfos[partition] = file; } // Representative is redundant and larger than current representative. // Delete representative. else { //file.Delete(); file.MoveTo(file.FullName + ".reduced"); } } List <FileInfo> retval = new List <FileInfo>(); retval.AddRange(representativesFileInfos.Values); return(new Collection <FileInfo>(retval)); }
public override bool Equals(object obj) { EquivClass other = obj as EquivClass; if (other == null) { return(false); } if (!this.representative.exception.Equals(other.representative.exception)) { return(false); } if (!this.representative.lastAction.Equals(other.representative.lastAction)) { return(false); } return(true); }
public override bool Equals(object obj) { EquivClass other = obj as EquivClass; if (other == null) { return(false); } if (!this.representative.exception.Equals(other.representative.exception)) // if "throw the same exception" { return(false); } if (!this.representative.lastAction.Equals(other.representative.lastAction)) // if "end with the same method call" { return(false); } return(true); }
/// <summary> /// Given an array of predidates {p_1, p_2, ..., p_n} where n>=0. /// Enumerate all satisfiable Boolean combinations Tuple({b_1, b_2, ..., b_n}, p) /// where p is satisfiable and equivalent to p'_1 & p'_2 & ... & p'_n, /// where p'_i = p_i if b_i = true and p'_i is Not(p_i) otherwise. /// If n=0 return Tuple({},True). /// </summary> /// <param name="preds">array of predicates</param> /// <param name="useEquivalenceChecking">optimization flag: if true, uses equivalence checking to cluster equivalent predicates; otherwise does not use equivalence checking</param> /// <returns>all minterms of the given predicate sequence</returns> public IEnumerable <Tuple <bool[], PRED> > GenerateMinterms(bool useEquivalenceChecking, params PRED[] preds) { if (preds.Length == 0) { yield return(new Tuple <bool[], PRED>(new bool[] { }, ba.True)); } else { var count = preds.Length; List <PRED> nonequivalentSets = new List <PRED>(); //work only with nonequivalent sets as distinct elements var indexLookup = new Dictionary <int, int>(); var newIndexMap = new Dictionary <EquivClass, int>(); var equivs = new List <List <int> >(); for (int i = 0; i < count; i++) { int newIndex; EquivClass equiv = CreateEquivalenceClass(useEquivalenceChecking, preds[i]); if (!newIndexMap.TryGetValue(equiv, out newIndex)) { newIndex = newIndexMap.Count; newIndexMap[equiv] = newIndex; nonequivalentSets.Add(preds[i]); equivs.Add(new List <int>()); } indexLookup[i] = newIndex; equivs[newIndex].Add(i); } //var pairs = new List<Tuple<IntSet, PRED>>(GenerateMinterms1(nonequivalentSets.ToArray())); //foreach (var pair in pairs) //{ // var characteristic = new bool[preds.Length]; // for (int i = 0; i < count; i++) // if (pair.First.Contains(indexLookup[i])) // characteristic[i] = true; // yield return // new Tuple<bool[], PRED>(characteristic, pair.Second); //} var tree = new PartitonTree <PRED>(ba); foreach (var psi in nonequivalentSets) { tree.Refine(psi); } foreach (var leaf in tree.GetLeaves()) { var characteristic = new bool[preds.Length]; foreach (var k in leaf.GetPath()) { foreach (var n in equivs[k]) { characteristic[n] = true; } } yield return (new Tuple <bool[], PRED>(characteristic, leaf.phi)); } } }
public static Collection<FileInfo> Reduce(Collection<FileInfo> tests) { Dictionary<EquivClass, TestCase> representatives = new Dictionary<EquivClass, TestCase>(); Dictionary<EquivClass, FileInfo> representativesFileInfos = new Dictionary<EquivClass, FileInfo>(); foreach (FileInfo file in tests) { TestCase testCase; try { testCase = new TestCase(file); } catch (Exception) { // File does not contain a valid test case, or // test case is malformed. continue; } EquivClass partition = new EquivClass(testCase); // If there are no representatives for this partition, // use testCase as the representative. if (!representatives.ContainsKey(partition)) { representatives[partition] = testCase; representativesFileInfos[partition] = file; } // if testCase is smaller than the current representative, // use testCase as the representative. // Delete the old representative. else if (testCase.NumTestLines < representatives[partition].NumTestLines) { representativesFileInfos[partition].Delete(); representatives[partition] = testCase; representativesFileInfos[partition] = file; } // Representative is redundant and larger than current representative. // Delete representative. else { file.Delete(); } } List<FileInfo> retval = new List<FileInfo>(); retval.AddRange(representativesFileInfos.Values); return new Collection<FileInfo>(retval); }