public static void MyClassInitialize(TestContext testContext)
 {
     testStrings = new List<string>();
     testStrings.AddRange(File.ReadLines("..\\..\\..\\..\\Test\\CoApp\\Toolkit\\Extensions\\TestStrings.txt"));
     Files = new List<string>();
     Files.AddRange(File.ReadLines("..\\..\\..\\..\\Test\\CoApp\\Toolkit\\Extensions\\FileList.txt"));
 }

        public static void SetUp(TestContext context)
        {
            _unitOfWork = new UnitOfWork();
            var memberFactory = new MemberFactory();

            _email = Guid.NewGuid().ToString();

            _decorator = new MemberDecorator(memberFactory, _unitOfWork.MemberRepository);

            _oldCount = _unitOfWork.MemberRepository.Count();
            _member = memberFactory.CreateMember(_email);
            _sameMember = memberFactory.CreateMember(_email);

            _decorator.Add(_member);
            _unitOfWork.PersistAll();

            using (var uow = new UnitOfWork())
            {
                _newCount = uow.MemberRepository.Count();
                try
                {
                    _loadedMember = uow.MemberRepository.Get(_member.Id);
                }
                catch (Exception)
                {
                    _loadedMember = null;
                }
            }
        }

 public static void MyClassInitialize(TestContext testContext)
 {
     var structureFileData = "FirstPackage/\n" +
                             "FirstPackage/Unix/\n" +
                             "FirstPackage/Unix/tags/\n" +
                             "FirstPackage/Unix/tags/FirstVersion/\n" +
                             "FirstPackage/Unix/tags/FirstVersion/metadata.xml\n" +
                             "FirstPackage/Unix/tags/FirstVersion/testp.zip\n" +
                             "FirstPackage/Unix/tags/SecondVersion/\n" +
                             "FirstPackage/Unix/tags/SecondVersion/metadata.xml\n" +
                             "FirstPackage/Unix/tags/SecondVersion/testp.zip\n" +
                             "FirstPackage/Unix/trunk/\n" +
                             "FirstPackage/Unix/trunk/metadata.xml\n" +
                             "FirstPackage/Unix/trunk/testp.zip\n" +
                             "FirstPackage/Windows/\n" +
                             "FirstPackage/Windows/tags/\n" +
                             "FirstPackage/Windows/tags/ProtoVersion/\n" +
                             "FirstPackage/Windows/tags/ProtoVersion/metadata.xml\n" +
                             "FirstPackage/Windows/tags/ProtoVersion/testp.zip\n" +
                             "FirstPackage/Windows/tags/SecondVersion/\n" +
                             "FirstPackage/Windows/tags/SecondVersion/metadata.xml\n" +
                             "FirstPackage/Windows/tags/SecondVersion/testp.zip\n" +
                             "FirstPackage/Windows/tags/ThirdVersion/\n" +
                             "FirstPackage/Windows/tags/ThirdVersion/metadata.xml\n" +
                             "FirstPackage/Windows/tags/ThirdVersion/testp.zip\n" +
                             "FirstPackage/Windows/trunk/\n" +
                             "FirstPackage/Windows/trunk/metadata.xml\n" +
                             "FirstPackage/Windows/trunk/testp.zip\n";
     File.WriteAllText(path, structureFileData);
 }

        public static void SetUp(TestContext context)
        {
            _unitOfWork = new UnitOfWork();
            _memberFactory = new MemberFactory();
            _gomeeFactory = new GomeeFactory();
            _targetFactory = new TargetFactory();
            _targetDecorator = new TargetDecorator(_targetFactory, _unitOfWork.TargetRepository);

            _member = _memberFactory.CreateMember(Guid.NewGuid().ToString());
            _gomee = _gomeeFactory.CreateGomee(_member);
            _targets = new List<Target>();

            using (var uow = new UnitOfWork())
            {
                uow.MemberRepository.Add(_member);
                uow.GomeeRepository.Add(_gomee);

                var count = new Random().Next(2, 5);
                for (var i = 0; i < count; i++)
                {
                    var target = _targetFactory.CreateGomeeTarget(_member, _gomee);
                    _targets.Add(target);
                    uow.TargetRepository.Add(target);
                }

                uow.PersistAll();
            }

            _loadedTargets = _targetDecorator.GetFor(_unitOfWork.GomeeRepository.Get(_gomee.Id));
        }

		public static void InitializeAssembly(TestContext ctx)
		{
			// Setup the test database based on setting in the
			// configuration file
			SqlDatabaseTestClass.TestService.DeployDatabaseProject();
			SqlDatabaseTestClass.TestService.GenerateData();
		}

        public static void InitClass(TestContext context)
        {
            dataSource = new TestDataSource();
            ScarfConfiguration.DataSourceFactory = new TestDataSourceFactory(dataSource);

            ScarfConfiguration.ConfigurationSection = ConfigurationMocks.CreateNewScarfSectionMock().Object;
        }

        public static void MyClassInitialize(TestContext testContext)
        {
            Greyscale conv = new Greyscale();
            testBitmap = new Bitmap(testPixel, testPixel);
            for (int height = 0; height < testBitmap.Height; height++)
            {
                for (int width = 0; width < testBitmap.Width; width++)
                {
                    testBitmap.SetPixel(width, height, Color.White);
                    width++;
                    testBitmap.SetPixel(width, height, Color.Black);
                    width++;
                    testBitmap.SetPixel(width, height, Color.Red);
                    width++;
                    testBitmap.SetPixel(width, height, Color.Green);
                    width++;
                    testBitmap.SetPixel(width, height, Color.Blue);
                }
            }

            //create greyscale
            double[] newColorValues = new double[3];
            for (int i = 0; i < newColorValues.GetLength(0); i++)
            {
                newColorValues[i] = 1;
            }
            fullGrey = new Memento("Blur", newColorValues);

            //get greyscaled Bitmap
            original = conv.getMemento();
            conv.setMemento(fullGrey);
            processedBitmap = conv.process(testBitmap);
            conv.setMemento(original);
        }

        public static void AssemblyInit(TestContext context)
        {
            Configuration.Instance.Init();
            Program.Init();

            File.Delete(Configuration.Instance.PrimaryDatabaseName);
        }

 public static void Init(TestContext tctx)
 {
     using (var fs = new FileStream("Config\\AwsS3HandlerParams.json", FileMode.Open))
     {
         _handlerParams = JsonHelper.Load<Config.AwsS3HandlerParams>(fs);
     }
 }

 public static void PlatformClientInitialize(TestContext testContext)
 {
     clientStabA = new PlatformClientStub(new System.Net.CookieContainer());
     clientStabA.AtValue = "initDt_AtValue";
     clientStabA.EjxValue = "initDt_EjxValue";
     clientStabA.PvtValue = "initDt_PvtValue";
 }

 public static void StartupSpotSharp(TestContext context)
 {
     // Ok, so.. turns out libspotify has issues shutting down/restart in the same process.
     // This means in order to test SpotSharp we will start and login to one instance at
     // the start of testing.
     spotSharp = new SpotSharp.SpotSharp(_spotifyApiKey);
 }

        public static void MyClassInitialize(TestContext testContext)
        {
            ObjectFactory.Inject<IEnvironment>(new Environment());
            ObjectFactory.Inject<IDatabaseConnection>(new DatabaseConnection());

            _environment = ObjectFactory.GetInstance<IEnvironment>();
        }

 public UseCase(string name, TestContext testContext)
 {
     this.name = name;
     ctx = testContext;
     fileList = new List<string>();
     actions = new List<Action>();
 }

        public static void MyClassInitialize(TestContext testContext)
        {
            _tasks = new[]
            {
                new TestTask(Priority.High),
                new TestTask(Priority.High),
                new TestTask(Priority.Normal),
                new TestTask(Priority.Low)
            };

            _lowtasks = new[]
            {
                new TestTask(Priority.Low),
                new TestTask(Priority.Low)
            };

            _normallowtasks = new[]
            {
                new TestTask(Priority.Low),
                new TestTask(Priority.Normal)
            };

            _highlowtasks = new[]
            {
                new TestTask(Priority.Low),
                new TestTask(Priority.High)
            };
        }

 public static void MyClassInitialize(TestContext testContext) 
 {
     List<TestData> testData = TestDataSet.LoadFromXMLFile("TestData.xml");
     TestData = new Dictionary<string, TestData>();
     for (int i = 0; i < testData.Count; i++)
     {
         TestData.Add(testData[i].Name, testData[i]);
     }
     AggregateLookup = new Dictionary<AggregateType, NodeId>()
     {
         { AggregateType.AnnotationCount, Opc.Ua.ObjectIds.AggregateFunction_AnnotationCount },
         { AggregateType.Average, Opc.Ua.ObjectIds.AggregateFunction_Average },
         { AggregateType.Count, Opc.Ua.ObjectIds.AggregateFunction_Count },
         { AggregateType.Delta, Opc.Ua.ObjectIds.AggregateFunction_Delta },
         { AggregateType.DurationBad, Opc.Ua.ObjectIds.AggregateFunction_DurationBad },
         { AggregateType.DurationGood, Opc.Ua.ObjectIds.AggregateFunction_DurationGood },
         { AggregateType.DurationInState0, Opc.Ua.ObjectIds.AggregateFunction_DurationInStateZero},
         { AggregateType.DurationInState1, Opc.Ua.ObjectIds.AggregateFunction_DurationInStateNonZero},
         { AggregateType.End, Opc.Ua.ObjectIds.AggregateFunction_End },
         { AggregateType.Interpolative, Opc.Ua.ObjectIds.AggregateFunction_Interpolative },
         { AggregateType.Max, Opc.Ua.ObjectIds.AggregateFunction_Maximum },
         { AggregateType.MaxActualTime, Opc.Ua.ObjectIds.AggregateFunction_MaximumActualTime },
         { AggregateType.Min, Opc.Ua.ObjectIds.AggregateFunction_Minimum },
         { AggregateType.MinActualTime, Opc.Ua.ObjectIds.AggregateFunction_MinimumActualTime },
         { AggregateType.NumberOfTransitions, Opc.Ua.ObjectIds.AggregateFunction_NumberOfTransitions },
         { AggregateType.PercentBad, Opc.Ua.ObjectIds.AggregateFunction_PercentBad },
         { AggregateType.PercentGood, Opc.Ua.ObjectIds.AggregateFunction_PercentGood },
         { AggregateType.Range, Opc.Ua.ObjectIds.AggregateFunction_Range },
         { AggregateType.Start, Opc.Ua.ObjectIds.AggregateFunction_Start },
         { AggregateType.TimeAverage, Opc.Ua.ObjectIds.AggregateFunction_TimeAverage },
         { AggregateType.Total, Opc.Ua.ObjectIds.AggregateFunction_Total },
         { AggregateType.TotalizeAverage, Opc.Ua.ObjectIds.AggregateFunction_Total2},
         { AggregateType.WorstQuality, Opc.Ua.ObjectIds.AggregateFunction_WorstQuality }
     };
 }

		public static void MyClassInitialize(TestContext testContext)
		{
			if (!Directory.Exists(Utility.RootFolder))
			{
				Directory.CreateDirectory(Utility.RootFolder);
			}
			if (!Directory.Exists(Utility.TempFolder))
			{
				Directory.CreateDirectory(Utility.TempFolder);
			}
			_mXmlNs = Utility.NS;
			_mOnGenerator = new OneNoteGenerator(Utility.RootFolder);
			//Get Id of the test notebook so we chould retrieve generated content
			//KindercareFormatConverter will create notebookName as Kindercare
			_mNotebookId = _mOnGenerator.CreateNotebook(NotebookName);

			var word = new Application();
			var doc = word.Application.Documents.Add();

			//add pages to doc
			for (int i = 1; i < DocPageTitles.Count; i++)
			{
				doc.Content.Text += DocPageTitles[i];
				doc.Words.Last.InsertBreak(WdBreakType.wdPageBreak);
			}

			var filePath = TestDocPath as object;
            doc.SaveAs(ref filePath);
            ((_WordDocument)doc).Close();
            ((_WordApplication)word).Quit();
		}

 public static void TestClassSetup(TestContext context)
 {
     _configuration = new Configuration();
     _configuration.Configure();
     _configuration.AddAssembly(typeof(Draft).Assembly);
     _sessionFactory = _configuration.BuildSessionFactory();
 }

 public static void Init(TestContext x)
 {
     OpenQA.Selenium.Firefox.FirefoxDriver fd = new OpenQA.Selenium.Firefox.FirefoxDriver();
     Browsers.Add(fd);
     OpenQA.Selenium.Chrome.ChromeDriver cd = new OpenQA.Selenium.Chrome.ChromeDriver();
     Browsers.Add(cd);
 }

        public static void ClassInit(TestContext context)
        {
            SetTestSettings();

            if (defaultAzureSubscription.Equals(null))
            {
                Assert.Inconclusive("No Subscription is selected!");
            }

            vhdBlobLocation = blobUrlRoot + vhdBlob;
            try
            {
                vmPowershellCmdlets.AddAzureVhd(new FileInfo(localFile), vhdBlobLocation);
            }
            catch (Exception e)
            {
                if (e.ToString().Contains("already exists"))
                {
                    // Use the already uploaded vhd.
                    Console.WriteLine("Using already uploaded blob..");
                }
                else
                {
                    throw;
                }
            }
        }

        public static void ClassInit(TestContext context)
        {
            _startingHandCombos = new Dictionary<string, WeightedStartingHandCombo>();
            _startingHandPermutations = new Dictionary<string, WeightedStartingHandCombo>();

            //All starting hands match a regular expression after ToString is called
            List<Card> cards = new List<Card>();
            foreach (Rank r in (Rank[])Enum.GetValues(typeof(Rank)))
            {
                foreach (Suit s in (Suit[])Enum.GetValues(typeof(Suit)))
                {
                    cards.Add(new Card(r, s));
                }
            }

            for (int iFirstCard = 0; iFirstCard < 52; iFirstCard++)
            {
                for (int iSecondCard = iFirstCard + 1; iSecondCard < 52; iSecondCard++)
                {
                    WeightedStartingHandCombo hand = new WeightedStartingHandCombo(cards[iFirstCard], cards[iSecondCard], 1);
                    _startingHandCombos.Add(hand.ToString(false), hand);
                    _startingHandPermutations.Add(hand.ToString(), hand);

                    WeightedStartingHandCombo handOppOrder = new WeightedStartingHandCombo(cards[iSecondCard], cards[iFirstCard], 1);
                    _startingHandPermutations.Add(handOppOrder.ToString(), handOppOrder);
                }
            }

            Assert.IsTrue(_startingHandCombos.Count == (52 * 51) / 2, "Incorrect number of combo's.");
            Assert.IsTrue(_startingHandPermutations.Count == 52 * 51, "Incorrect number of permutations.");
        }