/************************************************************************************************
* All code in this file is under the MS-RL License (https://opensource.org/licenses/MS-RL)      *
* By using the code in this file in any way, you agree to the above license terms.              *
* Copyright (C) LIGHTS IN LINE AB (https://www.lightsinline.se)                                 *
* Repository, Wiki, Issue tracker and more at https://git.lightsinline.se/products/VSTT-Plugins *
*                                                                                               *
* Contributors                                                                                  *
* LIGHTS IN LINE AB                                                                             *
* SWEDBANK AB                                                                                   *
* SKATTEVERKET                                                                                  *
************************************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using Microsoft.VisualStudio.TestTools.WebTesting;
using Microsoft.VisualStudio.TestTools.LoadTesting;
using System.IO;
using System.ComponentModel;
using System.Text.RegularExpressions;
using System.Security.Cryptography.X509Certificates;
using System.Diagnostics;
using System.Collections.Specialized;
using System.Configuration;
using System.Net.Configuration;
using System.Reflection;

namespace LIL_VSTT_Plugins
{
    public class SetWebTestParameter : WebTestPlugin
    {
        // BETA VERY UNTESTED!!

        private string myConnectionString = "";
        private string myLogFileString = "";
        private string myParameterName = "";
        private string myTestNames = "";
        private string myScenarioNames = "";
        private string myAgentNames = "";
        private string myColNames = "";
        private string myDebugLogFile = "";
        private bool myUseRandom = true;
        private bool myUseUnique = false;
        private bool myUseUniqueFiles = false;
        private bool myUseUniqueIteration = false;
        private bool myUseUniqueTestIteration = false;
        private bool myLogToFile = false;
        private bool myLogAppendID = false;
        private bool myLogAppendName = false;
        private bool mySeqLoop = false;
        private bool myHasColName = false;
        private bool myUseAutoSplit = false;
        private bool myIgnoreBlanks = true;
        private bool myDebug = false;

        private int iterationCounter = 0;
        private static bool isParamsLoaded = false;
        private static int globalIterationCounter = 0;
        private static readonly Object globalIterationCounterLock = new Object();

        private static readonly StringCollection myParams = new StringCollection();
        private static readonly Queue<string> myUsedQueue = new Queue<string>();
        private static readonly Queue<string> myUnUsedQueue = new Queue<string>();
        private Random random = new Random();

        #region guiparams

        [Category("Context")]
        [DisplayName("Parameter Namn")]
        [Description("Ange namnet på parametern som vi ska lägga till i TestContext, om det är flera använd CSV format med kommatecken som separator.")]
        [DefaultValue("UserName")]
        public string Parameter_Name
        {
            get { return myParameterName; }
            set { myParameterName = value; }
        }

        [Category("XDebug")]
        [DisplayName("Debug Mode")]
        [Description("Set True in order to enable Debug Mode. Each agent will log debug messages to the given Debug Log File.")]
        [DefaultValue(false)]
        public bool DebugMode
        {
            get { return myDebug; }
            set { myDebug = value; }
        }

        [Category("XDebug")]
        [DisplayName("Debug Log File")]
        [Description("Log file path to be used for debug logging, if enabled (True)")]
        [DefaultValue("C:\\Temp\\SetTestParameterDebug.log")]
        public string DebugLogFile
        {
            get { return myDebugLogFile; }
            set { myDebugLogFile = value; }
        }

        [Category("CSV Testdata")]
        [DisplayName("Filens sökväg")]
        [Description("Ange filens namn om den finns som Deployment Item i dina testsettings, eller fullständig sökväg om den inte deployas. Du kan ange en nätverksmappad disk eller UNC sökväg. Vid lokal sökväg behöver filen finnas på den agent där pluginet körs, vilket är alla agenter om du inte anger undantag.")]
        [DefaultValue("C:\\Userdata.csv")]
        public string Connection_String
        {
            get { return myConnectionString; }
            set { myConnectionString = value; }
        }

        [Category("CSV Testdata")]
        [DisplayName("Filen har kolumner med namn")]
        [Description("Ange om csv filen har rubriker i form av kolumnnamn på första raden. Om du sätter True kommer även kolumnens namn att användas som parameternamn istället.")]
        [DefaultValue(false)]
        public bool Has_col_name
        {
            get { return myHasColName; }
            set { myHasColName = value; }
        }

        [Category("CSV Testdata")]
        [DisplayName("Autosplit per agent")]
        [Description("Ange True om du vill att filen automatiskt ska splittas mellan alla aktiva agenter i testet. Obligatoriskt för att kunna ha unikt testdata över hela ditt loadtest då agenterna inte pratar med varandra under körningen.")]
        [DefaultValue(false)]
        public bool Autosplit
        {
            get { return myUseAutoSplit; }
            set { myUseAutoSplit = value; }
        }

        [Category("CSV Testdata")]
        [DisplayName("Ignorera blankskott")]
        [Description("Ange False om du inte vill att rader med blankskott ignoreras (tomma/blanka rader eller samtliga kolumner tomma/blanka).")]
        [DefaultValue(true)]
        public bool IgnoreBlanks
        {
            get { return myIgnoreBlanks; }
            set { myIgnoreBlanks = value; }
        }

        [Category("Loggning")]
        [DisplayName("Loggfilens namn")]
        [Description("Ange den fullständiga sökvägen till logg filen. Om filen finns kommer den inte skrivas över utan läggas till i slutet.")]
        [DefaultValue("C:\\Temp\\Fungerande.log")]
        public string LogFilePathString
        {
            get { return myLogFileString; }
            set { myLogFileString = value; }
        }

        [Category("Loggning")]
        [DisplayName("Lägg till ID")]
        [Description("Ange True om du vill att Agent ID samt VU ID läggs till automatiskt i slutet på filnamnet.")]
        [DefaultValue(false)]
        public bool LogFileAppendID
        {
            get { return myLogAppendID; }
            set { myLogAppendID = value; }
        }

        [Category("Loggning")]
        [DisplayName("Lägg till Namn")]
        [Description("Ange True om du vill att Scenario Name samt Test Name läggs till automatiskt i slutet på filnamnet.")]
        [DefaultValue(false)]
        public bool LogFileAppendName
        {
            get { return myLogAppendName; }
            set { myLogAppendName = value; }
        }

        [Category("Radmappning")]
        [DisplayName("1: Test Iteration Number")]
        [Description("Varje iteration av ett och samma test på samma Agent, får en ny rad från din fil. Testets iterationsnummer mappas till raderna i din testdatafil. Börjar på 1 på varje Agent. Autosplit fördelar rader mellan agenter.")]
        [DefaultValue(false)]
        public bool Use_UniqueTestIteration
        {
            get { return myUseUniqueTestIteration; }
            set { myUseUniqueTestIteration = value; }
        }
        
        [Category("Radmappning")]
        [DisplayName("2: Total Iteration Number")]
        [Description("Varje iteration av ett test på samma Agent, oavsett test, får en ny rad från din fil. Agentens Globala iterationsnummer mappas till raderna i din testdatafil. Börjar på 1 på varje Agent. Autosplit fördelar rader mellan agenter.")]
        [DefaultValue(false)]
        public bool Use_UniqueIteration
        {
            get { return myUseUniqueIteration; }
            set { myUseUniqueIteration = value; }
        }
        
        [Category("Radmappning")]
        [DisplayName("3: FIFO Kö med Pop/Enqueue")]
        [Description("Varje rad läses in i en kö på agenten. När en VU vill köra ett test får den raden överst i kön. När en VU är klar med iterationen av ett test läggs raden tillbaka sist i kön. Detta säkerställer att du inte behöver fler rader i testdata filen än antalet samtidiga/parallella VU som kör dina tester, även om du har olika testdatafiler för olika tester. Varje agent börjar på rad 1 i filen om du inte använder Autosplit.")]
        [DefaultValue(false)]
        public bool Use_UniqueFiles
        {
            get { return myUseUniqueFiles; }
            set { myUseUniqueFiles = value; }
        }

        [Category("Radmappning")]
        [DisplayName("4: Virtual User ID Number")]
        [Description("Varje ny VU får en egen rad från din fil, och återanvänder denna rad om den kör fler tester/iterationer. Agentens Virtual User ID Number mappas till raderna i din testdatafil. En VU varierar vilka tester den kör i din mix. En ny VU (enligt procent nya VU i run settings) får ett nytt nummer och därmed en ny rad i din fil. Första VU får nummer 1 på varje Agent. Autosplit fördelar rader mellan agenter.")]
        [DefaultValue(false)]
        public bool Use_Unique
        {
            get { return myUseUnique; }
            set { myUseUnique = value; }
        }

        [Category("Radmappning")]
        [DisplayName("5: Slumpmässigt")]
        [Description("Slumpmässigt val av rader i filen. Ingen kontroll eller viss ordning och flera VU kan slumpa fram samma rad.")]
        [DefaultValue(false)]
        public bool Use_Random
        {
            get { return myUseRandom; }
            set { myUseRandom = value; }
        }
        
        [Category("Radmappning")]
        [DisplayName("6: Virtual User Iteration Number")]
        [Description("Varje VU väljer rad baserat på antalet tidigare tester/iterationer den gjort. Varje ny VU börjar på rad 1. Om procent nya VU är 100 används endast rad 1 i alla tester. Observera att en VU som inte är ny kommer att byta mellan olika tester under din körning, om du har flera tester/skript i din mix. Om du använder undantag och flera instanser av detta plugin, kommer vissa rader att hoppas över.")]
        [DefaultValue(true)]
        public bool Use_Seq
        {
            get; set; // Fake. Actually enabled by setting all other options above to false.
        }
        
        [Category("CSV Testdata")]
        [DisplayName("Loopa testdata")]
        [Description("Ange true om du vill börja om från början av testdatafilen när alla används en gång. Gäller alla unik typer utom Push/Pull. Med False på detta val kommer sista raden ges till alla om datat tar slut, eller OutOfTestDataException slängas och loadtestet stoppas om det är aktiverat.")]
        [DefaultValue(false)]
        public bool Use_Loop
        {
            get { return mySeqLoop; }
            set { mySeqLoop = value; }
        }

        [Category("CSV Testdata")]
        [DisplayName("Avbryt med OutOfTestDataException")]
        [Description("Ange true om du vill att ditt loadtest ska stoppas om testdata tar slut (och Sekventiell Loop är satt till false).")]
        [DefaultValue(false)]
        public bool ThrowException
        {
            get; set;
        }

        [Category("Loggning")]
        [DisplayName("Logga fungerande till fil?")]
        [Description("Ange True om du vill att poster vars tester slutar i Pass ska loggas till fil (c:\\fungerande.log). Om filen redan finns läggs de till i slutet.")]
        [DefaultValue(false)]
        public bool Log_To_File
        {
            get { return myLogToFile; }
            set { myLogToFile = value; }
        }

        [Category("Undantag")]
        [DisplayName("Endast dessa Tester")]
        [Description("Denna instans av pluginet körs endast på Tester i test mixen där namnet eller del av namnet för testet finns i denna lista. Lämna blankt för att köra i alla tester.")]
        [DefaultValue("")]
        public string Test_Names
        {
            get { return myTestNames; }
            set { myTestNames = value; }
        }

        [Category("Undantag")]
        [DisplayName("Endast dessa Scenarios")]
        [Description("Denna instans av pluginet körs endast på Scenarion där namnet eller del av namnet för scenariot finns i denna lista. Lämna blankt för att köra i alla scenarion.")]
        [DefaultValue("")]
        public string Scenario_Names
        {
            get { return myScenarioNames; }
            set { myScenarioNames = value; }
        }

        [Category("Undantag")]
        [DisplayName("Endast dessa Agenter")]
        [Description("Denna instans av pluginet körs endast på Agenter där namnet eller del av namnet för agenten finns i denna lista. Lämna blankt för att köra på alla agenter.")]
        [DefaultValue("")]
        public string Agent_Names
        {
            get { return myAgentNames; }
            set { myAgentNames = value; }
        }

        #endregion

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            base.PreWebTest(sender, e);
            
            // Only run on specific agents if specified
            if (myAgentNames.Length > 0 && !myAgentNames.ToLower().Contains(e.WebTest.Context.AgentName.ToLower())) return;

            // Update the global iteration Counter
            lock (globalIterationCounterLock) globalIterationCounter++;

            // Update the local (this users or instance) iteration counter
            iterationCounter++;

            // Read the values into the param array if not already done (checks isParamsLoaded)
            this.initUserArray(myConnectionString, e.WebTest.Context.AgentCount, e.WebTest.Context.AgentId);

            // If we do have params in the array, select one as specified by the properties
            if (myParams.Count > 0 || myUnUsedQueue.Count > 0)
            {
                if (myUseUniqueTestIteration)
                    loadTestStartingUniqueTestIteration(e.WebTest);
                else if (myUseUniqueIteration)
                    loadTestStartingUniqueIteration(e.WebTest);
                else if (myUseUniqueFiles)
                    loadTestStartingUniqueFiles(e.WebTest);
                else if (myUseUnique)
                    loadTestStartingUnique(e.WebTest);
                else if (myUseRandom)
                    loadTestStartingRandom(e.WebTest);
                else
                    loadTestStartingSeq(e.WebTest);
            }
        }

        public override void PostWebTest(object sender, PostWebTestEventArgs e)
        {
            base.PostWebTest(sender, e);

            if(myUseUniqueFiles)
                loadTestFinishedUniqueFiles(e.WebTest);
            
            if (myLogToFile)
                loadTestEndLogger(e.WebTest);
        }

        void loadTestEndLogger(WebTest e)
        {
            // Log the user to logfile if the test is passed
            if (e.Outcome == Outcome.Pass)
            {
                string fileName = myLogFileString;
                if (myLogAppendID) fileName = fileName + "." + e.Context.AgentName + ".Vu" + e.Context.WebTestUserId;
                if (myLogAppendName) fileName = fileName + "." + e.Name;
                string[] allNames;
                if (myHasColName) allNames = myColNames.Split(','); else allNames = myParameterName.Split(',');
                string row = "";
                foreach (string name in allNames)
                {
                    if (e.Context.Keys.Contains(name))
                    {
                        if (row.Length == 0)
                            row += e.Context[name];
                        else
                            row += "," + e.Context[name];
                    }
                }
                File.AppendAllText(fileName + ".csv", row + "\r\n");
            }
        }

        void loadTestStartingRandom(WebTest e)
        {
            setParameters(this.getRandomUser(), e);
        }

        void loadTestStartingSeq(WebTest e)
        {
            setParameters(this.getSeqUser(iterationCounter), e);
        }

        void loadTestStartingUniqueFiles(WebTest e)
        {
            string strParams = "OutOfData";
            // Go single threaded
            lock (myUnUsedQueue)
            {
                if (myUnUsedQueue.Count > 0)
                {
                    strParams = myUnUsedQueue.Dequeue();
                    e.Context["QueueVal"] = strParams;
                }
                else
                {
                    // Out of testdata
                    e.Context["QueueVal"] = null;
                    stopAndThrow();
                }
            }
            setParameters(strParams, e);
            if (myDebug) lock (myDebugLogFile) { File.AppendAllText(myDebugLogFile, DateTime.Now.ToLocalTime() + " File: " + myConnectionString + " Test: " + e.Name + " VU: " + e.Context.WebTestUserId + " Value: \"" + strParams + "\" PULL\r\n"); }
        }

        void loadTestFinishedUniqueFiles(WebTest e)
        {
            String queueVal = (String)e.Context["QueueVal"];
            if (queueVal != null)
                lock (myUnUsedQueue)
                {
                    myUnUsedQueue.Enqueue(queueVal);
                }
            if (myDebug) lock (myDebugLogFile) { File.AppendAllText(myDebugLogFile, DateTime.Now.ToLocalTime() + " File: " + myConnectionString + " Test: " + e.Name + " VU: " + e.Context.WebTestUserId + " Value: \"" + queueVal + "\" PUSH\r\n"); }
        }

        void loadTestStartingUnique(WebTest e)
        {
            setParameters(this.getSeqUser(e.Context.WebTestUserId), e);
        }

        void loadTestStartingUniqueIteration(WebTest e)
        {
            setParameters(this.getSeqUser(globalIterationCounter), e);
        }

        void loadTestStartingUniqueTestIteration(WebTest e)
        {
            int testIteration = e.Context.WebTestIteration;
            setParameters(this.getSeqUser(testIteration - 1), e);
        }

        void setParameters(string user, WebTest e)
        {
            // Add context parameters to the starting test
            int numParams = 1;
            if (myHasColName == true && myColNames.Contains(',')) numParams = countColumns(myColNames);
            if (myHasColName == false && myParameterName.Contains(',')) numParams = countColumns(myParameterName);

            string[] allParams = user.Split(',');
            string[] allNames;
            if (myHasColName) allNames = myColNames.Split(','); else allNames = myParameterName.Split(',');
            for (int i = 0; i < numParams; i++)
            {
                e.Context[allNames[i]] = allParams[i];
            }
        }

        int countColumns(string input)
        {
            int count = 1;
            for (int i = 0; i < input.Length; i++)
            {
                if (input[i] == ',') count++;
            }
            return count;
        }

        string getRandomUser()
        {
            int randomIndex = random.Next(myParams.Count - 1);
            return myParams[randomIndex];
        }

        string getSeqUser(int seqIndex)
        {
            if (seqIndex < myParams.Count)
                return myParams[seqIndex];
            else
            {
                if (mySeqLoop)
                    return myParams[seqIndex % myParams.Count];
                else
                {
                    // Handle out of testdata here
                    if (ThrowException)
                    {
                        stopAndThrow();
                        return "OutOfData";
                    }
                    else return myParams[myParams.Count - 1];
                }
            }
        }

        void stopAndThrow()
        {
            throw new Exception("Out of Test Data");
        }

        bool initUserArray(string path, int agentCount, int agentId)
        {
            // Check if someone has loaded the params array
            if (isParamsLoaded == false)
            {
                // Try to lock the array
                lock (myParams)
                {
                    // Only read the file if we have a path and we still have not loaded a file now that we have the lock
                    if (!String.IsNullOrEmpty(path) && !isParamsLoaded)
                    {
                        StreamReader re = new StreamReader(path, System.Text.Encoding.Default);
                        string input = null;
                        int lineNum = 0;
                        int dataNum = 0;
                        char[] trim = { ' ', '\x00', '\t', '\x20' };
                        while ((input = re.ReadLine()) != null)
                        {
                            // Ignore blank lines and empty lines (just whitespace) or lines with only blank/empty/whitespace columns
                            if (myIgnoreBlanks && String.IsNullOrWhiteSpace(input.Replace(',', ' '))) continue;

                            lineNum++;
                            if (lineNum == 1 && myHasColName == true)
                            {
                                // First line is column names
                                myColNames = input.TrimEnd(trim);
                            }
                            else
                            {
                                if (myUseAutoSplit)
                                {
                                    int ifAgentId = 0;
                                    if (dataNum >= agentCount) ifAgentId = (dataNum % agentCount) + 1;
                                    else ifAgentId = dataNum + 1;
                                    if (ifAgentId == agentId)
                                    {
                                        if (myUseUniqueFiles) myUnUsedQueue.Enqueue(input.TrimEnd(trim));
                                        else myParams.Add(input.TrimEnd(trim));
                                    }
                                    dataNum++;
                                }
                                else
                                {
                                    if (myUseUniqueFiles) myUnUsedQueue.Enqueue(input.TrimEnd(trim));
                                    else myParams.Add(input.TrimEnd(trim));
                                }
                            }
                        }
                        re.Close();
                        // Let the world know we have read the file before we release the lock
                        isParamsLoaded = true;
                        return true;
                    }
                }
            }
            // If we get here, we did not return in any of the loading parts above. Return false to indicate we did not load the file.
            return false;
        }
    }

    /// <summary>
    /// Datasource Unique Once
    /// </summary>
    [DisplayName("Datasource Unique Once")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nOBS! Läs hela! Styr datasource selection till att endast göras en gång per VU. Du måste ändra i din datasource Access Metod till Do Not Move Automatically! WebTestUserId används för att välja rad. Använder de datasources som finns definerade i webtestet. Använd test mix based on users starting tests samt 0 percent new users.")]
    public class UniqueOnce : WebTestPlugin
    {
        string dataSourceName;
        string dataTableName;
        int offset;

        [DisplayName("Datakällans namn")]
        [Description("Ange namnet på datakällan i ditt webtest, tex DataSource1")]
        [DefaultValue("DataSource1")]
        public string DataSourceName
        {
            get { return dataSourceName; }
            set { dataSourceName = value; }
        }

        [DisplayName("Tabellens namn")]
        [Description("Ange namnet på den tabell som ska användas, tex Userdata#csv")]
        public string DataSourceTableName
        {
            get { return dataTableName; }
            set { dataTableName = value; }
        }

        [DisplayName("Offset")]
        [Description("Används för att hoppa över ett visst antal rader från början på datakällan så de inte används.")]
        [DefaultValue(0)]
        public int Offset
        {
            get { return offset; }
            set { offset = value; }
        }

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            base.PreWebTest(sender, e);
            int index = e.WebTest.Context.WebTestUserId + offset;
            e.WebTest.MoveDataTableCursor(dataSourceName, dataTableName, index);
            e.WebTest.AddCommentToResult("Selected row number " + index + " from datasource " + dataSourceName + " and table " + dataTableName + ".");
        }
    }

    /// <summary>
    /// Filtrar bort oönskade objekt från sidor.
    /// Samtliga objekt vars URL börjar med den angivna strängen kommer ignoreras och inte laddas ner.
    /// </summary>
    [DisplayName("Dynamisk URL Regex filter")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nFilter för att ignorera vissa objekt på websidor så de inte laddas ner automatiskt.")]
    public class WebTestDependentRegexFilter : WebTestPlugin
    {
        string m_regex;
        bool m_exclude = true;

        /// <summary>
        /// Fullständig URL (inkl http://) som börjar med FilterString kommer att ignoreras.

        [DisplayName("RegEx")]
        [Description("Dynamiska (dependent) request kommer att filtreras om de matchar detta uttryck.\r\nTex: www.adsite.com eller *.png")]
        public string FilterString
        {
            get { return m_regex; }
            set { m_regex = value; }
        }

        [DisplayName("Exclude")]
        [DefaultValue(true)]
        [Description("Om satt till true kommer matchande requests att tas bort/exkluderas. Om satt till false kommer alla request utom de som matchar att tas bort/exkluderas")]
        public bool Exclude
        {
            get { return m_exclude; }
            set { m_exclude = value; }
        }

        public override void PostRequest(object sender, PostRequestEventArgs e)
        {
            if (!string.IsNullOrEmpty(m_regex))
            {
                WebTestRequestCollection depsToRemove = new WebTestRequestCollection();
                Regex regex = new Regex(m_regex);

                foreach (WebTestRequest r in e.Request.DependentRequests)
                {
                    // Disable parsing on dependents since we cannot filter those
                    r.ParseDependentRequests = false;
                    if (m_exclude)
                    {
                        if (regex.IsMatch(r.Url))
                        {
                            depsToRemove.Add(r);
                        }
                    }
                    else
                    {
                        if (!regex.IsMatch(r.Url))
                        {
                            depsToRemove.Add(r);
                        }
                    }
                }
                foreach (WebTestRequest r in depsToRemove)
                {
                    e.Request.DependentRequests.Remove(r);
                }
            }
        }
    }

    /// <summary>
    /// Filtrar bort oönskade objekt från sidor.
    /// Samtliga objekt vars URL börjar med den angivna strängen kommer ignoreras och inte laddas ner.
    /// </summary>
    [DisplayName("Dynamisk URL exclude filter")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nFilter för att ignorera vissa objekt på websidor så de inte laddas ner automatiskt.")]
    public class WebTestDependentFilter : WebTestPlugin
    {
        string m_startsWith;

        /// <summary>
        /// Fullständig URL (inkl http://) som börjar med FilterString kommer att ignoreras.
        
        [DisplayName("URL börjar med")]
        [Description("Dynamiska (dependent) objekt som hittas kommer endast att laddas ner om de INTE börjar med denna sträng.\r\nTex: https://www.excludedsite.com")]
        public string FilterString
        {
            get { return m_startsWith; }
            set { m_startsWith = value; }
        }
        
        public override void PostRequest(object sender, PostRequestEventArgs e)
        {
            WebTestRequestCollection depsToRemove = new WebTestRequestCollection();
            Boolean hasRun = false;

            foreach (WebTestRequest r in e.Request.DependentRequests)
            {
                // Disable parsing on dependents since we cannot filter those
                r.ParseDependentRequests = false;
                if (!string.IsNullOrEmpty(m_startsWith) &&
                    r.Url.StartsWith(m_startsWith))
                {
                    depsToRemove.Add(r);
                    hasRun = true;
                }
            }
            foreach (WebTestRequest r in depsToRemove)
            {
                e.Request.DependentRequests.Remove(r);
            }

            if (hasRun)
            {
                //e.WebTest.AddCommentToResult("WebTestDependentFilter has run");
            }
        }
    }

    /// <summary>
    /// Filtrar bort oönskade objekt från sidor.
    /// Samtliga objekt vars URL börjar med den angivna strängen kommer ignoreras och inte laddas ner.
    /// </summary>
    [DisplayName("Dynamisk URL include filter")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nFilter för att ignorera vissa objekt på websidor så de inte laddas ner automatiskt.")]
    public class WebTestDependentIncludeFilter : WebTestPlugin
    {
        string m_startsWith;

        /// <summary>
        /// Fullständig URL (inkl http://) som börjar med FilterString kommer att ignoreras.

        [DisplayName("URL börjar med")]
        [Description("Alla dynamiska (dependent) objekt som hittas kommer endast att laddas ner OM DE BÖRJAR med denna sträng.\r\nTex: https://www.onlythissite.com")]
        public string FilterString
        {
            get { return m_startsWith; }
            set { m_startsWith = value; }
        }

        public override void PostRequest(object sender, PostRequestEventArgs e)
        {
            WebTestRequestCollection depsToRemove = new WebTestRequestCollection();
            Boolean hasRun = false;

            foreach (WebTestRequest r in e.Request.DependentRequests)
            {
                // Disable parsing on dependents since we cannot filter those
                r.ParseDependentRequests = false;
                if (!string.IsNullOrEmpty(m_startsWith) &&
                    !r.Url.StartsWith(m_startsWith))
                {
                    depsToRemove.Add(r);
                    hasRun = true;
                }
            }
            foreach (WebTestRequest r in depsToRemove)
            {
                e.Request.DependentRequests.Remove(r);
            }

            if (hasRun)
            {
                //e.WebTest.AddCommentToResult("WebTestDependentFilter has run");
            }
        }
    }

    /// <summary>
    /// Slå på URL encode på query string parametrar
    /// </summary>
    [DisplayName("URL Encode Query String Parameter")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nTvingar en URL Encode på angiven Query String parameter i alla request")]
    public class URLEncodeQueryStringParameter : WebTestPlugin
    {
        [DisplayName("Query String Parameter Name")]
        [Description("Name of the query string parameter to URL encode before each request")]
        public String paramName { get; set; }
        public override void PreRequest(object sender, PreRequestEventArgs e)
        {
            if (e.Request.HasQueryStringParameters)
            {
                if (e.Request.QueryStringParameters.Contains(paramName))
                {
                    foreach (QueryStringParameter qsp in e.Request.QueryStringParameters) {
                        if (qsp.Name.Equals(paramName))
                        {
                            qsp.UrlEncode = true;
                        }
                    }
                }
            }
        }
    }

    /// <summary>
    /// Loggar alla transaktioners svarstider som context parametrar
    /// </summary>
    [DisplayName("Transaction Response Times to Context")]
    [Description("(C) Copyright 2016 LIGHTS IN LINE AB\r\nLoggar alla transaktioners svarstider som context parametrar")]
    public class TransactionsToContext : WebTestPlugin
    {
        public override void PostTransaction(object sender, PostTransactionEventArgs e)
        {
            base.PostTransaction(sender, e);
            if (!e.WebTest.Context.ContainsKey(e.TransactionName))
            {
                e.WebTest.Context.Add(e.TransactionName, e.Duration.TotalMilliseconds.ToString());
            }
            else
            {
                e.WebTest.Context[e.TransactionName] = e.Duration.TotalMilliseconds.ToString();
            }
        }
    }

    /// <summary>
    /// Loggar alla transaktioners svarstider som context parametrar
    /// </summary>
    [DisplayName("Set Test Info As Header")]
    [Description("(C) Copyright 2017 LIGHTS IN LINE AB\r\nAdds name information from transactions, pages, tests into a header in requests so that it can be used to group upon in tools like AppDynamics, DynaTrace, etc.")]
    public class SetTestInfoAsHeader : WebTestPlugin
    {
        [DisplayName("Header Prefix")]
        [Description("Prefix of the header to be added on requests")]
        [DefaultValue("X-Sipoz")]
        public String HeaderName { get; set; }

        [DisplayName("Tests")]
        [Description("Add the Test name as a header with <prefix>-TestName")]
        [DefaultValue(true)]
        public bool onTransaction { get; set; }

        [DisplayName("Transactions")]
        [Description("Add the transaction name as a header with <prefix>-TransactionName")]
        [DefaultValue(true)]
        public bool onTest { get; set; }

        List<String> transactionPath = new List<string>();

        public override void PreRequest(object sender, PreRequestEventArgs e)
        {
            base.PreRequest(sender, e);
            if (onTest) e.Request.Headers.Add(HeaderName + "-TestName", e.WebTest.Name);
            if (onTransaction && transactionPath.Count > 0)
            {
                String value = String.Empty;
                foreach (string trans in transactionPath) {
                    if (value.Equals(String.Empty)) value = trans;
                    else value += "." + trans;
                }
                e.Request.Headers.Add(HeaderName + "-TransactionName", value);
            }
        }

        public override void PreTransaction(object sender, PreTransactionEventArgs e)
        {
            base.PreTransaction(sender, e);
            transactionPath.Add(e.TransactionName);
        }

        public override void PostTransaction(object sender, PostTransactionEventArgs e)
        {
            base.PostTransaction(sender, e);
            transactionPath.Remove(e.TransactionName);
        }
    }

    /// <summary>
    /// Ignorerar status koder under 500.
    /// </summary>
    [DisplayName("Ignore 4xx status codes")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nDetta plugin ändrar alla request så de inte går fel på grund av 4xx status koder i svaret samt ignorerar statuskoden helt på alla dependent requests")]
    public class WebTestIgnore4xx : WebTestPlugin
    {
        public override void PostRequest(object sender, PostRequestEventArgs e)
        {
            
            if (e.ResponseExists && (int)e.Response.StatusCode >= 500) e.Request.Outcome = Outcome.Fail;

            foreach (WebTestRequest r in e.Request.DependentRequests)
            {
                r.IgnoreHttpStatusCode = true;
            }
        }
       
        public override void PreRequest(object sender, PreRequestEventArgs e)
        {
            e.Request.IgnoreHttpStatusCode = true;
        }
    }

    /// <summary>
    /// Ignorerar status koder under 500.
    /// </summary>
    [DisplayName("Ignore Dependent Results")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nDependent requests kommer laddas ner men ej mätas individuellt. Alla kommer enbart mätas gemensamt som [dependent]")]
    public class WebTestIgnoreDependentResults : WebTestPlugin
    {
        public override void PostRequest(object sender, PostRequestEventArgs e)
        {
            foreach (WebTestRequest r in e.Request.DependentRequests)
            {
                r.ReportingName = "[dependent request]";
            }
        }
    }

    /// <summary>
    /// Sätter Reporting name
    /// </summary>
    [DisplayName("Report Name Automator")]
    [Description("(C) Copyright 2017 LIGHTS IN LINE AB\r\nSätter automatiskt Reporting Name på requests")]
    public class WebTestReportingNameAutomator : WebTestPlugin
    {
        [DisplayName("Use RegEx with group")]
        [Description("Will use the Set To Name as a regular expression with a group and use the matching group result as the Reporting Name. If no match, reporting name will not be set to \"no-match\"")]
        [DefaultValue(false)]
        public bool useRegGroup { get; set; }

        [DisplayName("Run on Dependents")]
        [Description("If set to true will run on dependents")]
        [DefaultValue(false)]
        public bool runOnDependents { get; set; }

        [DisplayName("Run on Requests")]
        [Description("If set to true will run on requests (default)")]
        [DefaultValue(true)]
        public bool runOnRequests { get; set; }

        [DisplayName("Set to Name")]
        [Description("The name to be set or the regular expression to be used. Groups are specified within () like (.+?) would match the shortest possible string")]
        [DefaultValue(false)]
        public string reportingName { get; set; }

        private Regex regex = null;
        public override void PostRequest(object sender, PostRequestEventArgs e)
        {
            if(runOnDependents)
                foreach (WebTestRequest r in e.Request.DependentRequests)
                {
                    r.ReportingName = getNameToSet(r.Url);
                }
        }

        public override void PreRequest(object sender, PreRequestEventArgs e)
        {
            if (runOnRequests)
                e.Request.ReportingName = getNameToSet(e.Request.Url);
        }

        private void createRegExOnce() {
            if(regex == null) {
                regex = new Regex(reportingName);
            }
        }

        private string getNameToSet(string input) {
            string result = "no-match";
            if (useRegGroup == false)
                result = reportingName;
            else
            {
                createRegExOnce();
                Match m = regex.Match(input);
                if (m.Success && m.Groups.Count > 0)
                {
                    result = m.Groups[0].Value;
                }
            }
            return result;
        }
    }

    /// <summary>
    /// Service Manager Plugin
    /// </summary>
    [DisplayName("Service Manager Config")]
    [Description("(C) Copyright 2015 LIGHTS IN LINE AB\r\nSätter config värden i Service Manager instansen för hela testet, finns även som loadtest plugin och gäller då hela loadtestet.")]
    public class ServiceManagerWebTestPlugin : WebTestPlugin
    {
        static bool unsafeHeadersSet = false;

        [DisplayName("Use Expect 100 Behaviour"), DefaultValue(false)]
        [Description("Default i .NET är att detta är påslaget, default i webbläsare är dock att detta inte är påslaget. Detta plugin stänger default därför av detta (false).")]
        public bool exp100 { get; set; }

        [DisplayName("Max Connection Idle Time (s)"), DefaultValue(100)]
        [Description("Anger hur länge connections får ligga kvar i poolen innan de aktivt stängs ner. VS default är 100 sekunder men många webbservrar stänger ner tidigare utan att meddela klienten, vilket ger felmeddelanden under loadtests av typen att en connection oväntat stängts ner.")]
        public int maxIdle { get; set; }

        [DisplayName("TCP Keep Alive"), DefaultValue(false)]
        [Description("Keepalive på TCP nivå är default avstängt både i webbläsare och i .NET men vissa rika/feta klienter kan slå på detta, tex webservice klienter")]
        public bool keepAlive { get; set; }

        [DisplayName("TCP Keep Alive Timeout (ms)"), DefaultValue(5000)]
        public int timeOut { get; set; }

        [DisplayName("TCP Keep Alive Interval"), DefaultValue(1000)]
        public int interVal { get; set; }

        [DisplayName("Use Nagle Algorithm"), DefaultValue(false)]
        [Description("Buffring av paket på TCP nivå, är normalt sätt inte påslaget för HTTP men för tex SSH eller Telnet. Buffrar små paket och slår ihop dem till större för att minska antalet paket på långsamma nätverk.")]
        public bool useNagle { get; set; }

        [DisplayName("Force TLS 1.2"), DefaultValue(false)]
        [Description("Default inte påslaget. Om servern inte stödjer TLS1.2 kommer SSL handskakningen att avbrytas och requestet failar. Kräver .NET 4.5 samt att TLS1.2 är aktiverat i SChannel (använd bifogad schannel_high.reg om det inte är påslaget på äldre windows versioner)")]
        public bool useTls12 { get; set; }

        [DisplayName("Apply Override"), DefaultValue(false)]
        [Description("Ändrar proxy inställningarna för detta webtest enligt detta plugin")]
        [Category("Web Proxy")]
        public bool proxyOverride { get; set; }

        [DisplayName("Proxy URI"), DefaultValue("http://host:port")]
        [Description("Anger proxyserverns URI (http://host:port)")]
        [Category("Web Proxy")]
        public string proxyURI { get; set; }

        [DisplayName("Bypass Local"), DefaultValue(false)]
        [Description("True för att inte använda proxy på lokala hostnamn, i.e. utan domännamn")]
        [Category("Web Proxy")]
        public bool proxyBypassLocal { get; set; }

        [DisplayName("Bypass RegExp"), DefaultValue("")]
        [Description("Sätter ett reguljärt uttryck för URI (hostnamn) som INTE ska gå via proxyn")]
        [Category("Web Proxy")]
        public string proxyBypass { get; set; }

        [DisplayName("User Name"), DefaultValue("")]
        [Description("Sätter användarnamn för proxyn")]
        [Category("Web Proxy")]
        public string proxyUser { get; set; }

        [DisplayName("User Password"), DefaultValue("")]
        [Description("Sätter lösenordet för användarnamnet för proxyn")]
        [Category("Web Proxy")]
        public string proxyPass { get; set; }

        [DisplayName("Use Unsafe Header Parsing"), DefaultValue(false)]
        [Description("Enables unsafe parsing of response headers")]
        public bool unsafeHeaders { get; set; }

        System.Net.WebProxy myProxy = null;

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            base.PreWebTest(sender, e);

            if (proxyOverride)
            {
                if (myProxy == null)
                {
                    myProxy = new System.Net.WebProxy();
                    if(!String.IsNullOrWhiteSpace(proxyURI)) myProxy.Address = new Uri(proxyURI);
                    myProxy.BypassProxyOnLocal = proxyBypassLocal;
                    if (!String.IsNullOrWhiteSpace(proxyBypass)) myProxy.BypassList = new string[] { proxyBypass };
                    if (!String.IsNullOrWhiteSpace(proxyUser)) myProxy.Credentials = new System.Net.NetworkCredential(proxyUser, proxyPass);
                }
                // Change the webtests proxy setting
                e.WebTest.Proxy = "lil";
                e.WebTest.WebProxy = myProxy;
                // Set context parameters
                e.WebTest.Context["proxyOverride"] = proxyOverride;
                e.WebTest.Context["proxyURI"] = proxyURI;
                e.WebTest.Context["proxyBypassLocal"] = proxyBypassLocal;
                e.WebTest.Context["proxyBypass"] = proxyBypass;
                e.WebTest.Context["proxyUser"] = proxyUser;
                e.WebTest.Context["proxyPass"] = proxyPass;
            }

            System.Net.ServicePointManager.Expect100Continue = exp100;
            System.Net.ServicePointManager.MaxServicePointIdleTime = maxIdle;
            System.Net.ServicePointManager.SetTcpKeepAlive(keepAlive, timeOut, interVal);
            System.Net.ServicePointManager.UseNagleAlgorithm = useNagle;

            if (useTls12) System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12;
            if (unsafeHeaders && !unsafeHeadersSet)
            {
                ToggleAllowUnsafeHeaderParsing(true);
                unsafeHeadersSet = true;
            }
        }

        public static bool ToggleAllowUnsafeHeaderParsing(bool enable)
        {
            //Get the assembly that contains the internal class
            Assembly assembly = Assembly.GetAssembly(typeof(SettingsSection));
            if (assembly != null)
            {
                //Use the assembly in order to get the internal type for the internal class
                Type settingsSectionType = assembly.GetType("System.Net.Configuration.SettingsSectionInternal");
                if (settingsSectionType != null)
                {
                    //Use the internal static property to get an instance of the internal settings class.
                    //If the static instance isn't created already invoking the property will create it for us.
                    object anInstance = settingsSectionType.InvokeMember("Section",
                    BindingFlags.Static | BindingFlags.GetProperty | BindingFlags.NonPublic, null, null, new object[] { });
                    if (anInstance != null)
                    {
                        //Locate the private bool field that tells the framework if unsafe header parsing is allowed
                        FieldInfo aUseUnsafeHeaderParsing = settingsSectionType.GetField("useUnsafeHeaderParsing", BindingFlags.NonPublic | BindingFlags.Instance);
                        if (aUseUnsafeHeaderParsing != null)
                        {
                            aUseUnsafeHeaderParsing.SetValue(anInstance, enable);
                            return true;
                        }

                    }
                }
            }
            return false;
        }
    }

    /// <summary>
    /// WebTest Plugin Template
    /// </summary>
    [DisplayName("Randomize each page")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nVäljer en ny slumpmässig rad i din datasource vid varje sida/page i skriptet.")]
    public class randomOnEachPage : WebTestPlugin
    {
        string dataSourceName;
        string dataTableName;
        int datasourceSize = 0;
        Random RandomNumber = new Random(System.DateTime.Now.Millisecond);

        [DisplayName("Datakällans namn")]
        [Description("Ange namnet på datakällan i ditt webtest, tex DataSource1")]
        [DefaultValue("DataSource1")]
        public string DataSourceName
        {
            get { return dataSourceName; }
            set { dataSourceName = value; }
        }

        [DisplayName("Tabellens namn")]
        [Description("Ange namnet på den tabell som ska användas, tex Userdata#csv")]
        public string DataSourceTableName
        {
            get { return dataTableName; }
            set { dataTableName = value; }
        }

        public override void PrePage(object sender, PrePageEventArgs e)
        {
            base.PrePage(sender, e);
            if (datasourceSize == 0) {
                int size = e.WebTest.GetDataTableRowCount(dataSourceName, dataTableName);
                if(size > 0) 
                    datasourceSize = size;
                else
                    return;
            }
            if (datasourceSize > 0)
            {
                int index = RandomNumber.Next(0, datasourceSize - 1);
                e.WebTest.MoveDataTableCursor(dataSourceName, dataTableName, index);
                //e.WebTest.AddCommentToResult("Selected row number " + index + " from datasource " + dataSourceName + " and table " + dataTableName + ".");
            }
        }
    }

    ///<summary>
    ///WebTest Plugin Data Generator
    ///</summary>
    [DisplayName("Data Generator Integer")]
    [Description("(C) Copyright 2016 LIGHTS IN LINE AB\r\nGenererar en slumpad integer som context parameter")]
    public class dataGenInteger : WebTestPlugin
    {
        Random RandomNumber = new Random(System.DateTime.Now.Millisecond);

        private string paramName;
        [DisplayName("Parameter namn")]
        [Description("Ange namnet på parametern i ditt webtest, tex IntParameter1")]
        [DefaultValue("IntegerParameter1")]
        public string ParamNameVal
        {
            get { return paramName; }
            set { paramName = value; }
        }

        private int intMin;
        [DisplayName("Integer Min")]
        [Description("Ange minsta värdet för parametern i ditt webtest, tex 0")]
        [DefaultValue(0)]
        public int IntegerMin
        {
            get { return intMin; }
            set { intMin = value; }
        }

        private int intMax;
        [DisplayName("Integer Max")]
        [Description("Ange högsta värdet för parametern i ditt webtest, tex 100")]
        [DefaultValue(100)]
        public int IntegerMax
        {
            get { return intMax; }
            set { intMax = value; }
        }

        private bool prePage = false;
        [DisplayName("Uppdatera på varje Page")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje ny sida som laddas i testet.")]
        [DefaultValue(false)]
        public bool PrePageVal
        {
            get { return prePage; }
            set { prePage = value; }
        }

        private bool preTrans = false;
        [DisplayName("Uppdatera på varje Transaktion")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje ny transaktion i testet.")]
        [DefaultValue(false)]
        public bool PreTransactionVal
        {
            get { return preTrans; }
            set { preTrans = value; }
        }

        private bool preReq = false;
        [DisplayName("Uppdatera på varje Request")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje nytt request i testet.")]
        [DefaultValue(false)]
        public bool PreRequestVal
        {
            get { return preReq; }
            set { preReq = value; }
        }

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            update(e.WebTest.Context);
            base.PreWebTest(sender, e);
        }

        public override void PrePage(object sender, PrePageEventArgs e)
        {
            if (prePage) update(e.WebTest.Context);
            base.PrePage(sender, e);
        }

        public override void PreRequestDataBinding(object sender, PreRequestDataBindingEventArgs e)
        {
            if (preReq) update(e.WebTest.Context);
            base.PreRequestDataBinding(sender, e);
        }

        public override void PreTransaction(object sender, PreTransactionEventArgs e)
        {
            if (preTrans) update(e.WebTest.Context);
            base.PreTransaction(sender, e);
        }

        private void update(WebTestContext context)
        {
            context[paramName] = RandomNumber.Next(intMin, intMax);
        }
    }

    ///<summary>
    ///WebTest Plugin Data Generator
    ///</summary>
    [DisplayName("Data Generator Timestamp")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nGenererar en timestamp som context parameter")]
    public class dataGenTimestamp : WebTestPlugin
    {
        private string paramName;
        [DisplayName("Parameter namn")]
        [Description("Ange namnet på parametern i ditt webtest, tex TimeStampParameter1")]
        [DefaultValue("TimeStampParameter1")]
        public string ParamNameVal
        {
            get { return paramName; }
            set { paramName = value; }
        }

        private bool millis = false;
        [DisplayName("Använd millisekunder")]
        [Description("Sätt till true om du vill ha värdet i millisekunder istället för sekunder.")]
        [DefaultValue(false)]
        public bool MillisecondsVal
        {
            get { return millis; }
            set { millis = value; }
        }

        private bool prePage = false;
        [DisplayName("Uppdatera på varje Page")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje ny sida som laddas i testet.")]
        [DefaultValue(false)]
        public bool PrePageVal
        {
            get { return prePage; }
            set { prePage = value; }
        }

        private bool preTrans = false;
        [DisplayName("Uppdatera på varje Transaktion")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje ny transaktion i testet.")]
        [DefaultValue(false)]
        public bool PreTransactionVal
        {
            get { return preTrans; }
            set { preTrans = value; }
        }

        private bool preReq = false;
        [DisplayName("Uppdatera på varje Request")]
        [Description("Sätt till true om du vill ha värdet uppdaterat inför varje nytt request i testet.")]
        [DefaultValue(false)]
        public bool PreRequestVal
        {
            get { return preReq; }
            set { preReq = value; }
        }

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            update(e.WebTest.Context);
            base.PreWebTest(sender, e);
        }

        public override void PrePage(object sender, PrePageEventArgs e)
        {
            if (prePage) update(e.WebTest.Context);
            base.PrePage(sender, e);
        }

        public override void PreRequestDataBinding(object sender, PreRequestDataBindingEventArgs e)
        {
            if (preReq) update(e.WebTest.Context);
            base.PreRequestDataBinding(sender, e);
        }

        public override void PreTransaction(object sender, PreTransactionEventArgs e)
        {
            if (preTrans) update(e.WebTest.Context);
            base.PreTransaction(sender, e);
        }

        private void update(WebTestContext context)
        {
            TimeSpan span = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc));
            if (millis) context[paramName] = ((Int64) span.TotalMilliseconds).ToString();
            else context[paramName] = ((Int64) span.TotalSeconds).ToString();
        }
    }

    /// <summary>
    /// WebTest Client Certificate
    /// </summary>
    [DisplayName("Client Certificate")]
    [Description("(C) Copyright 2016 LIGHTS IN LINE AB\r\nSätter webtestet att använda ett specifikt client cert för SSL. Certifikatet installeras automatiskt i Windows User Certificate Store.")]
    public class ClientCertificatePlugin : WebTestPlugin
    {
        [DisplayName("Certificate Path")]
        [Description("Sökvägen till certifikatfilen (P12/PFX/PEM med privat nyckel eller CER/DER utan privat nyckel)")]
        [DefaultValue("")]
        public string pCertificatePath { get; set; }

        [DisplayName("Certificate Path Parameter")]
        [Description("Ange namn på parameter som ska användas för sökvägen till certifikatfilen. Om parametern saknas eller är tom används Certificate Path")]
        [DefaultValue("")]
        public string pCertificatePathParameter { get; set; }

        [DisplayName("Certificate Password")]
        [Description("Ange lösenordet för att öppna skyddade/krypterade filer")]
        [DefaultValue("")]
        public string pCertificatePassword { get; set; }

        [DisplayName("Certificate Password Parameter")]
        [Description("Ange namn på parameter som ska användas för lösenordet till certifikatfilen. Om parametern saknas eller är tom används Certificate Password")]
        [DefaultValue("")]
        public string pCertificatePasswordParameter { get; set; }

        [DisplayName("Log Debug Info")]
        [Description("Sätt till True om extra info ska loggas i början av varje test")]
        [DefaultValue(false)]
        public bool pDebug { get; set; }

        [DisplayName("Install trusted certificates")]
        [Description("Sätt till True om certifikat ska installeras automatiskt om det är giltigt")]
        [DefaultValue(false)]
        public bool pInstallTrusted { get; set; }

        [DisplayName("Install untrusted certificates")]
        [Description("Sätt till True om ogiltiga som giltiga certifikat ska installeras automatiskt")]
        [DefaultValue(false)]
        public bool pInstallUntrusted { get; set; }

        private bool haveCert = false;
        private X509Certificate2 myClientCertAndKey;
        private Regex p12RegExp = new Regex(@"p12$|pfx$",RegexOptions.IgnoreCase);
        private Regex cerRegExp = new Regex(@"cer$|der$", RegexOptions.IgnoreCase);
        private Regex pemRegExp = new Regex(@"pem$", RegexOptions.IgnoreCase);

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();

            base.PreWebTest(sender, e);
            String certPath, certPass;
            // Ladda in certifikatet och sätt CertPolicy

            if (!String.IsNullOrWhiteSpace(pCertificatePathParameter) && e.WebTest.Context.ContainsKey(pCertificatePathParameter) && !String.IsNullOrWhiteSpace(e.WebTest.Context[pCertificatePathParameter].ToString()) )
            {
                certPath = e.WebTest.Context[pCertificatePathParameter].ToString().Trim();
            } else
            {
                certPath = pCertificatePath.Trim();
            }

            if (!String.IsNullOrWhiteSpace(pCertificatePasswordParameter) && e.WebTest.Context.ContainsKey(pCertificatePasswordParameter) && !String.IsNullOrWhiteSpace(e.WebTest.Context[pCertificatePasswordParameter].ToString()))
            {
                certPass = e.WebTest.Context[pCertificatePasswordParameter].ToString();
            }
            else
            {
                certPass = pCertificatePassword;
            }

            if(string.IsNullOrWhiteSpace(certPath))
            {
                // Cant continue, cert  is missing
                if (pDebug) e.WebTest.AddCommentToResult("No certificate loaded, since both Certificate Path and Certificate Path Parameter are empty");
                return;
            }

            // Check what type of container we have. All files are treated as PEM unless the extension matches our winX509regExp regular expression (see above)
            // Read certificate and private key depending on type
            if (p12RegExp.IsMatch(certPath))
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate file is treated as PFX/P12");
                try
                {
                    myClientCertAndKey = new X509Certificate2(certPath, certPass, X509KeyStorageFlags.PersistKeySet);
                }
                catch (Exception ex)
                {
                    e.WebTest.AddCommentToResult("Error during loading of certificate: " + certPath + " Message: " + ex.Message);
                    return;
                }
            } else if (cerRegExp.IsMatch(certPath))
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate file is treated as CER/DER without private key");
                try
                {
                    myClientCertAndKey = new X509Certificate2(certPath, certPass);
                }
                catch (Exception ex)
                {
                    e.WebTest.AddCommentToResult("Error during loading of certificate: " + certPath + " Message: " + ex.Message);
                    return;
                }
            } else if (pemRegExp.IsMatch(certPath))
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate file is treated as OpenSSL encoded PEM");

                // Use Bouncy Castle to read the certificate and key, then convert to .NET X509Certificate2 and X509Certificate
                String text;
                try {
                    text = File.ReadAllText(certPath);
                } catch (Exception ex)
                {
                    e.WebTest.AddCommentToResult("Error opening PEM file: " + certPath + " Message: " + ex.Message);
                    return;
                }

                // Find the key and certificate in file and load them
                int keyTextBeginPos = text.IndexOf("-----BEGIN");
                int keyTextEndPos = text.IndexOf("-----END");
                Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair bcKey = null;
                Org.BouncyCastle.X509.X509Certificate bcCert = null;

                while (keyTextBeginPos != -1 && keyTextEndPos != -1)
                {
                    object obj;
                    try
                    {
                        Org.BouncyCastle.OpenSsl.PemReader bc = new Org.BouncyCastle.OpenSsl.PemReader(new StringReader(text), new PasswordHelper(certPass));
                        obj = bc.ReadObject();
                    }
                    catch (Org.BouncyCastle.Crypto.InvalidCipherTextException ex)
                    {
                        e.WebTest.AddCommentToResult("Error during reading of PEM file: " + certPath + " Wrong password? Message: " + ex.Message);
                        return;
                    }
                    catch (Exception ex)
                    {
                        e.WebTest.AddCommentToResult("Error during reading of PEM file: " + certPath + " Message: " + ex.GetType().FullName + ":" + ex.Message);
                        return;
                    }
                    if (obj != null)
                    {
                        if (pDebug) e.WebTest.AddCommentToResult("Found PEM Object of type " + obj.GetType().FullName);
                        if(obj is Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair)
                        {
                            // We have a keypair
                            bcKey = (Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair)obj;
                        }
                        if(obj is Org.BouncyCastle.X509.X509Certificate)
                        {
                            // We have a certificate
                            bcCert = (Org.BouncyCastle.X509.X509Certificate)obj;
                        }
                    }
                    keyTextBeginPos = text.IndexOf("-----BEGIN", keyTextEndPos);
                    if(keyTextBeginPos >= 0) text = text.Substring(keyTextBeginPos);
                    keyTextEndPos = text.IndexOf("-----END");
                }
                if (bcCert == null)
                {
                    e.WebTest.AddCommentToResult("Error: PEM file has to contain an x509 certificate");
                    return;
                }
                try {
                    myClientCertAndKey = new X509Certificate2(Org.BouncyCastle.Security.DotNetUtilities.ToX509Certificate(bcCert));
                    if(bcKey != null) myClientCertAndKey.PrivateKey = Org.BouncyCastle.Security.DotNetUtilities.ToRSA(bcKey.Private as Org.BouncyCastle.Crypto.Parameters.RsaPrivateCrtKeyParameters);
                } catch (Exception ex)
                {
                    e.WebTest.AddCommentToResult("Error during loading of PEM file: " + certPath + " Message: " + ex.Message);
                    return;
                }
            } else
            {
                // Unknown or unsuported format
                e.WebTest.AddCommentToResult("Error during loading of file: " + certPath + " Message: Unsupported format");
                return;
            }

            // Check that we have a certificate
            if (myClientCertAndKey == null)
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate File " + certPath + " could not be loaded.");
                return;
            }
            else
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate File " + certPath + " loaded successfully in " + sw.ElapsedMilliseconds + "ms");
            }

            // Check that it seems okey
            if (string.IsNullOrWhiteSpace(myClientCertAndKey.Thumbprint))
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate File " + certPath + " contains no Thumbprint. Not using it.");
                return;
            }
            if (pDebug) e.WebTest.AddCommentToResult("Subject: [" + myClientCertAndKey.Subject + "]");
            if (pDebug) e.WebTest.AddCommentToResult("Issued by: [" + myClientCertAndKey.Issuer + "] Expires: [" + myClientCertAndKey.GetExpirationDateString() + "]");

            // Check if the certificate is trusted (i.e. chain can be validated)
            bool myCertTrusted = false;
            if (myClientCertAndKey.Verify())
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate is TRUSTED");
                myCertTrusted = true;
            } else
            {
                e.WebTest.AddCommentToResult("Warning: Certificate is NOT TRUSTED by client. Might not be trusted on server either. Check that the Issuer/CA root and intermediary certificates are installed on the client and server.");
                myCertTrusted = false;
            }

            // Check if it is expired or about to expire
            if(myClientCertAndKey.NotAfter < DateTime.Now)
            {
                e.WebTest.AddCommentToResult("Warning: Client Certificate has expired. Might not be trusted on server.");
            } else if (myClientCertAndKey.NotBefore > DateTime.Now)
            {
                e.WebTest.AddCommentToResult("Warning: Client Certificate is not valid yet. Might not be trusted on server. Valid on " + myClientCertAndKey.NotBefore.ToString());
            } else if (myClientCertAndKey.NotAfter < DateTime.Now.AddDays(14))
            {
                e.WebTest.AddCommentToResult("Warning: Client Certificate will expire in less than 14 days. Better renew it soon.");
            }

            // Check if we have a private key
            if (myClientCertAndKey.HasPrivateKey)
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate HAS PRIVATE KEY in file");
            }

            // Check that the certificate exists in the cert store
            X509Store cuStore = new X509Store();
            cuStore.Open(OpenFlags.ReadWrite);
            if(cuStore.Certificates.Contains(myClientCertAndKey)) {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate already INSTALLED in Current User Windows Certificate Store");
                // Try to load the key from store if we dont have it and verify that it belongs to the certificate
                if(!myClientCertAndKey.HasPrivateKey)
                {
                    X509Certificate2Collection certCol = cuStore.Certificates.Find(X509FindType.FindByThumbprint, myClientCertAndKey.Thumbprint, false);
                    if(certCol == null || certCol.Count == 0)
                    {
                        e.WebTest.AddCommentToResult("Error: Certificate could not be loaded from store using it's thumbprint which is very strange. Aborting");
                        return;
                    } else
                    {
                        if(certCol.Count > 1)
                        {
                            if (pDebug) e.WebTest.AddCommentToResult("Certificates thumbprint has more than one match in the Windows User Certificate Store, using the first one.");
                        }
                        X509Certificate2 cert = certCol[0];
                        if (!cert.HasPrivateKey)
                        {
                            e.WebTest.AddCommentToResult("Error: Certificate does not have a corresponding private key in the Windows User Certificate Store. Can not use it for SSL.");
                            return;
                        } else
                        {
                            if (pDebug) e.WebTest.AddCommentToResult("Certificate was found in Windows User Certificate Store using thumbprint and HAS a corresponding PRIVATE KEY");
                        }
                    }
                }
            } else
            {
                if (pDebug) e.WebTest.AddCommentToResult("Certificate is NOT INSTALLED");
                if (myClientCertAndKey.HasPrivateKey)
                {
                    if (pInstallTrusted && myCertTrusted || pInstallUntrusted)
                    {
                        // Try to install certificate
                        // Install in user store
                        try
                        {
                            myClientCertAndKey.FriendlyName = "VSTT";
                            cuStore.Add(myClientCertAndKey);
                            if (pDebug) e.WebTest.AddCommentToResult("Certificate HAS BEEN INSTALLED in the Current User Windows Certificate Store with Friendly Name: VSTT");
                        }
                        catch (Exception ex)
                        {
                            e.WebTest.AddCommentToResult("Error: COULD NOT INSTALL in the Current User Windows Certificate Store, Message: " + ex.Message);
                            return;
                        }
                    }
                    else
                    {
                        e.WebTest.AddCommentToResult("Error: COULD NOT INSTALL the certificate since you selected NOT to install untrusted certificates.");
                        return;
                    }
                } else
                {
                    e.WebTest.AddCommentToResult("Error: COULD NOT INSTALL the certificate since the file did not contain a private key and cannot be used without one.");
                    return;
                }
            }

            // Set the PreRequest method to add the certificate on requests
            haveCert = true;
            if (pDebug) e.WebTest.AddCommentToResult("Certificate will be ADDED TO REQUESTS");
            sw.Stop();
            if (pDebug) e.WebTest.AddCommentToResult("Certificate processing done in " + sw.ElapsedMilliseconds + "ms");
        }

        public override void PreRequest(object sender, PreRequestEventArgs e)
        {
            base.PreRequest(sender, e);
            if (haveCert)
            {
                if (!e.Request.ClientCertificates.Contains(myClientCertAndKey))
                {
                    e.Request.ClientCertificates.Add(myClientCertAndKey);
                }
                e.WebTest.Context["Client Certificate"] = myClientCertAndKey.Subject;
            } else
            {
                e.WebTest.Context["Client Certificate"] = "No certificate was specified in this request. Windows will try to automatically choose an installed client certificate if requested by the server.";
            }
        }
    }

    public class PasswordHelper : Org.BouncyCastle.OpenSsl.IPasswordFinder
    {
        private string pwd = "";
        public PasswordHelper(String password)
        {
            this.pwd = password;
        }
        public char[] GetPassword()
        {
            return pwd.ToArray();
        }
    }

    /*
    /// <summary>
    /// WebTest Plugin Template
    /// </summary>
    [DisplayName("Plugin Namn")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nFörklaring")]
    public class myPlugin : WebTestPlugin
    {
        private string paramName;
        [DisplayName("Parameter namn")]
        [Description("Ange namnet på parametern i ditt webtest, tex TimeStampParameter1")]
        [DefaultValue("TimeStampParameter1")]
        public string ParamNameVal
        {
            get { return paramName; }
            set { paramName = value; }
        }

        public override void PreWebTest(object sender, PreWebTestEventArgs e)
        {
            base.PreWebTest(sender, e);
            e.WebTest.Context.CookieContainer = new myCookieContainer();
        }
    }
    */

}