/************************************************************************************************
* 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 Microsoft.VisualStudio.TestTools.LoadTesting;
using System.ComponentModel;
using System.IO;
using System.Collections.Specialized;
using System.Net;

namespace LIL_VSTT_Plugins
{

    /// <summary>
    /// LoadTest Context Copy
    /// </summary>
    [DisplayName("LoadTest Context Copy")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nKopierar context parametrar satta i loadtestet till alla test context i test mixen.")]
    public class LoadTestPluginCopier : ILoadTestPlugin
    {
        //store the load test object.  
        LoadTest mLoadTest;

        public void Initialize(LoadTest loadTest)
        {
            mLoadTest = loadTest;

            //connect to the TestStarting event.
            mLoadTest.TestStarting += new EventHandler<TestStartingEventArgs>(mLoadTest_TestStarting);
        }


        void mLoadTest_TestStarting(object sender, TestStartingEventArgs e)
        {
            //When the test starts, copy the load test context parameters to 
            //the test context parameters
            foreach (string key in mLoadTest.Context.Keys)
            {
                e.TestContextProperties.Add(key, mLoadTest.Context[key]);
            }
        }
    }

        /// <summary>
    /// LoadTest Context Copy
    /// </summary>
    [DisplayName("Personnummer Generator")]
    [Description("(C) Copyright 2017 LIGHTS IN LINE AB\r\nGenererar personnummer och sätter dem som parameter till testernas context.")]
    public class LoadTestPnumGen : ILoadTestPlugin
    {
        //store the load test object.  
        LoadTest mLoadTest;

        public void Initialize(LoadTest loadTest)
        {
            mLoadTest = loadTest;

            //connect to the TestStarting event.
            mLoadTest.TestStarting += new EventHandler<TestStartingEventArgs>(mLoadTest_TestStarting);
        }


        void mLoadTest_TestStarting(object sender, TestStartingEventArgs e)
        {
            //TODO
        }
    }

    /// <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 loadtestet. Finns även som WebTestPlugin som enbart slår på det webtestet.")]
    public class ServiceManagerPlugin : ILoadTestPlugin
    {
        [DisplayName("Enable Expect 100 Behaviour"), DefaultValue(false)]
        [Description(".Net 4.5 default is true, plugin default is false")]
        public bool exp100 { get; set; }

        [DisplayName("Connection Pool Idle Time (s)"), DefaultValue(100)]
        public int maxIdle { get; set; }

        [DisplayName("DNS Refresh Timeout (s)"), DefaultValue(120)]
        public int DnsRefreshTimeout { get; set; }

        [DisplayName("Enable DNS Round Robin"), DefaultValue(false)]
        public bool EnableDnsRoundRobin { get; set; }

        [Category("Transport Control")]
        [DisplayName("TCP Keep Alive"), DefaultValue(false)]
        public bool keepAlive { get; set; }

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

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

        [Category("Transport Control")]
        [DisplayName("Use Nagle Algorithm"), DefaultValue(false)]
        public bool useNagle { get; set; }

        [Category("Secure Sockets")]
        [DisplayName("Enable TLS 1.2"), DefaultValue(true)]
        [Description(".Net 4.5 default is false, plugin default is true")]
        public bool useTls12 { get; set; }

        [Category("Secure Sockets")]
        [DisplayName("Enable TLS 1.1"), DefaultValue(true)]
        [Description(".Net 4.5 default is false, plugin default is true")]
        public bool useTls11 { get; set; }

        [Category("Secure Sockets")]
        [DisplayName("Enable TLS 1.0"), DefaultValue(true)]
        public bool useTls10 { get; set; }

        [Category("Secure Sockets")]
        [DisplayName("Enable SSL 3.0"), DefaultValue(false)]
        public bool useSsl3 { get; set; }

        [Category("Secure Sockets")]
        [DisplayName("Enable CRL checks"), DefaultValue(false)]
        public bool useCrl { get; set; }

        public void Initialize(LoadTest loadTest)
        {
            ServicePointManager.Expect100Continue = exp100;
            ServicePointManager.MaxServicePointIdleTime = maxIdle * 1000;
            ServicePointManager.DnsRefreshTimeout = DnsRefreshTimeout * 1000;
            ServicePointManager.EnableDnsRoundRobin = EnableDnsRoundRobin;
            ServicePointManager.SetTcpKeepAlive(keepAlive, timeOut, interVal);
            ServicePointManager.UseNagleAlgorithm = useNagle;
            //if (useTls12) System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12;
            if (useSsl3) ServicePointManager.SecurityProtocol |= SecurityProtocolType.Ssl3;
            else ServicePointManager.SecurityProtocol &= SecurityProtocolType.Ssl3;
            if (useTls10) ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls;
            else ServicePointManager.SecurityProtocol &= SecurityProtocolType.Tls;
            if (useTls11) ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls11;
            else ServicePointManager.SecurityProtocol &= SecurityProtocolType.Tls11;
            if (useTls12) ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12;
            else ServicePointManager.SecurityProtocol &= SecurityProtocolType.Tls12;
            ServicePointManager.CheckCertificateRevocationList = useCrl;
        }

    }

    [DisplayName("Set Test Context Parameters")]
    [Description("(C) Copyright 2011 LIGHTS IN LINE AB\r\nSätter parametrar i testcontextet för tester i mixen hämtat från en CSV fil.")]
    public class SetTestParameter : ILoadTestPlugin
    {
        // Summary:
        //     Initializes the load test plug-in.
        //
        // Parameters:
        //   loadTest:
        //     The load test to be executed.

        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 bool stop = false;
        private int timeWait = 0;
        
        private StringCollection myParams = new StringCollection();
        private Queue<String> myUsedQueue = new Queue<string>();
        private Queue<String> myUnUsedQueue = new Queue<string>();
        private Random random = new Random();
        private Dictionary<string, int> testIterations = new Dictionary<string, int>();
        private LoadTest m_loadTest;

        #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 void Initialize(LoadTest loadTest)
        {
            m_loadTest = loadTest;
            // Only run on specific agents if specified
            if (myAgentNames.Length > 0 && !myAgentNames.ToLower().Contains(loadTest.Context.AgentName.ToLower())) return;

            // Vi bör läsa in alla värden här
            this.initUserArray(myConnectionString, loadTest.Context.AgentCount, loadTest.Context.AgentId);

            if (myParams.Count > 0)
            {
                if (myUseUniqueTestIteration)
                    m_loadTest.TestStarting += new EventHandler<TestStartingEventArgs>(loadTestStartingUniqueTestIteration);
                else if (myUseUniqueIteration)
                    m_loadTest.TestStarting += new EventHandler<TestStartingEventArgs>(loadTestStartingUniqueIteration);
                else if (myUseUniqueFiles)
                {
                    m_loadTest.TestStarting += new EventHandler<TestStartingEventArgs>(loadTestStartingUniqueFiles);
                    m_loadTest.TestFinished += new EventHandler<TestFinishedEventArgs>(loadTestFinishedUniqueFiles);
                }
                else if (myUseUnique)
                    m_loadTest.TestStarting += new EventHandler<TestStartingEventArgs>(loadTestStartingUnique);
                else if (myUseRandom)
                    m_loadTest.TestStarting += new EventHandler<TestStartingEventArgs>(loadTestStartingRandom);
                else
                    m_loadTest.TestStarting += new EventHandler<TestStartingEventArgs>(loadTestStartingSeq);
            }
            if (myLogToFile)
            {
                m_loadTest.TestFinished += new EventHandler<TestFinishedEventArgs>(loadTestEndLogger);
            }
            m_loadTest.Heartbeat += new EventHandler<HeartbeatEventArgs>(loadTestHeartBeat);
        }

        void loadTestHeartBeat(object sender, HeartbeatEventArgs e)
        {
            if (stop)
            {
                if (timeWait > 60)
                    m_loadTest.Abort(new Exception("Out of test data: " + myConnectionString + " does not have more than " + myParams.Count + " accepted rows with IgnoreBlanks " + myIgnoreBlanks + "), Autosplit " + myUseAutoSplit + " and with " + m_loadTest.Context.AgentCount + " Agent(s)."));
                else
                    timeWait++;
            }
        }

        void loadTestEndLogger(object sender, TestFinishedEventArgs e)
        {
            // Log the user to logfile if the test is passed
            if (e.Result.Passed && shouldRun(e))
            {
                string fileName = myLogFileString;
                if (myLogAppendID) fileName = fileName + ".Agent" + m_loadTest.Context.AgentId + ".Vu" + e.UserContext.UserId;
                if (myLogAppendName) fileName = fileName + "." + e.UserContext.ScenarioName + "." + e.TestName;
                string[] allNames;
                if (myHasColName) allNames = myColNames.Split(','); else allNames = myParameterName.Split(',');
                string row = "";
                foreach (string name in allNames)
                {
                    if(e.UserContext.Keys.Contains(name)) {
                        if (row.Length == 0)
                            row += e.UserContext[name];
                        else
                            row += "," + e.UserContext[name];
                    }
                }
                File.AppendAllText(fileName + ".csv", row + "\r\n");
            }
        }

        void loadTestStartingRandom(object sender, TestStartingEventArgs e)
        {
            setParameters(this.getRandomUser(), e);
        }

        void loadTestStartingSeq(object sender, TestStartingEventArgs e)
        {
            setParameters(this.getSeqUser(e.UserContext.CompletedTestCount), e);
        }

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

        void loadTestFinishedUniqueFiles(object sender, TestFinishedEventArgs e)
        {
            if (shouldRun(e))
            {
                String queueVal = (String)e.UserContext["QueueVal"];
                if (queueVal != null)
                    lock (myUnUsedQueue)
                    {
                        myUnUsedQueue.Enqueue(queueVal);
                    }
                if (myDebug) lock (myDebugLogFile) { File.AppendAllText(myDebugLogFile, DateTime.Now.ToLocalTime() + " File: " + myConnectionString + " Test: " + e.TestName + " VU: " + e.UserContext.UserId + " Value: \"" + queueVal + "\" PUSH\r\n"); }
            }
        }

        void loadTestStartingUnique(object sender, TestStartingEventArgs e)
        {
            setParameters(this.getSeqUser(e.UserContext.UserId), e);
        }

        void loadTestStartingUniqueIteration(object sender, TestStartingEventArgs e)
        {
            setParameters(this.getSeqUser(e.TestIterationNumber - 1), e);
        }

        void loadTestStartingUniqueTestIteration(object sender, TestStartingEventArgs e)
        {
            if (shouldRun(e))
            {
                int testIteration = getTestIterationNumber(e.TestName);
                e.UserContext["TestIteration"] = testIteration;
                e.TestContextProperties["TestIteration"] = testIteration;
                setParameters(this.getSeqUser(testIteration - 1), e);
            }
        }

        void setParameters(string user, TestStartingEventArgs e)
        {
            if (shouldRun(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);
                //e.TestContextProperties.Add("LIL_LogValue", user);
                //e.UserContext["LIL_LogValue"] = user;
                string[] allParams = user.Split(',');
                string[] allNames;
                if (myHasColName) allNames = myColNames.Split(','); else allNames = myParameterName.Split(',');
                for (int i = 0; i < numParams; i++)
                {
                    e.TestContextProperties[allNames[i]] = allParams[i];
                    e.UserContext[allNames[i]] = allParams[i];
                }
            }
        }

        int getTestIterationNumber(string testName)
        {
            int num = 1;
            lock (testIterations)
            {
                if (testIterations.ContainsKey(testName) == false)
                    {
                        testIterations[testName] = 0;
                    }
                num = testIterations[testName] + 1;
                testIterations[testName] = num;
            }
            return num;
        }

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

        bool shouldRun(TestStartingEventArgs e)
        {
            bool doRun = true;
            if (myTestNames.Length > 0 && !myTestNames.ToLower().Contains(e.TestName.ToLower())) doRun = false;
            if (myScenarioNames.Length > 0 && !myScenarioNames.ToLower().Contains(e.ScenarioName.ToLower())) doRun = false;
            return doRun;
        }

        bool shouldRun(TestFinishedEventArgs e)
        {
            bool doRun = true;
            if (myTestNames.Length > 0 && !myTestNames.ToLower().Contains(e.TestName.ToLower())) doRun = false;
            if (myScenarioNames.Length > 0 && !myScenarioNames.ToLower().Contains(e.ScenarioName.ToLower())) doRun = false;
            return doRun;
        }

        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()
        {
            if(m_loadTest != null)
            foreach (LoadTestScenario s in m_loadTest.Scenarios)
            {
                s.CurrentLoad = 0;
            }
            this.stop = true;
        }

        bool initUserArray(string path, int agentCount, int agentId)
        {
            if (path.Length > 0)
            {
                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();
                return true;
            }
            else { 
                return false; 
            }
        }
    }
}