public PexMePostProcessor(IPexComponent host)
     : base(host)
 {
     this.host = host;
     this.pmd = host.GetService<IPexMeDynamicDatabase>() as PexMeDynamicDatabase;
     this.psd = host.GetService<IPexMeStaticDatabase>() as PexMeStaticDatabase;
     this.pdw = new PexMeDumpWriter(host);
     this.currAssembly = this.pmd.Services.CurrentAssembly.Assembly.Assembly;
     var nestingdepth = System.Environment.GetEnvironmentVariable("PEXME_NESTED_DEPTH");
     if (nestingdepth != null)
         ndepth = Convert.ToInt32(nestingdepth, 10);
 }
        /// <summary>
        /// Initializes DUCover.
        /// </summary>
        public static void Initialize(AssemblyEx assembly)
        {
            if (!bLoggerInitialized)
            {
                InitializeLogger();
                bLoggerInitialized = true;
                logger = LogManager.GetCurrentClassLogger();
            }

            //Check whether intialization information is required for this assembly
            var shortname = assembly.ShortName;
            if (DUCoverConstants.SystemAssemblies.Contains(shortname))
                return;

            //Analyzes all classes and methods and collects all entities.
            DeclEntityCollector.CollectAllDeclEntitiesInAssembly(assembly);

            //Populate all Def-Use tables
            PopulateAllDUCoverTables();
        }
        public static bool TryGetTypeExFromName(IPexComponent host, AssemblyEx assembly, string typename, out TypeEx typeEx)
        {
            if(typeExCache.TryGetValue(typename, out typeEx))
                return true;

            typeEx = null;
            foreach (var assemtype in assembly.TypeDefinitions)
            {
                if (assemtype.FullName == typename)
                {
                    typeEx = assemtype.Instantiate(GetGenericTypeParameters(host, assemtype));
                    typeExCache.Add(typename, typeEx);
                    return true;
                }
            }
            return false;
        }
 public override bool TryGetAssemblySetupTeardownMethods(AssemblyEx assembly, out Method setup, out Method teardown)
 {
     setup = teardown = null;
     return false;
 }
 /// <inheritdoc/>
 public override bool TryGetAssemblySetupTeardownMethods(AssemblyEx assembly, out Method setup, out Method teardown)
 {
     // xUnit.net does not have an assembly setup and teardown
     setup = teardown = null;
     return false;
 }
 protected override void Initialize()
 {
     base.Initialize();
     this.currAssembly = this.Services.CurrentAssembly.Assembly.Assembly;
     this.Log.LogMessage("MSeqGenRecommender", "MSeqGenRecommender initialized");
     this.LoadExplorableCandidates();
 }
        /// <summary>
        /// Retrieves the PUT for the method we are looking for in the current assembly
        /// </summary>
        /// <param name="method"></param>
        /// <returns></returns>
        public static bool TryRetrievePUT(IPexComponent host, AssemblyEx assembly, Method method, out Method putmethod)
        {
            //Get the class name of the target class that is including
            //the method we are looking for
            TypeEx declaringType;
            bool bresult = method.TryGetDeclaringType(out declaringType);
            SafeDebug.Assume(bresult, "Failed to get the declaring type!!!");

            string tclassname = null;
            var declaringTypeDef = declaringType.Definition;
            if (declaringTypeDef.GenericTypeParametersCount == 0)
            {
                tclassname = declaringType.ShortName.ToString();
            }
            else
            {
                tclassname = declaringType.ShortName.ToString();
                tclassname = tclassname.Substring(0, tclassname.IndexOf('`'));

                foreach (var param in declaringTypeDef.GenericTypeParameters)
                {
                    tclassname = tclassname + param.Name;
                }
            }
            tclassname = tclassname + "Test";

            foreach (var classdef in assembly.TypeDefinitions)
            {
                if(classdef.ShortName != tclassname)
                    continue;

                //TODO: To be more robust, we can later replace
                //this piece of code by actually checking whether there
                //is a method call to the method of the library we are looking for
                foreach (var mdef in classdef.DeclaredInstanceMethods)
                {
                    if (mdef.ShortName == method.ShortName)
                    {
                        bool isPexMethod = false;
                        foreach (var attr in mdef.DeclaredAttributes)
                        {
                            if (attr.SerializableName.ToString().Contains("PexMethodAttribute"))
                            {
                                isPexMethod = true;
                                break;
                            }
                        }

                        if (isPexMethod)
                        {
                            putmethod = mdef.Instantiate(MethodOrFieldAnalyzer.GetGenericTypeParameters(host, classdef),
                                MethodOrFieldAnalyzer.GetGenericMethodParameters(host, mdef));
                            return true;
                        }
                    }
                }
            }

            putmethod = null;
            return false;
        }