public SwallowedCounterOutput(IOutputFullResults <Method, Assembly> inner)
            : base(inner)
        {
            Contract.Requires(inner != null);

            this.swallowed = new SwallowedBuckets();
        }
Beispiel #2
0
 public RegressionOutput(IOutputFullResults <Method, Assembly> output, GeneralOptions options, IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> mdDecoder)
     : base(output)
 {
     this.options             = options;
     this.mdDecoder           = mdDecoder;
     this.methodAnalysisCount = new Dictionary <Method, int>();
 }
        public WarningSuggestionLinkOutput(IOutputFullResults <Method, Assembly> inner)
            : base(inner)
        {
            Contract.Requires(inner != null);

            this.suppressWarningManager = new SuppressWarningsManager <Method>();
            this.DB = null;
        }
        public ExternallyVisibleMethodsOnlyOutput(IOutputFullResults <Method, Assembly> inner, Predicate <Method> IsVisibleOutsideTheAssembly)
            : base(inner)
        {
            Contract.Requires(inner != null);
            Contract.Requires(IsVisibleOutsideTheAssembly != null);

            this.IsVisibleOutsideTheAssembly = IsVisibleOutsideTheAssembly;
            this.isMethodOk = false;
        }
        public MaskingSuggestions(string methodName, IOutputFullResults <Method, Assembly> inner)
            : base(inner)
        {
            Contract.Requires(methodName != null);
            Contract.Requires(inner != null);

            this.methodName = methodName;
            this.ok         = false;
        }
        public XmlBaseLineWriter(IOutputFullResults <Method, Assembly> output, GeneralOptions options, IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> mdDecoder,
                                 CacheManager <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, ExternalExpression <APC, SymbolicValue>, SymbolicValue> cacheManager, string targetFileName)
            : base(output, options, mdDecoder)

        {
            this.targetFileName = targetFileName;
            this.cacheManager   = cacheManager;
            var settings = new XmlWriterSettings();

            settings.Indent = true;
            this.xmlWriter  = XmlWriter.Create(targetFileName, settings);
            this.xmlWriter.WriteStartElement("Assembly");
        }
        public MaskingOutput(IOutputFullResults <Method, Assembly> output, GeneralOptions options,
                             IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> mdDecoder)
            : base(output)
        {
            Contract.Requires(output != null);
            Contract.Requires(options != null);
            Contract.Requires(mdDecoder != null);

            this.options                 = options;
            this.mdDecoder               = mdDecoder;
            this.currMethod              = default(Method);
            this.methodmask              = null;
            this.assemblymask            = null;
            this.swallowedCount          = new SwallowedBuckets();
            this.suppressWarningsManager = new SuppressWarningsManager <Method>();
            this.errorsWereEmitted       = false;
        }
 public XmlBaseLineComparer(IOutputFullResults <Method, Assembly> output, GeneralOptions options, IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> mdDecoder,
                            CacheManager <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, ExternalExpression <APC, SymbolicValue>, SymbolicValue> cacheManager, string xmlBaseLineFile)
     : base(output, options, mdDecoder)
 {
     this.cacheManager = cacheManager;
     try
     {
         this.baseLineRoot = XElement.Load(xmlBaseLineFile);
         // gets pool of *all* expected outcomes (currently, does not distinguish by method)
         expectedAssemblyOutcomes = BaseLineOutcomes.GetOutcomes(this.GetAssemblyRoots(), this.options.baseLineStrategy);
     }
     catch (System.Xml.XmlException)
     {
         output.WriteLine("Error: baseline file {0} is corrupted", xmlBaseLineFile);
         Environment.Exit(-1);
     }
     this.swallowedCounter = new SwallowedBuckets();
 }
Beispiel #9
0
        public QuantitativeOutput(
            bool SortWarnings, bool ShowScores, bool showJustification,
            Func <WarningLevelOptions> WarningLevel, WarningScoresManager scoresManager,
            int MaxWarnings, IOutputFullResults <Method, Assembly> output)
            : base(output)
        {
            Contract.Requires(scoresManager != null);
            Contract.Requires(output != null);

            this.sortWarnings      = SortWarnings;
            this.showJustification = showJustification;
            this.showScores        = ShowScores;
            this.warningLevel      = WarningLevel;
            this.maxWarnings       = MaxWarnings;
            this.scoresManager     = scoresManager;
            this.warnings          = new SortedDictionary <double, List <Bucket> >(new InverseNaturalOrder());
            this.emitCount         = 0;
            this.outcomeCount      = 0;
            this.swallowedCount    = new SwallowedBuckets();
        }
Beispiel #10
0
 public MaskVerifiedRepairsSuggestions(IOutputFullResults <Method, Assembly> inner)
     : base(inner)
 {
     Contract.Requires(inner != null);
 }
Beispiel #11
0
 public XmlBaseLine(IOutputFullResults <Method, Assembly> output, GeneralOptions options, IDecodeMetaData <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly> mdDecoder)
 {
     this.output    = output;
     this.options   = options;
     this.mdDecoder = mdDecoder;
 }