C# UnitTesting.TestContext类代码示例

 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 }
     };
 }