<|start_filename|>BDD/BDDWebTestAutomation/SpecFlowTests/BDDCoffeeSiteSteps.cs<|end_filename|>
﻿using TechTalk.SpecFlow;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using SpecFlowTests.Drivers;
using OpenQA.Selenium;

namespace SpecFlowTests
{
    [Binding]
    public class BDDCoffeeSiteSteps
    {
        public static WebDriver webDriver = null;
        [AfterTestRun]
        public static void AfterTestRun()
        {
            webDriver?.Quit();
            webDriver?.Dispose();
        }

        [BeforeTestRun]
        public static void BeforeTestRun()
        {
            webDriver = new WebDriver();
        }
        [Given(@"I have a deployed web site")]
        public void GivenIHaveADeployedWebSite()
        {
            //ScenarioContext.Current.Pending();
        }
        
        [Given(@"I want to override the default site url")]
        public void GivenIWantToOverrideTheDefaultSiteUrl()
        {
            
        }
        
        [When(@"I set the Site Url to (.*)")]
        public void WhenISetTheSiteUrlToHttpsDrcoffee_Azurewebsites_Net(string p0)
        {
            webDriver.SeleniumBaseUrl = p0;
        }
        
        [Then(@"a browser opens to the default page")]
        public void ThenABrowserOpensToTheDefaultPage()
        {
            webDriver.Current.Navigate();
        }

        [Given(@"I like Capuccino")]
        public void GivenILikeCapuccino()
        {
            
        }

        [When(@"I go to the relative url of (.*)")]
        public void WhenIGoToTheRelativeUrlOf(string p0)
        {
            webDriver.SetRelativeUrl(p0);
            webDriver.Current.Navigate();
        }

        [Then(@"the coffee type (.*) is found")]
        public void ThenTheCoffeeTypeCappuccinoIsFound(string p0)
        {
            Assert.IsTrue(webDriver.Current.PageSource.Contains(p0));
        }

        [Then(@"I can verify the text '(.*)' is on the page")]
        public void ThenICanVerifyTheTextIsOnThePage(string p0)
        {
            Assert.IsTrue(webDriver.Current.PageSource.Contains(p0));
        }

        [Given(@"I want to show how to write tests")]
        public void GivenIWantToShowHowToWriteTests()
        {
           
        }

    }
}


<|start_filename|>BDD/BDDWebTestAutomation/EncryptUtilsTests/EncryptStringsTests.cs<|end_filename|>
﻿using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using EncryptUtils;
namespace EncryptUtilsTests
{
    [TestClass]
    public class EncryptStringsTests
    {
        [TestMethod]
        public void EncryptStringTest()
        {
            //arrange
            string OriginalString = "This is not encrypted";
            string EncryptionKey = "really lame encryption key";
            //act
            var EncryptedString = EncryptUtils.EncryptStrings.Encrypt(OriginalString, true, EncryptionKey);
            var DecryptedString = EncryptUtils.EncryptStrings.Decrypt(EncryptedString, true, EncryptionKey);
            //assert
            Assert.AreEqual(OriginalString, DecryptedString);
        }

        [TestMethod]
        public void DecryptStringTest()
        { }
    }
}


<|start_filename|>source/JmeterPipelineValidationTests/JmeterPipelineValidationTests/Config.cs<|end_filename|>
﻿using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace JmeterPipelineValidationTests
{
    public class Config
    {
        public static IConfiguration Configuration {
            get {
                string configFileContents = File.ReadAllText("appsettings.json");
                byte[] byteArray = Encoding.UTF8.GetBytes(configFileContents.Replace(@"\", @"\\"));
                MemoryStream stream = new MemoryStream(byteArray);
                var builder = new ConfigurationBuilder()
               .SetBasePath(Directory.GetCurrentDirectory())
               .AddJsonStream(stream);
                return builder.Build();
            }}

    }
}


<|start_filename|>source/JmeterPipelineValidationTests/JmeterPipelineValidationTests/GenerateReportTests.cs<|end_filename|>
﻿using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.IO;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;

namespace JmeterPipelineValidationTests
{
    [TestClass]
    public class GenerateReportTests
    {
        [TestMethod]
        public void GenerateReport()
        {
            //arrange
            string resultsJsonFile = Config.Configuration["statisticsFileName"];

            //act
            JObject resultsJson = JObject.Parse(File.ReadAllText(resultsJsonFile));
            string markdownTemplate =
                $"# JMeter Performance Test Results\r\n" +
                $"\r\n" +
                $"| Measure      | Value |\r\n"+
                $"| ----------- | ----------- |\r\n" +
                $"| Average Response Time | {resultsJson["Total"]["meanResTime"]} |\r\n" +
                $"| Sample Count | {resultsJson["Total"]["sampleCount"]} |\r\n";
            File.WriteAllText(@"report.md", markdownTemplate);
            //assert

        }
        
    }
}


<|start_filename|>DynamicsFinOps/FinOpsConfigurationValidation/DynamicsOdataTests/FinOpsRSSTests.cs<|end_filename|>
﻿using Microsoft.VisualStudio.TestTools.UnitTesting;
using DynamicsOdata;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json.Linq;

namespace DynamicsOdataTests
{
    [TestClass()]
    public class FinOpsRSSTests
    {
        public static TestContext TC;

        [ClassInitialize]
        public static void InitializeTestClass(TestContext tc)
        {
            TC = tc;
        }

        [TestMethod()]
        public void FinOpsRSSTest()
        {
            //arrange
            FinOpsRSS finOpsRSS = RSSUtil.CreateRssFromConfig();
            //act
            JObject rss = finOpsRSS.GetJsonRss("Customers");
            int numberOfCustomers = 0;
            var customers = from a in rss["value"]
                            select (string)a["Name"];
            foreach (var customer in customers)
            {
                numberOfCustomers++;
                TC.WriteLine("Customer Name: {0}", customer);
            }
            //assert
            Assert.IsTrue(numberOfCustomers > 0);
        }

        [TestMethod()]
        public void CreateSpecFlowExamples()
        {
            //arrange
            FinOpsRSS finOpsRSS = RSSUtil.CreateRssFromConfig();
            //act
            JObject rss = finOpsRSS.GetJsonRss("MainAccounts");
            int numberOfCustomers = 0;
            var customers = from a in rss["value"]
                            select (string)a["Name"];
            foreach (var customer in customers)
            {
                numberOfCustomers++;
                TC.WriteLine("\t| {0} |", customer);
            }
            //assert
            Assert.IsTrue(numberOfCustomers > 0);
        }

        [TestMethod]
        public void DumpConfigurationSettings()
        {
            //arrange
            FinOpsRSS finOpsRSS = RSSUtil.CreateRssFromConfig();
            //act
            TC.WriteLine("ActiveDirectoryClientAppId '{0}'",finOpsRSS.ActiveDirectoryClientAppId);
            TC.WriteLine("ActiveDirectoryResource '{0}'", finOpsRSS.ActiveDirectoryResource);
            TC.WriteLine("ActiveDirectoryTenant '{0}'", finOpsRSS.ActiveDirectoryTenant);
            TC.WriteLine("AzureSecret '{0}'", finOpsRSS.AzureSecret);
        }

    }
}

<|start_filename|>BDD/BDDWebTestAutomation/SpecFlowTests/Drivers/WebDriver.cs<|end_filename|>
﻿using System;
using System.Configuration;
using System.Diagnostics;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Firefox;
using OpenQA.Selenium.IE;
using OpenQA.Selenium.PhantomJS;
using OpenQA.Selenium.Support.UI;

namespace SpecFlowTests.Drivers
{
    public static class WebDriverExtensions
    {
        public static IWebElement FindElement(this IWebDriver driver, By by, int timeoutInSeconds)
        {
            if (timeoutInSeconds > 0)
            {
                var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
                return wait.Until(drv => drv.FindElement(by));
            }
            return driver.FindElement(by);
        }
    }
    public class WebDriver : IDisposable
    {
        private IWebDriver _currentWebDriver;
        public WebDriver(string url)
        {
            this.SeleniumBaseUrl = url;
        }

        public WebDriver()
        {
            SeleniumBaseUrl = SpecFlowTests.Properties.Settings.Default.seleniumBaseUrl;
        }

        public Screenshot GetScreenShot()
        {
            return ((ITakesScreenshot)this.Current).GetScreenshot();
        }

        public void SetRelativeUrl(string relativeUrl)
        {
            this.Current.Url = this.SeleniumBaseUrl + relativeUrl;
        }
        public IWebDriver Current
        {
            get
            {
                if (_currentWebDriver != null)
                    return _currentWebDriver;

                switch (BrowserConfig.ToUpper())
                {
                    case "IE":
                        _currentWebDriver = new InternetExplorerDriver(new InternetExplorerOptions() { IgnoreZoomLevel = true}) { Url = SeleniumBaseUrl };
                        break;
                    case "CHROME":
                        _currentWebDriver = new ChromeDriver() { Url = SeleniumBaseUrl };
                        break;
                    case "FIREFOX":
                        _currentWebDriver = new FirefoxDriver() { Url = SeleniumBaseUrl };
                        break;
                    case "HEADLESS":
                        _currentWebDriver = new PhantomJSDriver() { Url = SeleniumBaseUrl };
                        break;
                    default:
                        throw new NotSupportedException($"{BrowserConfig} is not a supported browser");
                }

                return _currentWebDriver;
            }
        }

        private WebDriverWait _wait;
        public WebDriverWait Wait
        {
            get
            {
                if (_wait == null)
                {
                    this._wait = new WebDriverWait(Current, TimeSpan.FromSeconds(10));
                }
                return _wait;
            }
        }

        protected string BrowserConfig => SpecFlowTests.Properties.Settings.Default.BrowserConfig;
        public string SeleniumBaseUrl;

        public void Quit()
        {
            _currentWebDriver?.Quit();
        }

        public void Dispose()
        {
            _currentWebDriver?.Dispose();
            KillSelenium();

        }
        private void KillSelenium()
        {
            string nameOfDriver;
            string nameOfBrowser;
            try
            {
                switch (BrowserConfig)
                {
                    case "IE":
                        nameOfBrowser = "ie.exe";
                        nameOfDriver = "IEDriverServer";
                        break;
                    case "Chrome":
                        nameOfDriver = "chromedriver.exe";
                        nameOfBrowser = "chrome.exe";
                        break;
                    case "Firefox":
                        nameOfBrowser = "firefox.exe";
                        nameOfDriver = "geckodriver.exe";
                        break;
                    default:
                        throw new NotSupportedException($"{BrowserConfig} is not a supported browser");
                }

                var webDrivers = Process.GetProcessesByName(nameOfDriver);
                foreach (var webDriver in webDrivers)
                {
                    webDriver.Kill();
                }
                var browsers = Process.GetProcessesByName(nameOfBrowser);
                foreach (var browser in browsers)
                {
                    browser.Kill();
                }

            }
            catch
            {


            }
        }
    }
}


<|start_filename|>jmeter/bearer.groovy<|end_filename|>
@Grab(group='commons-codec', module='commons-codec', version='1.13')
import org.apache.commons.codec.binary.Base64;
String jwtToken = "<KEY>";
//String jwtToken = vars.get("bearer");
String[] split_string = jwtToken.split("\\.");
String base64EncodedHeader = split_string[0];
String base64EncodedBody = split_string[1];
String base64EncodedSignature = split_string[2];
Base64 base64Url = new Base64(true);
String header = new String(base64Url.decode(base64EncodedHeader));
String body = new String(base64Url.decode(base64EncodedBody));
printf header;
printf body;
//vars.put("jwtHeader",header)
//vars.put("jwtBody",body)

<|start_filename|>BDD/BDDWebTestAutomation/SpecFlowTests/BDDCoffeeSite.feature.cs<|end_filename|>
﻿// ------------------------------------------------------------------------------
//  <auto-generated>
//      This code was generated by SpecFlow (http://www.specflow.org/).
//      SpecFlow Version:2.2.0.0
//      SpecFlow Generator Version:2.2.0.0
// 
//      Changes to this file may cause incorrect behavior and will be lost if
//      the code is regenerated.
//  </auto-generated>
// ------------------------------------------------------------------------------
#region Designer generated code
#pragma warning disable
namespace SpecFlowTests
{
    using TechTalk.SpecFlow;
    
    
    [System.CodeDom.Compiler.GeneratedCodeAttribute("TechTalk.SpecFlow", "2.2.0.0")]
    [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    [Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute()]
    public partial class BDDCoffeeSiteFeature
    {
        
        private static TechTalk.SpecFlow.ITestRunner testRunner;
        
        private Microsoft.VisualStudio.TestTools.UnitTesting.TestContext _testContext;
        
#line 1 "BDDCoffeeSite.feature"
#line hidden
        
        public virtual Microsoft.VisualStudio.TestTools.UnitTesting.TestContext TestContext
        {
            get
            {
                return this._testContext;
            }
            set
            {
                this._testContext = value;
            }
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.ClassInitializeAttribute()]
        public static void FeatureSetup(Microsoft.VisualStudio.TestTools.UnitTesting.TestContext testContext)
        {
            testRunner = TechTalk.SpecFlow.TestRunnerManager.GetTestRunner(null, 0);
            TechTalk.SpecFlow.FeatureInfo featureInfo = new TechTalk.SpecFlow.FeatureInfo(new System.Globalization.CultureInfo("en-US"), "BDDCoffeeSite", null, ProgrammingLanguage.CSharp, ((string[])(null)));
            testRunner.OnFeatureStart(featureInfo);
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.ClassCleanupAttribute()]
        public static void FeatureTearDown()
        {
            testRunner.OnFeatureEnd();
            testRunner = null;
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestInitializeAttribute()]
        public virtual void TestInitialize()
        {
            if (((testRunner.FeatureContext != null) 
                        && (testRunner.FeatureContext.FeatureInfo.Title != "BDDCoffeeSite")))
            {
                global::SpecFlowTests.BDDCoffeeSiteFeature.FeatureSetup(null);
            }
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestCleanupAttribute()]
        public virtual void ScenarioTearDown()
        {
            testRunner.OnScenarioEnd();
        }
        
        public virtual void ScenarioSetup(TechTalk.SpecFlow.ScenarioInfo scenarioInfo)
        {
            testRunner.OnScenarioStart(scenarioInfo);
            testRunner.ScenarioContext.ScenarioContainer.RegisterInstanceAs<Microsoft.VisualStudio.TestTools.UnitTesting.TestContext>(TestContext);
        }
        
        public virtual void ScenarioCleanup()
        {
            testRunner.CollectScenarioErrors();
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Set the base url")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "BDDCoffeeSite")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestCategoryAttribute("SetBasePage")]
        public virtual void SetTheBaseUrl()
        {
            TechTalk.SpecFlow.ScenarioInfo scenarioInfo = new TechTalk.SpecFlow.ScenarioInfo("Set the base url", new string[] {
                        "SetBasePage"});
#line 5
this.ScenarioSetup(scenarioInfo);
#line 6
 testRunner.Given("I have a deployed web site", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "Given ");
#line 7
 testRunner.And("I want to override the default site url", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "And ");
#line 8
 testRunner.When("I set the Site Url to https://drcoffee.azurewebsites.net", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "When ");
#line 9
 testRunner.Then("a browser opens to the default page", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "Then ");
#line hidden
            this.ScenarioCleanup();
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Verify Cappuccino is available")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "BDDCoffeeSite")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestCategoryAttribute("HomePage")]
        public virtual void VerifyCappuccinoIsAvailable()
        {
            TechTalk.SpecFlow.ScenarioInfo scenarioInfo = new TechTalk.SpecFlow.ScenarioInfo("Verify Cappuccino is available", new string[] {
                        "HomePage"});
#line 12
this.ScenarioSetup(scenarioInfo);
#line 13
 testRunner.Given("I like Capuccino", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "Given ");
#line 14
 testRunner.When("I set the Site Url to https://drcoffee.azurewebsites.net", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "When ");
#line 15
 testRunner.And("I go to the relative url of /", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "And ");
#line 16
 testRunner.Then("the coffee type Cappuccino is found", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "Then ");
#line hidden
            this.ScenarioCleanup();
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Show how anyone can write new tests")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "BDDCoffeeSite")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestCategoryAttribute("AboutPage")]
        public virtual void ShowHowAnyoneCanWriteNewTests()
        {
            TechTalk.SpecFlow.ScenarioInfo scenarioInfo = new TechTalk.SpecFlow.ScenarioInfo("Show how anyone can write new tests", new string[] {
                        "AboutPage"});
#line 19
this.ScenarioSetup(scenarioInfo);
#line 20
 testRunner.Given("I want to show how to write tests", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "Given ");
#line 21
 testRunner.When("I set the Site Url to https://drcoffee.azurewebsites.net", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "When ");
#line 22
 testRunner.And("I go to the relative url of /about.jsp", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "And ");
#line 23
 testRunner.Then("I can verify the text \'Its a coffee shop\' is on the page", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "Then ");
#line hidden
            this.ScenarioCleanup();
        }
    }
}
#pragma warning restore
#endregion


<|start_filename|>DynamicsFinOps/FinOpsConfigurationValidation/DynamicsOdataTests/ChartOfAccountsConfigurationSteps.cs<|end_filename|>
﻿using System;
using TechTalk.SpecFlow;
using Newtonsoft.Json.Linq;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using DynamicsOdata;
using System.Configuration;
namespace DynamicsOdataTests
{
    [Binding]
    public class ChartOfAccountsConfigurationSteps
    {
        [Given(@"the '(.*)' have been created")]
        public void GivenTheHaveBeenCreated(string p0)
        {
            JObject rss = null;
            if (!FeatureContext.Current.Keys.Contains(ScenarioContext.Current.ScenarioInfo.Title + "rss"))
            {
                FinOpsRSS finOpsRSS = RSSUtil.CreateRssFromConfig();
                rss = finOpsRSS.GetJsonRss(p0);
                FeatureContext.Current.Add(ScenarioContext.Current.ScenarioInfo.Title + "rss", rss);
            }
        }
        
        [When(@"we look at the '(.*)' key")]
        public void WhenWeLookAtTheKey(string p0)
        {
            if (!FeatureContext.Current.Keys.Contains(ScenarioContext.Current.ScenarioInfo.Title + "rssTag"))
                FeatureContext.Current.Add(ScenarioContext.Current.ScenarioInfo.Title + "rssTag", p0);


        }

        [Then(@"(.*) should match")]
        public void ThenShouldMatch(string p0)
        {
            string rssTag =(string) FeatureContext.Current[ScenarioContext.Current.ScenarioInfo.Title + "rssTag"];
            var rss = (JObject)FeatureContext.Current[ScenarioContext.Current.ScenarioInfo.Title + "rss"];
            var rssResults = from a in rss["value"]
                             where ((string)a[rssTag] == p0)
                             select (string)a[rssTag];
            Assert.IsTrue(rssResults.Count() > 0);
        }
    }
}


<|start_filename|>parameterize/DetectParams/dos2unix/Program.cs<|end_filename|>
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;

namespace dos2unix
{
    class Program
    {
        static void Main(string[] args)
        {
            string fileName = args[0];
            string fileContents = File.ReadAllText(fileName);
            File.WriteAllText(fileName,fileContents.Replace("\r\n", "\n"));
           
        }
        
    }
}


<|start_filename|>DynamicsFinOps/FinOpsConfigurationValidation/DynamicsOdataTests/ChartOfAccountsConfiguration.feature.cs<|end_filename|>
﻿// ------------------------------------------------------------------------------
//  <auto-generated>
//      This code was generated by SpecFlow (http://www.specflow.org/).
//      SpecFlow Version:2.4.0.0
//      SpecFlow Generator Version:2.4.0.0
// 
//      Changes to this file may cause incorrect behavior and will be lost if
//      the code is regenerated.
//  </auto-generated>
// ------------------------------------------------------------------------------
#region Designer generated code
#pragma warning disable
namespace DynamicsOdataTests
{
    using TechTalk.SpecFlow;
    
    
    [System.CodeDom.Compiler.GeneratedCodeAttribute("TechTalk.SpecFlow", "2.4.0.0")]
    [System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    [Microsoft.VisualStudio.TestTools.UnitTesting.TestClassAttribute()]
    public partial class ChartOfAccountsConfigurationFeature
    {
        
        private static TechTalk.SpecFlow.ITestRunner testRunner;
        
        private Microsoft.VisualStudio.TestTools.UnitTesting.TestContext _testContext;
        
#line 1 "ChartOfAccountsConfiguration.feature"
#line hidden
        
        public virtual Microsoft.VisualStudio.TestTools.UnitTesting.TestContext TestContext
        {
            get
            {
                return this._testContext;
            }
            set
            {
                this._testContext = value;
            }
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.ClassInitializeAttribute()]
        public static void FeatureSetup(Microsoft.VisualStudio.TestTools.UnitTesting.TestContext testContext)
        {
            testRunner = TechTalk.SpecFlow.TestRunnerManager.GetTestRunner();
            TechTalk.SpecFlow.FeatureInfo featureInfo = new TechTalk.SpecFlow.FeatureInfo(new System.Globalization.CultureInfo("en-US"), "ChartOfAccountsConfiguration", "\tIn order to verify each deployment is consistent\r\n\tAnd ensure that minimum requi" +
                    "red accounting elements are present\r\n\tto avoid testing new features before manua" +
                    "l configurations have been completed", ProgrammingLanguage.CSharp, ((string[])(null)));
            testRunner.OnFeatureStart(featureInfo);
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.ClassCleanupAttribute()]
        public static void FeatureTearDown()
        {
            testRunner.OnFeatureEnd();
            testRunner = null;
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestInitializeAttribute()]
        public virtual void TestInitialize()
        {
            if (((testRunner.FeatureContext != null) 
                        && (testRunner.FeatureContext.FeatureInfo.Title != "ChartOfAccountsConfiguration")))
            {
                global::DynamicsOdataTests.ChartOfAccountsConfigurationFeature.FeatureSetup(null);
            }
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestCleanupAttribute()]
        public virtual void ScenarioTearDown()
        {
            testRunner.OnScenarioEnd();
        }
        
        public virtual void ScenarioInitialize(TechTalk.SpecFlow.ScenarioInfo scenarioInfo)
        {
            testRunner.OnScenarioInitialize(scenarioInfo);
            testRunner.ScenarioContext.ScenarioContainer.RegisterInstanceAs<Microsoft.VisualStudio.TestTools.UnitTesting.TestContext>(_testContext);
        }
        
        public virtual void ScenarioStart()
        {
            testRunner.OnScenarioStart();
        }
        
        public virtual void ScenarioCleanup()
        {
            testRunner.CollectScenarioErrors();
        }
        
        public virtual void RequiredGLAccountsExist(string accountName, string[] exampleTags)
        {
            TechTalk.SpecFlow.ScenarioInfo scenarioInfo = new TechTalk.SpecFlow.ScenarioInfo("Required GL Accounts exist", null, exampleTags);
#line 7
this.ScenarioInitialize(scenarioInfo);
            this.ScenarioStart();
#line 8
 testRunner.Given("the \'MainAccounts\' have been created", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "Given ");
#line 9
 testRunner.When("we look at the \'Name\' key", ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "When ");
#line 10
 testRunner.Then(string.Format("{0} should match", accountName), ((string)(null)), ((TechTalk.SpecFlow.Table)(null)), "Then ");
#line hidden
            this.ScenarioCleanup();
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Cash Advance Returns")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Cash Advance Returns")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Cash Advance Returns")]
        public virtual void RequiredGLAccountsExist_CashAdvanceReturns()
        {
#line 7
this.RequiredGLAccountsExist("Cash Advance Returns", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Bank Account - USD")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Bank Account - USD")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Bank Account - USD")]
        public virtual void RequiredGLAccountsExist_BankAccount_USD()
        {
#line 7
this.RequiredGLAccountsExist("Bank Account - USD", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Bank Account - CNY")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Bank Account - CNY")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Bank Account - CNY")]
        public virtual void RequiredGLAccountsExist_BankAccount_CNY()
        {
#line 7
this.RequiredGLAccountsExist("Bank Account - CNY", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Bank Account - EUR")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Bank Account - EUR")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Bank Account - EUR")]
        public virtual void RequiredGLAccountsExist_BankAccount_EUR()
        {
#line 7
this.RequiredGLAccountsExist("Bank Account - EUR", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Bank Account - RUB")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Bank Account - RUB")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Bank Account - RUB")]
        public virtual void RequiredGLAccountsExist_BankAccount_RUB()
        {
#line 7
this.RequiredGLAccountsExist("Bank Account - RUB", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Bank Account - GBP")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Bank Account - GBP")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Bank Account - GBP")]
        public virtual void RequiredGLAccountsExist_BankAccount_GBP()
        {
#line 7
this.RequiredGLAccountsExist("Bank Account - GBP", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: USD Cash Advances Account")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "USD Cash Advances Account")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "USD Cash Advances Account")]
        public virtual void RequiredGLAccountsExist_USDCashAdvancesAccount()
        {
#line 7
this.RequiredGLAccountsExist("USD Cash Advances Account", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: EUR Cash Advances Account")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "EUR Cash Advances Account")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "EUR Cash Advances Account")]
        public virtual void RequiredGLAccountsExist_EURCashAdvancesAccount()
        {
#line 7
this.RequiredGLAccountsExist("EUR Cash Advances Account", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: CAD Cash Advances Account")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "CAD Cash Advances Account")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "CAD Cash Advances Account")]
        public virtual void RequiredGLAccountsExist_CADCashAdvancesAccount()
        {
#line 7
this.RequiredGLAccountsExist("CAD Cash Advances Account", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Yuan Cash Advances Account")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Yuan Cash Advances Account")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Yuan Cash Advances Account")]
        public virtual void RequiredGLAccountsExist_YuanCashAdvancesAccount()
        {
#line 7
this.RequiredGLAccountsExist("Yuan Cash Advances Account", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: All Other Cash Advances Account")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "All Other Cash Advances Account")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "All Other Cash Advances Account")]
        public virtual void RequiredGLAccountsExist_AllOtherCashAdvancesAccount()
        {
#line 7
this.RequiredGLAccountsExist("All Other Cash Advances Account", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Bank Account - Payroll")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Bank Account - Payroll")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Bank Account - Payroll")]
        public virtual void RequiredGLAccountsExist_BankAccount_Payroll()
        {
#line 7
this.RequiredGLAccountsExist("Bank Account - Payroll", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Cash in bank - US (Fixed asset purch)")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Cash in bank - US (Fixed asset purch)")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Cash in bank - US (Fixed asset purch)")]
        public virtual void RequiredGLAccountsExist_CashInBank_USFixedAssetPurch()
        {
#line 7
this.RequiredGLAccountsExist("Cash in bank - US (Fixed asset purch)", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Petty Cash")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Petty Cash")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "<NAME>")]
        public virtual void RequiredGLAccountsExist_PettyCash()
        {
#line 7
this.RequiredGLAccountsExist("Petty Cash", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: TOTAL CASH & CASH EQUIVALENTS")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "TOTAL CASH & CASH EQUIVALENTS")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "TOTAL CASH & CASH EQUIVALENTS")]
        public virtual void RequiredGLAccountsExist_TOTALCASHCASHEQUIVALENTS()
        {
#line 7
this.RequiredGLAccountsExist("TOTAL CASH & CASH EQUIVALENTS", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Bonds")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Bonds")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Bonds")]
        public virtual void RequiredGLAccountsExist_Bonds()
        {
#line 7
this.RequiredGLAccountsExist("Bonds", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Other Marketable Securities")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Other Marketable Securities")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Other Marketable Securities")]
        public virtual void RequiredGLAccountsExist_OtherMarketableSecurities()
        {
#line 7
this.RequiredGLAccountsExist("Other Marketable Securities", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Bill of Exchange (BOE)")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Bill of Exchange (BOE)")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Bill of Exchange (BOE)")]
        public virtual void RequiredGLAccountsExist_BillOfExchangeBOE()
        {
#line 7
this.RequiredGLAccountsExist("Bill of Exchange (BOE)", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: BOE Remitted for Collection")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "BOE Remitted for Collection")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "BOE Remitted for Collection")]
        public virtual void RequiredGLAccountsExist_BOERemittedForCollection()
        {
#line 7
this.RequiredGLAccountsExist("BOE Remitted for Collection", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: BOE Remitted for Discount")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "BOE Remitted for Discount")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "BOE Remitted for Discount")]
        public virtual void RequiredGLAccountsExist_BOERemittedForDiscount()
        {
#line 7
this.RequiredGLAccountsExist("BOE Remitted for Discount", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Protested BOE")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Protested BOE")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Protested BOE")]
        public virtual void RequiredGLAccountsExist_ProtestedBOE()
        {
#line 7
this.RequiredGLAccountsExist("Protested BOE", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: TOTAL SECURITIES")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "TOTAL SECURITIES")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "TOTAL SECURITIES")]
        public virtual void RequiredGLAccountsExist_TOTALSECURITIES()
        {
#line 7
this.RequiredGLAccountsExist("TOTAL SECURITIES", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Accounts Receivable - Domestic")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Accounts Receivable - Domestic")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Accounts Receivable - Domestic")]
        public virtual void RequiredGLAccountsExist_AccountsReceivable_Domestic()
        {
#line 7
this.RequiredGLAccountsExist("Accounts Receivable - Domestic", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Accounts Receivable - Foreign")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Accounts Receivable - Foreign")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Accounts Receivable - Foreign")]
        public virtual void RequiredGLAccountsExist_AccountsReceivable_Foreign()
        {
#line 7
this.RequiredGLAccountsExist("Accounts Receivable - Foreign", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Accounts Receivable - Clearing")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Accounts Receivable - Clearing")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Accounts Receivable - Clearing")]
        public virtual void RequiredGLAccountsExist_AccountsReceivable_Clearing()
        {
#line 7
this.RequiredGLAccountsExist("Accounts Receivable - Clearing", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Inter-unit Receivable - Domestic")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Inter-unit Receivable - Domestic")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Inter-unit Receivable - Domestic")]
        public virtual void RequiredGLAccountsExist_Inter_UnitReceivable_Domestic()
        {
#line 7
this.RequiredGLAccountsExist("Inter-unit Receivable - Domestic", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Credit Card Receivable")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Credit Card Receivable")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Credit Card Receivable")]
        public virtual void RequiredGLAccountsExist_CreditCardReceivable()
        {
#line 7
this.RequiredGLAccountsExist("Credit Card Receivable", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Interest Receivable")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Interest Receivable")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Interest Receivable")]
        public virtual void RequiredGLAccountsExist_InterestReceivable()
        {
#line 7
this.RequiredGLAccountsExist("Interest Receivable", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Notes Receivable")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Notes Receivable")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Notes Receivable")]
        public virtual void RequiredGLAccountsExist_NotesReceivable()
        {
#line 7
this.RequiredGLAccountsExist("Notes Receivable", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Other Receivables")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Other Receivables")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Other Receivables")]
        public virtual void RequiredGLAccountsExist_OtherReceivables()
        {
#line 7
this.RequiredGLAccountsExist("Other Receivables", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: TOTAL ACCOUNTS RECEIVABLE")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "TOTAL ACCOUNTS RECEIVABLE")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "TOTAL ACCOUNTS RECEIVABLE")]
        public virtual void RequiredGLAccountsExist_TOTALACCOUNTSRECEIVABLE()
        {
#line 7
this.RequiredGLAccountsExist("TOTAL ACCOUNTS RECEIVABLE", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Prepaid Expenses")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Prepaid Expenses")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Prepaid Expenses")]
        public virtual void RequiredGLAccountsExist_PrepaidExpenses()
        {
#line 7
this.RequiredGLAccountsExist("Prepaid Expenses", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Prepaid Insurance")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Prepaid Insurance")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Prepaid Insurance")]
        public virtual void RequiredGLAccountsExist_PrepaidInsurance()
        {
#line 7
this.RequiredGLAccountsExist("Prepaid Insurance", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Advances")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Advances")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Advances")]
        public virtual void RequiredGLAccountsExist_Advances()
        {
#line 7
this.RequiredGLAccountsExist("Advances", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: Prepaid Commissions")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "Prepaid Commissions")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "Prepaid Commissions")]
        public virtual void RequiredGLAccountsExist_PrepaidCommissions()
        {
#line 7
this.RequiredGLAccountsExist("Prepaid Commissions", ((string[])(null)));
#line hidden
        }
        
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethodAttribute()]
        [Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute("Required GL Accounts exist: TOTAL OTHER CURRENT ASSETS")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("FeatureTitle", "ChartOfAccountsConfiguration")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("VariantName", "TOTAL OTHER CURRENT ASSETS")]
        [Microsoft.VisualStudio.TestTools.UnitTesting.TestPropertyAttribute("Parameter:AccountName", "TOTAL OTHER CURRENT ASSETS")]
        public virtual void RequiredGLAccountsExist_TOTALOTHERCURRENTASSETS()
        {
#line 7
this.RequiredGLAccountsExist("TOTAL OTHER CURRENT ASSETS", ((string[])(null)));
#line hidden
        }
    }
}
#pragma warning restore
#endregion


<|start_filename|>DynamicsFinOps/FinOpsConfigurationValidation/DynamicsOdata/UriExtensions.cs<|end_filename|>
﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DynamicsOdata
{
    public static class UriExtensions
    {
        public static Uri Combine(this Uri uriCurrent, params string[]  uriParts)
        {
            string uri = uriCurrent.ToString();
            if (uriParts != null && uriParts.Count() > 0)
            {
                char[] trims = new char[] { '\\', '/' };
                uri = (uri ?? string.Empty).TrimEnd(trims);
                for (int i = 0; i < uriParts.Count(); i++)
                {
                    uri = string.Format("{0}/{1}", uri.TrimEnd(trims), (uriParts[i] ?? string.Empty).TrimStart(trims));
                }
            }
            return new Uri( uri);

        }
    }
}


<|start_filename|>source/JmeterPipelineValidationTests/JmeterPipelineValidationTests/appsettings.json<|end_filename|>
{
  "jmeterLogFileName": "__ResultsFolder__\loadtestresults\jmeter.log",
  "statisticsFileName": "__ResultsFolder__\loadtestresults\statistics.json",
  "expectedKoMax": "5.0"
}


<|start_filename|>parameterize/DetectParams/DetectParams/Program.cs<|end_filename|>
﻿using System;
using System.Xml;
using System.IO;
using System.Xml.Linq;
using System.Linq;
using System.Linq.Expressions;
using System.Collections.Generic;
namespace DetectParams
{
    class Program
    {
        static void Main(string[] args)
        {
            string filename = "floodio.xml";
            string xmlString = File.ReadAllText(filename).Replace("\r\n", "\n");

            var xElement = XElement.Parse(xmlString);
            System.Collections.Generic.IEnumerable<object> items = from item in xElement.DescendantNodes()
                                                                   where item.ToString().Contains(@"amFwcG1DMFhKYk00aVFsZkJOZ1VCUT09LS1QUWlOaElaR1ltMG9NVkcvVlhQTWZ3PT0=--63516119f76973f97525468ca67c52f17b6ac394")
                                                                   select item;
             Console.WriteLine("Hello World!");
        }
    }
}


<|start_filename|>DynamicsFinOps/FinOpsConfigurationValidation/DynamicsOdataTests/ConfigurationBuilderTests.cs<|end_filename|>
﻿using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace DynamicsOdataTests
{
    [TestClass]
    public class ConfigurationBuilderTests
    {
        [TestMethod]
        public void VerifySetting()
        {

            //arrange
            string expectedValue = "from configbuilder";
            string actualValue = "not from configbuilder";
            //act
#pragma warning disable CS0618 // Type or member is obsolete
            actualValue = System.Configuration.ConfigurationSettings.AppSettings["TestConfig"];
#pragma warning restore CS0618 // Type or member is obsolete
                              //assert
            Assert.AreEqual(actualValue, expectedValue);
        }
    }
}


<|start_filename|>jmeter/jmr.cmd<|end_filename|>
jmeter -t %1%

<|start_filename|>source/JmeterPipelineValidationTests/JmeterPipelineValidationTests/JMeterLogTests.cs<|end_filename|>
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.IO;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;

namespace JmeterPipelineValidationTests
{
    [TestClass]
    public class JMeterLogTests
    {

        [TestMethod]
        public void AutoStopListenerDidNotFire()
        {

            //arrange
            string failMessage = "AutoStop: Sending StopTestNow request to port 4445";
            //act
            Assert.IsTrue(File.Exists(Config.Configuration["jmeterLogFileName"]));
            string jmeterLogFileName = Config.Configuration["jmeterLogFileName"];
            var logFileContents = File.ReadAllText(jmeterLogFileName);
            bool failedMessageFound = logFileContents.Contains(failMessage);
            //assert
            Assert.IsTrue(!failedMessageFound);
        }

        [TestMethod]
        public void ErrorPercentageLessThanTarget()
        {

            //arrange
            string statisticsFileName = Config.Configuration["statisticsFileName"];
            string expectedMaxString = Config.Configuration["expectedKoMax"];
            float expectedMax;
            float.TryParse(expectedMaxString,out expectedMax);
            
            //act
            JObject rss = JObject.Parse(File.ReadAllText(statisticsFileName));
            float errorPercentage;
            string errorPercentageString = (string) rss["Total"]["errorPct"];
            float.TryParse(errorPercentageString, out errorPercentage);
            bool koIsOk = errorPercentage < expectedMax;
            //assert
            Assert.IsTrue(koIsOk);
        }
    }
}


<|start_filename|>DynamicsFinOps/FinOpsConfigurationValidation/DynamicsOdata/FinOpsRSS.cs<|end_filename|>
﻿using Microsoft.IdentityModel.Clients.ActiveDirectory;
using Newtonsoft.Json.Linq;
using System;
using System.IO;
using System.Net;

namespace DynamicsOdata
{
    public class FinOpsRSS
    {
        public string ActiveDirectoryTenant { get; set; }
        public string ActiveDirectoryResource { get; set; } 
        public string ActiveDirectoryClientAppId { get; set; }
        public string AzureSecret { get; set; }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="azureSecret"></param>
        /// <param name="axFinOpsUri"></param>
        /// <param name="clientAppId"></param>
        /// <param name="aDTenant"></param>
        public FinOpsRSS()
        {
            
        }
        public JObject GetJsonRss(string entity)
        {

            Uri odataEntityUri = new Uri(ActiveDirectoryResource).Combine("data", entity);
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(odataEntityUri);
            request.Method = "GET";
            AuthenticationContext authenticationContext = new AuthenticationContext(ActiveDirectoryTenant);
            var credential = new ClientCredential(ActiveDirectoryClientAppId, AzureSecret);
            AuthenticationResult authenticationResult = authenticationContext.AcquireTokenAsync(ActiveDirectoryResource, credential).Result;
            request.Headers["Authorization"] = authenticationResult.CreateAuthorizationHeader();
            JObject rss = null;
            using (var response = (HttpWebResponse)request.GetResponse())
            using (var stream = response.GetResponseStream())
            using (var sr = new StreamReader(stream))
            {
                rss = JObject.Parse(sr.ReadToEnd());

            }
            return rss;
        }
    }
}
