static void Main(string[] args)
        {
            var endOfRec = DateTime.Now.Add(TimeSpan.FromSeconds(30));
            using (var writer = new AviWriter("test.avi")
            {
                FramesPerSecond = 15,
                EmitIndex1 = true
            })
            {
                var stream = writer.AddVideoStream();

                stream.Width = Screen.PrimaryScreen.WorkingArea.Width;
                stream.Height = Screen.PrimaryScreen.WorkingArea.Height;
                stream.Codec = KnownFourCCs.Codecs.Uncompressed;
                stream.BitsPerPixel = BitsPerPixel.Bpp32;

                var googleChrome = new TestCase();

                Task.Factory.StartNew(() =>
                {
                    googleChrome.Scenario("http://www.google.com", "что посмотреть сегодня?");
                });

                var buffer = new byte[Screen.PrimaryScreen.WorkingArea.Width * Screen.PrimaryScreen.WorkingArea.Height * 4];
                while (!TestCase.isFinished)
                {
                    GetScreenshot(buffer);
                    stream.WriteFrame(true, buffer, 0, buffer.Length);
                }
            }

            Console.WriteLine("Execution Done");
        }
        public IEnumerable<Violation> Apply(TestCase testCase)
        {
            var calledAssertingMethods = testCase.GetCalledAssertingMethods();
            var tracker = new MethodValueTracker(testCase.TestMethod);

            // For each asserting method with >= 1 parameters:
            foreach (var cm in calledAssertingMethods)
            {
                var methodRef = cm.MethodReference;
                var parameterPurposes = testCase.Framework.GetParameterPurposes(methodRef);
                if (!IsSingleTruthCheckingMethod(methodRef, parameterPurposes))
                    continue;

                foreach (var valueGraph in tracker.ValueGraphs)
                {
                    IList<MethodValueTracker.Value> consumedValues =
                        tracker.GetConsumedValues(valueGraph, cm.Instruction).ToList();
                    if (consumedValues.Count == 0)
                        continue; // not part of value graph
                    var interestingValue = consumedValues[0];
                    var producers = UltimateProducers(interestingValue);
                    if (producers.Count > 1)
                    {
                        yield return new Violation(this, testCase, cm.Instruction, string.Format("{0}.{1} performs a boolean test on a composite boolean value",
                            cm.MethodReference.DeclaringType.Name,
                            cm.MethodReference.Name));
                    }
                }
            }
        }
        private ObjectModel.TestResult CreateTest(TestData test, TestStepRun stepRun, TestCase testCase)
        {
            ObjectModel.TestResult testResult = new ObjectModel.TestResult(testCase);
            testResult.DisplayName = test.Name;
            testResult.ErrorLineNumber = test.CodeLocation.Line;
            //testResult.ErrorStackTrace
            testResult.StartTime = stepRun.StartTime;
            if (stepRun.TestLog.Streams.Count > 0)
            {
                testResult.ErrorMessage = stepRun.TestLog.Streams[0].ToString();
            }
            testResult.EndTime = stepRun.EndTime;

            testResult.Duration = stepRun.Result.Duration;

            var testStatus = stepRun.Result.Outcome.Status;
            switch (testStatus)
            {
                case TestStatus.Passed:
                    testResult.Outcome = ObjectModel.TestOutcome.Passed;
                    break;
                case TestStatus.Failed:
                    testResult.Outcome = ObjectModel.TestOutcome.Failed;
                    break;
                case TestStatus.Skipped:
                    testResult.Outcome = ObjectModel.TestOutcome.Skipped;
                    break;
                case TestStatus.Inconclusive:
                    testResult.Outcome = ObjectModel.TestOutcome.NotFound;
                    break;
            }

            return testResult;
        }
Beispiel #4
0
 public TestFailed(Exception ex)
 {
     TestCase = new TestCase();
     ExceptionType = ex.GetType().FullName;
     Message = ExceptionUtility.GetMessage(ex);
     StackTrace = ExceptionUtility.GetStackTrace(ex);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="TestCaseFull" /> class.
 /// </summary>
 /// <param name="testCase">The test case.</param>
 /// <param name="testSteps">The test steps.</param>
 /// <param name="mostRecentResult">The most recent result.</param>
 /// <param name="executionComment">The execution comment.</param>
 public TestCaseFull(TestCase testCase, List<TestStep> testSteps, string mostRecentResult, string executionComment)
 {
     this.TestCase = testCase;
     this.TestSteps = testSteps;
     this.MostRecentResult = mostRecentResult;
     this.ExecutionComment = executionComment;
 }
        private void DoTest(TestCase test)
        {
            var canvas = new Canvas();
            canvas.Width = 300;
            canvas.Height = 700;
            ICanvasRenderingContext2D ctx = new CanvasRenderingContext2D(canvas, this, true);
            string url = test(ctx);
            ctx.commit();
            string location = Application.ResourceAssembly.Location;
            string path = location.Remove(location.LastIndexOf("\\"));

            var di = new DirectoryInfo(path);
            url = di.Parent.Parent.Parent.FullName + "\\SharpCanvas.Tests\\" + url;
            if (File.Exists(url))
            {
                pctOriginal.Source = new BitmapImage(new Uri(url));
                pctOriginal.Visibility = Visibility.Visible;
            }
            else
            {
                pctOriginal.Visibility = Visibility.Hidden;
            }
            ctResults.Children.Clear();
            ctResults.Children.Add(canvas);
        }
Beispiel #7
0
        private void WriteTestCase(string outputDirectory, TestCase currentTestCase)
        {
            EnsureDirectoryExists(outputDirectory);

            File.WriteAllText(Path.Combine(outputDirectory, currentTestCase.Name + ".txt"), currentTestCase.Content);
            File.WriteAllText(Path.Combine(outputDirectory, currentTestCase.Name + ".json"), currentTestCase.Json);
        }
        static TextWriter tw; //= new StreamReader("A-small-attempt3.in");

        #endregion Fields

        #region Methods

        static void Main(string[] args)
        {
            tr = new StreamReader("C-large-1.in");

            int n = Convert.ToInt16(tr.ReadLine());
            List<TestCase> testCases = new List<TestCase>();

            for (; i < n; i++)
            {
                TestCase t = new TestCase();
                string[] temp2 = tr.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                //string[] temp2 = temp.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                t.lowLimit = Convert.ToInt64(temp2[0]);
                t.upperLimit = Convert.ToInt64(temp2[1]);
                testCases.Add(t.processInput());

            }
            tw = new StreamWriter("output.txt");
            i = 0;
            for (; i < testCases.Count-1; i++)
            {
                tw.WriteLine("Case #{0}: {1}", (i + 1), testCases[i].output);
            }
            tw.Write("Case #{0}: {1}", (i + 1), testCases[i].output);
            tr.Close();
            tw.Close();
            //Console.ReadLine();
        }
        public object PropertyProvider(TestCase testCase, string name)
        {
            // Traits filtering
            if (knownTraits.Contains(name))
            {
                var result = new List<string>();

                foreach (var trait in GetTraits(testCase))
                    if (string.Equals(trait.Key, name, StringComparison.OrdinalIgnoreCase))
                        result.Add(trait.Value);

                if (result.Count > 0)
                    return result.ToArray();
            }
            else
            {
                // Handle the displayName and fullyQualifierNames independently
                if (string.Equals(name, FullyQualifiedNameString, StringComparison.OrdinalIgnoreCase))
                    return testCase.FullyQualifiedName;
                if (string.Equals(name, DisplayNameString, StringComparison.OrdinalIgnoreCase))
                    return testCase.DisplayName;
            }

            return null;
        }
Beispiel #10
0
 private void bAddUnitTest_Click(object sender, RoutedEventArgs e)
 {
     TestCase tc = new TestCase();
     tc.UT = new UnitTest("?unittest", 0, 0, 0, 0, "a"); // Create blank unit test, and pass it to dialog.
     tc.ShowDialog();
     Singleton.GetSingleton().unitTestSuite.unitTests.Add(tc.UT); // Add test case created in dialog.
 }
 public TestCaseRuleApplication(TestCase testCase, IRule rule, IViolationScorer scorer)
 {
     _scorer = scorer;
     TestCase = testCase;
     Rule = rule;
     Apply();
 }
Beispiel #12
0
        private void DoTest(TestCase test)
        {
            if (animation.IsStarted)
                animation.Stop();

            Graphics g = ctResults.Panel1.CreateGraphics();
            //this.CreateGraphics();
            g.Clear(Color.White);
            var bmp = new Bitmap((int) g.VisibleClipBounds.Width, (int) g.VisibleClipBounds.Height);
            Graphics tmp = Graphics.FromImage(bmp);
            var ctx = new CanvasRenderingContext2D(tmp, bmp, new Pen(Color.Black, 1), new Fill(Color.Black), false);
            string url = test(ctx);
            g.DrawImage(bmp, 0, 0);
            var di = new DirectoryInfo(Application.StartupPath);
            url = di.Parent.Parent.Parent.FullName + "\\SharpCanvas.Tests\\" + url;
            if (File.Exists(url))
            {
                pctOriginal.Load(url);
                pctOriginal.Show();
            }
            else
            {
                pctOriginal.Hide();
            }
        }
Beispiel #13
0
        public void DelayTestCaseTest()
        {
            DeleteFiles();
            int stepDelayDuration = 500;
            var step = new DelayStep();
            step.DelayMilliSeconds = stepDelayDuration;

            var sw = new Stopwatch();
            sw.Start();

            step.Execute(new Context());

            var actualDuration = sw.ElapsedMilliseconds;
            Console.WriteLine("Observed delay: {0}", actualDuration);
            Assert.AreEqual(stepDelayDuration, actualDuration, 20);

            stepDelayDuration = 5;
            step.DelayMilliSeconds = stepDelayDuration;

            var tc = new TestCase();
            tc.ExecutionSteps.Add(step);

            TestCase.SaveToFile(tc, "DelayTestCaseTest.xaml");
            var bu = new BizUnit(TestCase.LoadFromFile("DelayTestCaseTest.xaml"));

            sw = new Stopwatch();
            sw.Start();

            bu.RunTest();

            actualDuration = sw.ElapsedMilliseconds;
            Console.WriteLine("Observed delay: {0}", actualDuration);
            Assert.AreEqual(actualDuration, stepDelayDuration, 20);
        }
Beispiel #14
0
        // TODO: Write a constructor that takes an out argument of type
        //       TestCase and a second argument of type in that
        //       will have the test case number. This constructor will
        //       determine which test case to encapsulate inside of
        //       the delegate.
        internal TestCases(out TestCase testCaseDelegate, int testCaseNumber)
        {
            _timeToWaitGenerator = new Random(DateTime.Now.Millisecond);

            switch (testCaseNumber)
            {
                case 0:
                    testCaseDelegate = new TestCase(RunAllTestCases);
                    break;

                case 1:
                    testCaseDelegate = new TestCase(TestCase1);
                    break;

                case 2:
                    testCaseDelegate = new TestCase(TestCase2);
                    break;

                case 3:
                    testCaseDelegate = new TestCase(TestCase3);
                    break;

                default:
                    Console.WriteLine("WARNING: Invalid case number {0} specified. Defaulting to ALL.", testCaseNumber);
                    testCaseDelegate = new TestCase(RunAllTestCases);
                    break;
            }
        }
        public static IEnumerable<TestCase> GetTests(IEnumerable<string> sourceFiles, ITestCaseDiscoverySink discoverySink)
        {
            var tests = new List<TestCase>();

            Parallel.ForEach(sourceFiles, s =>
            {
                var sourceCode = File.ReadAllText(s);

                var matches = TestFinderRegex.Matches(sourceCode);
                foreach (Match m in matches)
                {
                    var methodParts = m.Groups["Method"].Value.Split(new string[] { ".prototype." }, System.StringSplitOptions.None);
                    var testClass = methodParts[0];
                    var testMethod = methodParts[1];
                    var testName = m.Groups["Name"].Value;
                    var testDescription = m.Groups["Description"].Value;
                    var testCase = new TestCase(String.Join(".", methodParts), TSTestExecutor.ExecutorUri, s)
                    {
                        CodeFilePath = s,
                        DisplayName = testName,
                    };

                    if (discoverySink != null)
                    {
                        discoverySink.SendTestCase(testCase);
                    }
                    tests.Add(testCase);
                }
            });

            return tests;
        }
Beispiel #16
0
        internal static IList<TestCase> GetTests(IEnumerable<string> sources, ITestCaseDiscoverySink discoverySink = null, ITestContainer testContainer = null)
        {
            IList<TestCase> tests = new List<TestCase>();

            foreach (var assemblyFileName in sources)
            {
                Assembly assembly = Assembly.LoadFrom(assemblyFileName);

                var methodsWithMoyaAttributes = assembly.GetTypes()
                      .SelectMany(t => t.GetMethods())
                      .Where(Reflection.MethodInfoHasMoyaAttribute)
                      .ToArray();

                foreach (MethodInfo methodWithMoyaAttributes in methodsWithMoyaAttributes)
                {
                    var testCase = new TestCase(methodWithMoyaAttributes.Name, Constants.ExecutorUri, assemblyFileName)
                    {
                        Id = Guid.NewGuid()
                    };

                    tests.Add(testCase);
                    if (discoverySink != null)
                    {
                        discoverySink.SendTestCase(testCase);
                    }
                    if (testContainer != null)
                    {
                        testContainer.AddTestCaseAndMethod(testCase, methodWithMoyaAttributes);
                    }
                }
            }

            return tests;
        }
        public void RunAllTestsInDocument_ShouldExtractAllProjectReferences_And_PassItTo_TestSandbox()
        {
            // arrange
            var project = CreateProject("SampleTestsProject");
            string[] allProjectReferences = { "A" };

            _solutionExplorerMock.GetAllProjectReferences(project.Name).Returns(allProjectReferences);
            var testNode = CSharpSyntaxTree.ParseText("[TestFixture]class HelloWorldTests{" +
                                             " [Test] public void TestMethod()" +
                                             "{}" +
                                             "}");

            var testClass = testNode.GetRoot().GetClassDeclarationSyntax();
            var fixtureDetails = new TestFixtureDetails();
            var testCase = new TestCase(fixtureDetails) { SyntaxNode = testClass.GetPublicMethods().Single() };
            fixtureDetails.Cases.Add(testCase);

            _testExtractorMock.GetTestClasses(Arg.Any<CSharpSyntaxNode>())
                .Returns(new[] { testClass });
            _testExtractorMock.GetTestFixtureDetails(testClass, Arg.Any<ISemanticModel>()).Returns(fixtureDetails);

            var rewrittenDocument = new RewrittenDocument(testNode, null, false);

            // act
            _sut.RunAllTestsInDocument(rewrittenDocument, null, project, new string[0]);

            // assert
            _testExecutorEngineMock.Received(1).
                RunTestFixture(Arg.Is<string[]>(x => x[0] == allProjectReferences[0]), Arg.Any<TestFixtureExecutionScriptParameters>());
        }
        private void RunTest(ITestExecutionRecorder frameworkHandle, string source, string spec = null)
        {
            var results = appDomainRunner.ExecuteSpecifications(source, spec);
            var query = from result in results
                        from @group in result.Examples
                        from example in @group.Examples
                        select example;

            foreach (var example in query) {
                var testCase = new TestCase(example.Reason, ExecutorUri, source) {
                    CodeFilePath = source
                };

                frameworkHandle.RecordStart(testCase);
                var testResult = new TestResult(testCase) {
                    DisplayName = example.Reason,
                    Duration = new TimeSpan(example.ElapsedTime),
                };

                if (example.Status == ResultStatus.Error) {
                    testResult.Outcome = TestOutcome.Failed;
                    testResult.ErrorMessage = example.Message;
                    testResult.ErrorStackTrace = example.StackTrace;
                }

                if (example.Status == ResultStatus.Success) {
                    testResult.Outcome = TestOutcome.Passed;
                }

                frameworkHandle.RecordEnd(testCase, testResult.Outcome);
                frameworkHandle.RecordResult(testResult);
            }
        }
        public TestCase GetTestCase(TestData testData)
        {
            string displayName;

            var fullName = testData.FullName;

            var pos = fullName.LastIndexOf('/');

            if (pos == -1)
            {
                displayName = testData.CodeReference.MemberName;
            }
            else
            {
                displayName = fullName.Substring(pos + 1);
            }

            var testCase = new TestCase(fullName, new Uri(GallioAdapter.ExecutorUri), GetSource(testData))
            {
                CodeFilePath = testData.CodeLocation.Path,
                LineNumber = testData.CodeLocation.Line,
                DisplayName = displayName
            };

            testCase.SetPropertyValue(testIdProperty, testData.Id);

            return testCase;
        }
        public void RunAllTestsInDocument_ShouldExtractAllTestCases()
        {
            // arrange
            var project = CreateProject("SampleTestsProject");
            var semanticModel = Substitute.For<ISemanticModel>();

            var testNode = CSharpSyntaxTree.ParseText("[TestFixture]class HelloWorldTests{" +
                                             " [Test] public void TestMethod()" +
                                             "{}" +
                                             "}");

            var testClass = testNode.GetRoot().GetClassDeclarationSyntax();
            var fixtureDetails = new TestFixtureDetails();
            var testCase = new TestCase(fixtureDetails) { SyntaxNode = testClass.GetPublicMethods().Single() };
            fixtureDetails.Cases.Add(testCase);

            _testExtractorMock.GetTestClasses(Arg.Any<CSharpSyntaxNode>())
                .Returns(new[] { testClass });

            _testExtractorMock.GetTestFixtureDetails(Arg.Any<ClassDeclarationSyntax>(), Arg.Any<ISemanticModel>()).Returns(fixtureDetails);
            var rewrittenDocument = new RewrittenDocument(testNode, null, false);

            // act
            _sut.RunAllTestsInDocument(rewrittenDocument, semanticModel, project, new string[0]);

            // assert
            _testExtractorMock.Received(1).GetTestFixtureDetails(testClass, semanticModel);
        }
internal static IEnumerable<TestCase> GetTests(IEnumerable<string> sources, ITestCaseDiscoverySink discoverySink)
        {
            //if(!Debugger.IsAttached)
            //        Debugger.Launch();
            var tests = new List<TestCase>();

               
                foreach (string source in sources)
                {
                    var TestNames = GetTestNameFromFile(source);
                    foreach (var testName in TestNames)
                    {
                        var normalizedSource = source.ToLowerInvariant();
                        var testCase = new TestCase(testName.Key, ProtractorTestExecutor.ExecutorUri, normalizedSource);
                        tests.Add(testCase);
                        testCase.CodeFilePath = source;
                        testCase.LineNumber = testName.Value;

                        if (discoverySink != null)
                        {

                            discoverySink.SendTestCase(testCase);
                        }
                    }
                }
                        return tests;
        }
Beispiel #22
0
        private void btnAdd_Click(object sender, RoutedEventArgs e)
        {
            string newTestName;
            for (int testId = 1; ; ++testId)
            {
                newTestName = "case" + testId;
                if (!TestCases.Any(t => StringComparer.CurrentCultureIgnoreCase.Equals(newTestName, t.Name)))
                {
                    break;
                }
            }

            var newTestCase = new TestCase
            {
                Name = newTestName,
                Input = "",
                Output = "",
                IsSkipped = false,
                OutputIsKnown = true,
            };

            TestCases.Add(newTestCase);
            lstTestCases.Items.Add(newTestCase);
            lstTestCases.SelectedItem = newTestCase;
        }
        public void DiscoverTests(IEnumerable<string> sources, 
                                  IDiscoveryContext discoveryContext, 
                                  IMessageLogger logger, 
                                  ITestCaseDiscoverySink discoverySink)
        {
            var validSources = from source in sources
                               where source.EndsWith(StringHelper.GetSearchExpression(), StringComparison.CurrentCultureIgnoreCase)
                               select source;

            foreach (var source in validSources) {
                var results = appDomainRunner.ExecuteSpecifications(source);
                var query = from result in results
                            from @group in result.Examples
                            from example in @group.Examples
                            select example;

                foreach (var example in query) {
                    var testCase = new TestCase(example.Reason, DefaultTestExecutor.ExecutorUri, source) {
                        CodeFilePath = example.FileName,
                        LineNumber = example.LineNumber
                    };
                    discoverySink.SendTestCase(testCase);
                }
            }
        }
        public void WhenRunningTestsProvidingAssemblySources_ShouldDiscoverAndRunTestsInAssembly()
        {
            TestGeneratorAdapter adapter = CreateTestGeneratorAdapter();

            TestCase testCase1 = new TestCase("#1", TestGeneratorAdapter.ExecutorUri, "Source1")
            {
                LocalExtensionData = new TestContext(testGenerator, new Test("#1"))
            };

            TestCase testCase2 = new TestCase("#1", TestGeneratorAdapter.ExecutorUri, "Source1")
            {
                LocalExtensionData = new TestContext(testGenerator, new Test("#1"))
            };

            TestCase testCase3 = new TestCase("#1", TestGeneratorAdapter.ExecutorUri, "Source1")
            {
                LocalExtensionData = new TestContext(testGenerator, new Test("#1"))
            };

            testGeneratorDiscoverer.Discover(Arg.Any<IEnumerable<string>>(), Arg.Any<IMessageLogger>())
                .Returns(new TestCase[] { testCase1, testCase2, testCase3 });

            adapter.RunTests(new string[] { "Some Source" }, runContext, frameworkHandle);

            frameworkHandle.Received(3).RecordResult(Arg.Is<TestResult>(result => result.TestCase.DisplayName == "#1"));
        }
		public bool IsEnabled (TestCase test)
		{
			var attr = test.Attribute as HttpClientTestAttribute;
			if (attr == null)
				return false;
			return (attr.Target & HttpClientTestTarget.Default) != 0;
		}
    public override void AddAll(TestCase test)
    {
        // Do like super's
        base.AddAll(test);

        // If test invalid
        if (null == test) {
            // Error
            throw new Exception("Invalid test case encountered.");
        }

        // For each method in the test case
        Type type = test.GetType();
        foreach (MethodInfo method in type.GetMethods()) {
            // For each unit test attribute
            foreach (System.Object obj in method.GetCustomAttributes(typeof(CoroutineUnitTest), false)) {
                // If attribute is valid
                Attribute testAtt = obj as Attribute;
                if (null != testAtt) {
                    // If type has constructors
                    ConstructorInfo[] ci = type.GetConstructors();
                    if (0 < ci.Length) {
                        // Add the test
                        TestCase tmp = ci[0].Invoke(null) as TestCase;
                        tmp.SetTestMethod(method.Name);
                        coroutineTests.Add(tmp);
                    }
                }
            }
        }
    }
        public void AddChildToTestCase()
        {
            TestSuite master = new TestSuite("master", null);
            TestCase test = new TestCase("test", master);

            test.AddChild(new TestCase());
        }
        public override TestResult Run(TestCase testCase)
        {
            DateTime start = DateTime.Now;
            FileLoader.Load(testCase.Instance, this._data);
            TimeSpan elapsed = DateTime.Now - start;

            return new TestResult(elapsed, testCase.Instance.Triples.Count, "Triples/Second");
        }
 private static NaplTestCase SerializeTestCase(TestCase testCase)
 {
     var res = new NaplTestCase();
     res.arguments.AddRange(testCase.Arguments.Select(SerializeTestValue));
     res.expected_result = SerializeTestValue(testCase.ExpectedResult);
     res.description = testCase.Description;
     return res;
 }
Beispiel #30
0
        public void ConvertToTestCommandWithNullMethodThrows()
        {
            Action<TimeZone> dummyAction = _ => { };
            var sut = new TestCase<TimeZone>(dummyAction);

            Assert.Throws<ArgumentNullException>(
                () => sut.ConvertToTestCommand(null));
        }
 public async Task IntT_InMem_AccessToken_Get_Expired()
 {
     await TestCase.AccessToken_Get_Expired().ConfigureAwait(false);
 }
Beispiel #32
0
        public static IEnumerable <string> GetCategories(this TestCase testCase)
        {
            var categories = testCase.GetPropertyValue(CategoryList.NUnitTestCategoryProperty) as string[];

            return(categories);
        }
 public async Task IntT_InMem_AccessToken_GetOrAdd_WithUser()
 {
     await TestCase.AccessToken_GetOrAdd_WithUser().ConfigureAwait(false);
 }
        public void BTA226_CDIS_GetMemberPromotion_Positive()
        {
            testCase        = new TestCase(TestContext.TestName);
            listOfTestSteps = new List <TestStep>();
            testStep        = new TestStep();
            String stepName = "";
            int    index    = 0;

            try
            {
                Logger.Info("Test Method Started");
                Common common = new Common(this.DriverContext);
                CDIS_Service_Methods cdis_Service_Method = new CDIS_Service_Methods(common);

                testStep = TestStepHelper.StartTestStep(testStep);
                stepName = "Adding member with CDIS service";
                Member output = cdis_Service_Method.GetCDISMemberGeneral();
                testStep.SetOutput("IpCode: " + output.IpCode + ", Name: " + output.FirstName);
                Logger.Info("IpCode:" + output.IpCode + ",Name:" + output.FirstName);
                testStep = TestStepHelper.EndTestStep(testCase, testStep, stepName, true, DriverContext.SendScreenshotImageContent("API"));
                listOfTestSteps.Add(testStep);

                IList <VirtualCard> vc = output.GetLoyaltyCards();

                testStep = TestStepHelper.StartTestStep(testStep);
                stepName = "Getting Promotion Definitions from Service";
                if (cdis_Service_Method.GetActivePromotionsDefinitionsCount() < 15)
                {
                    index = 0;
                }
                else
                {
                    index = cdis_Service_Method.GetActivePromotionsDefinitionsCount() - 10;
                }
                PromotionDefinitionStruct[] def    = cdis_Service_Method.GetPromotionDefinitionsRecent(index);
                PromotionDefinitionStruct   promot = new PromotionDefinitionStruct();
                foreach (PromotionDefinitionStruct pd in def)
                {
                    if (pd.Targeted)
                    {
                        promot = pd;
                        break;
                    }
                }
                Logger.Info("Promotion to be added " + promot.Name);
                testStep.SetOutput("The Targerted Promotion: " + promot.Name + " will be added to the member; Name: " + output.FirstName);
                testStep = TestStepHelper.EndTestStep(testCase, testStep, stepName, true, DriverContext.SendScreenshotImageContent("API"));
                listOfTestSteps.Add(testStep);


                testStep = TestStepHelper.StartTestStep(testStep);
                stepName = "Adding Promotion to a member from Service";
                MemberPromotionStruct promotionCode = cdis_Service_Method.AddMemberPromotion(vc[0].LoyaltyIdNumber, promot.Code);
                testStep.SetOutput("The Targerted Promotion: " + promot.Name + " with Promotion ID : " + promotionCode.Id + " has been added to member: " + output.FirstName);
                Logger.Info("MemberPromotion Code : " + promotionCode.Id);
                testStep = TestStepHelper.EndTestStep(testCase, testStep, stepName, true, DriverContext.SendScreenshotImageContent("API"));
                listOfTestSteps.Add(testStep);

                testStep = TestStepHelper.StartTestStep(testStep);
                stepName = "Verify newly added Promotion from GetMemberpromotions";
                GetMemberPromotionsOut memberPromotions = cdis_Service_Method.GetMemberPromotions(vc[0].LoyaltyIdNumber);
                testStep.SetOutput("Expected value (promotion code from response) is: " + memberPromotions.MemberPromotion[0].Id + " and the actual value (promotion which was added through AddMemberPromotion) is" + promotionCode.Id);
                Assert.AreEqual(promotionCode.Id, memberPromotions.MemberPromotion[0].Id, "Expected value (promotion code from response) is" + memberPromotions.MemberPromotion[0].Id + "Actual value (promotion which was added through AddMemberPromotion) is" + promotionCode.Id);
                Logger.Info("MemberPromotion Code : " + memberPromotions.MemberPromotion[0].Id);
                testStep = TestStepHelper.EndTestStep(testCase, testStep, stepName, true, DriverContext.SendScreenshotImageContent("API"));
                listOfTestSteps.Add(testStep);

                testStep = TestStepHelper.StartTestStep(testStep);
                stepName = "Validating the response from database";
                String dbresponse = DatabaseUtility.GetMemberPromotionsCodeUsingIdFromDBSOAP(output.IpCode + "");
                testStep.SetOutput("Member Promotion Code from database:" + dbresponse);
                Assert.AreEqual(memberPromotions.MemberPromotion[0].Id + "", dbresponse, "Expected value is" + memberPromotions.MemberPromotion[0].Id + "Actual value is" + dbresponse);
                testStep = TestStepHelper.EndTestStep(testCase, testStep, stepName, true, DriverContext.SendScreenshotImageContent("API"));
                listOfTestSteps.Add(testStep);

                testCase.SetStatus(true);
            }
            catch (Exception e)
            {
                testStep = TestStepHelper.EndTestStep(testCase, testStep, stepName, false, DriverContext.SendScreenshotImageContent("API"));
                listOfTestSteps.Add(testStep);
                testCase.SetStatus(false);
                testCase.SetErrorMessage(e.Message);
                Assert.Fail(e.Message);
            }
            finally
            {
                testCase.SetTestCaseSteps(listOfTestSteps);
                testCase.SetEndTime(new StringHelper().GetFormattedDateTimeNow());
                listOfTestCases.Add(testCase);
            }
        }
Beispiel #35
0
 public static void AddTrait(this TestCase testCase, string name, string value)
 {
     testCase?.Traits.Add(new Trait(name, value));
 }
 public async Task IntT_InMem_AccessToken_Delete_ByUser_And_Feature()
 {
     await TestCase.AccessToken_Delete_ByUser_And_Feature().ConfigureAwait(false);
 }
Beispiel #37
0
 public TestCaseSandbox(TestCase testCase)
     : this(testCase, NPath.SystemTemp)
 {
 }
 public void RecordStart(TestCase testCase)
 {
 }
Beispiel #39
0
        // NOTE: These constructors are protected internal to allow 3rd parties to
        //       do unit testing of their data collectors.
        //
        //       We do not want to make the constructors of this class public as it
        //       would lead to a great deal of user error when they start creating
        //       their own data collection context instances to log errors/warnings
        //       or send files with.  The potential for this type of error still
        //       exists by having the protected constructor, but it is less likely
        //       and we have added safeguards in our DataCollectinLogger and
        //       DataCollectionDataSink to safeguard against derived types being
        //       passed to us.
        //
        //       In order to create mock instances of the DataCollectionContext for
        //       unit testing purposes, 3rd parties can derive from this class and
        //       have public constructors.  This will allow them to instantiate their
        //       class and pass to us for creating data collection events.

        /// <summary>
        /// Constructs DataCollection Context for in process data collectors
        /// </summary>
        /// <param name="testCase">test case to identify the context</param>
        public DataCollectionContext(TestCase testCase)
        {
            this.TestCase = testCase;
        }
 private static void TestCase_OnExecutionBegin(TestCase testCase, TestCaseBeginExecutionArgs args)
 {
     LogEvent.Info(message: $"Beginning test case execution \"{testCase.Title}\"");
 }
 public void RecordEnd(TestCase testCase, TestOutcome outcome)
 {
 }
Beispiel #42
0
 public void SendTestCase(TestCase discoveredTest)
 {
     Tests.Add(discoveredTest);
 }
 public async Task IntT_InMem_AccessToken_AssertExists_Missing()
 {
     await TestCase.AccessToken_AssertExists_Missing().ConfigureAwait(false);
 }
Beispiel #44
0
        public void Test(
            [ValueSource(nameof(TestCases))] TestCase testCase,
            [ValueSource(nameof(BufferSizes))] BufferSize bufferSize)
        {
            var configMock = new Mock <IConfig>();

            int usingBufferSize = LargeBufferSize;

            if (bufferSize < BufferSize.Large)
            {
                usingBufferSize = sizeof(ulong);
                if (bufferSize != BufferSize.Min)
                {
                    ++usingBufferSize;
                }
            }

            configMock
            .SetupGet(o => o.UsingBufferLength)
            .Returns(usingBufferSize);

            var physicalBufferLength =
                usingBufferSize + Consts.BufferReadingEnsurance;

            configMock
            .SetupGet(o => o.PhysicalBufferLength)
            .Returns(physicalBufferLength);

            ISortingSegmentsSupplier sortingSegmentsSupplier =
                new SortingSegmentsSupplier(
                    configMock.Object);

            var lineIndexesExtractorMock =
                new Mock <ILinesIndexesExtractor>();

            IGroupSorter groupSorter =
                new GroupSorter(
                    sortingSegmentsSupplier,
                    lineIndexesExtractorMock.Object);

            var groupBytesCount   = testCase.GroupBytes.Length;
            var groupBuffersCount = (int)Math.Ceiling((double)
                                                      groupBytesCount / usingBufferSize);

            var buffersCount = BuffersOffset
                               + groupBuffersCount
                               + OverBuffersCount;

            byte[][] buffers = Enumerable
                               .Range(0, buffersCount)
                               .Select(_ => new byte[physicalBufferLength])
                               .ToArray();

            for (int i = 0; i < groupBuffersCount - 1; i++)
            {
                Array.Copy(testCase.GroupBytes, i * usingBufferSize,
                           buffers[BuffersOffset + i], 0,
                           usingBufferSize);
            }

            Array.Copy(testCase.GroupBytes, (groupBuffersCount - 1) * usingBufferSize,
                       buffers[BuffersOffset + groupBuffersCount - 1], 0,
                       groupBytesCount % usingBufferSize);

            var lines    = new LineIndexes[LinesStorageLength];
            var segments = new ulong[LinesStorageLength];

            var groupMock = new Mock <IGroup>();

            groupMock
            .SetupGet(o => o.BytesCount)
            .Returns(groupBytesCount);

            groupMock
            .SetupGet(o => o.Buffers)
            .Returns(new ArraySegment <byte[]>(
                         buffers,
                         BuffersOffset,
                         groupBuffersCount));
            groupMock
            .SetupGet(o => o.Lines)
            .Returns(new ArraySegment <LineIndexes>(
                         lines,
                         LinesRangeOffset,
                         testCase.InputLines.Length));
            groupMock
            .SetupGet(o => o.SortingSegments)
            .Returns(new ArraySegment <ulong>(
                         segments,
                         LinesRangeOffset,
                         testCase.InputLines.Length));

            lineIndexesExtractorMock
            .Setup(o => o.ExtractIndexes(groupMock.Object))
            .Callback(() => Array.Copy(testCase.InputLines, 0,
                                       lines, LinesRangeOffset,
                                       testCase.InputLines.Length));

            groupSorter.Sort(groupMock.Object);

            var resultLines = lines
                              .Skip(LinesRangeOffset)
                              .Take(testCase.InputLines.Length)
                              .Select(o => o.Start)
                              .ToArray();

            // Console.WriteLine(string.Join(" ", testCase.ExpectedSortedLines));
            // Console.WriteLine(string.Join(" ", resultLines));

            CollectionAssert.AreEqual(
                testCase.ExpectedSortedLines,
                resultLines);
        }
 public async Task IntT_InMem_AccessToken_Get_ForUserContentAndFeature()
 {
     await TestCase.AccessToken_Get_ForUserContentAndFeature().ConfigureAwait(false);
 }
 public async Task IntT_InMem_AccessToken_Create_ForUser_ValueLength()
 {
     await TestCase.AccessToken_Create_ForUser_ValueLength().ConfigureAwait(false);
 }
 public async Task IntT_InMem_AccessToken_Create_ForUserAndContent()
 {
     await TestCase.AccessToken_Create_ForUserAndContent().ConfigureAwait(false);
 }
 public async Task IntT_InMem_AccessToken_UpdateMissing()
 {
     await TestCase.AccessToken_UpdateMissing().ConfigureAwait(false);
 }
Beispiel #49
0
 public TestCaseCompilationMetadataProvider(TestCase testCase, AssemblyDefinition fullTestCaseAssemblyDefinition)
     : base(testCase, fullTestCaseAssemblyDefinition)
 {
 }
Beispiel #50
0
        public void DesignModeClientWithRunSelectedTestCasesShouldDeserializeTestsWithTraitsCorrectly()
        {
            // Arrange.
            var testCase = new TestCase("A.C.M", new Uri("d:\\executor"), "A.dll");

            testCase.Traits.Add(new Trait("foo", "bar"));

            var testList = new System.Collections.Generic.List <TestCase> {
                testCase
            };
            var testRunPayload = new TestRunRequestPayload {
                RunSettings = null, TestCases = testList
            };

            var getProcessStartInfoMessage = new Message
            {
                MessageType = MessageType.TestRunSelectedTestCasesDefaultHost,
                Payload     = JToken.FromObject("random")
            };

            var sessionEnd = new Message {
                MessageType = MessageType.SessionEnd
            };
            TestRunRequestPayload receivedTestRunPayload = null;
            var allTasksComplete = new ManualResetEvent(false);

            // Setup mocks.
            this.mockCommunicationManager.Setup(cm => cm.WaitForServerConnection(It.IsAny <int>())).Returns(true);
            this.mockCommunicationManager.Setup(cm => cm.DeserializePayload <TestRunRequestPayload>(getProcessStartInfoMessage))
            .Returns(testRunPayload);
            this.mockTestRequestManager.Setup(
                trm =>
                trm.RunTests(
                    It.IsAny <TestRunRequestPayload>(),
                    It.IsAny <ITestHostLauncher>(),
                    It.IsAny <ITestRunEventsRegistrar>(),
                    It.IsAny <ProtocolConfig>()))
            .Callback(
                (TestRunRequestPayload trp,
                 ITestHostLauncher testHostManager,
                 ITestRunEventsRegistrar testRunEventsRegistrar,
                 ProtocolConfig config) =>
            {
                receivedTestRunPayload = trp;
                allTasksComplete.Set();
            });
            this.mockCommunicationManager.SetupSequence(cm => cm.ReceiveMessage())
            .Returns(getProcessStartInfoMessage)
            .Returns(sessionEnd);

            // Act.
            this.designModeClient.ConnectToClientAndProcessRequests(0, this.mockTestRequestManager.Object);

            // wait for the internal spawned of tasks to complete.
            allTasksComplete.WaitOne(1000);

            // Assert.
            Assert.IsNotNull(receivedTestRunPayload);
            Assert.IsNotNull(receivedTestRunPayload.TestCases);
            Assert.AreEqual(1, receivedTestRunPayload.TestCases.Count);

            // Validate traits
            var traits = receivedTestRunPayload.TestCases.ToArray()[0].Traits;

            Assert.AreEqual("foo", traits.ToArray()[0].Name);
            Assert.AreEqual("bar", traits.ToArray()[0].Value);
        }
 public async Task IntT_InMem_AccessToken_Delete_ByContent()
 {
     await TestCase.AccessToken_Delete_ByContent().ConfigureAwait(false);
 }
Beispiel #52
0
 private void testMultibyte(IMac mac, TestCase testCase)
 {
     mac.BlockUpdate(testCase.getAd(), 0, testCase.getAd().Length);
     checkMac(mac, testCase);
 }
 public void InitializeTest()
 {
     this.dataCollectionSink    = new InProcDataCollectionSink();
     this.testCase              = new TestCase("DummyNS.DummyC.DummyM", new Uri("executor://mstest/v1"), "Dummy.dll");
     this.dataCollectionContext = new DataCollectionContext(this.testCase);
 }
Beispiel #54
0
 public void SelectTestCase(TestCase testcase)
 {
     IsCurrent     = false;
     this.testcase = testcase;
     SelectedCaseChanged();
 }
Beispiel #55
0
 public TestCaseSandbox(TestCase testCase, NPath rootTemporaryDirectory)
     : this(testCase, rootTemporaryDirectory, string.Empty)
 {
 }
Beispiel #56
0
 public LtmTestCaseItem(TestCase item)
     : base(item)
 {
 }
Beispiel #57
0
 public TestCaseSandbox(TestCase testCase, string rootTemporaryDirectory, string namePrefix)
     : this(testCase, rootTemporaryDirectory.ToNPath(), namePrefix)
 {
 }
 private static void TestCase_OnExecutionComplete(TestCase testCase, TestCaseResult testCaseResult)
 {
     LogEvent.Info(message: $"Test case execution \"{testCase.Title}\" completed ({testCaseResult.TestVerdict}).");
 }
        public void ExecuteSendPipelineWithDefaultXmlAsmWithImportedSchemaTest()
        {
            // Create test case...
            var tc = new TestCase {
                Name = "ExecuteSendPipelineWithDefaultXmlAsmWithImportedSchemaTest"
            };

            var pipeStep = new ExecuteSendPipelineStep
            {
                PipelineAssemblyPath =
                    @"..\..\..\..\Test\BizUnit.BizTalkTestArtifacts\bin\Debug\BizUnit.BizTalkTestArtifacts.dll",
                PipelineTypeName = "BizUnit.BizTalkTestArtifacts.SendPipeline1"
            };
            var ds = new DocSpecDefinition
            {
                AssemblyPath =
                    @"..\..\..\..\Test\BizUnit.BizTalkTestArtifacts\bin\Debug\BizUnit.BizTalkTestArtifacts.dll",
                TypeName = "BizUnit.BizTalkTestArtifacts.Schema0"
            };

            pipeStep.DocSpecs.Add(ds);
            ds = new DocSpecDefinition
            {
                AssemblyPath =
                    @"..\..\..\..\Test\BizUnit.BizTalkTestArtifacts\bin\Debug\BizUnit.BizTalkTestArtifacts.dll",
                TypeName = "BizUnit.BizTalkTestArtifacts.Schema3Env"
            };
            pipeStep.DocSpecs.Add(ds);
            pipeStep.SourceDir     = @"..\..\..\..\Test\BizUnit.BizTalkTestArtifacts\Instances\";
            pipeStep.SearchPattern = "Child*.xml";
            pipeStep.Destination   = "Output.021.xml";
            // Add ExecuteReceivePipelineStep to test case
            tc.ExecutionSteps.Add(pipeStep);

            var exists = new ExistsStep
            {
                DirectoryPath     = ".",
                Timeout           = 2000,
                SearchPattern     = "Output.021*.xml",
                ExpectedNoOfFiles = 1
            };

            // Add ExistsStep to test case
            tc.ExecutionSteps.Add(exists);

            var fv = new FileReadMultipleStep
            {
                DirectoryPath = ".",
                SearchPattern = "Output.021.xml",
                DeleteFiles   = false
            };

            var validation = new XmlValidationStep();
            var sd         = new SchemaDefinition
            {
                XmlSchemaPath      = @"..\..\..\..\Test\BizUnit.BizTalkTestArtifacts\Schema0.xsd",
                XmlSchemaNameSpace = "http://BizUnit.BizTalkTestArtifacts.Schema0"
            };

            validation.XmlSchemas.Add(sd);
            sd = new SchemaDefinition
            {
                XmlSchemaPath      = @"..\..\..\..\Test\BizUnit.BizTalkTestArtifacts\Schema3Env.xsd",
                XmlSchemaNameSpace = "http://BizUnit.BizTalkTestArtifacts.Schema3Env"
            };
            validation.XmlSchemas.Add(sd);
            // Add validation to FileReadMultipleStep
            fv.SubSteps.Add(validation);
            // Add FileReadMultipleStep to test case
            tc.ExecutionSteps.Add(exists);

            TestCase.SaveToFile(tc, "ExecuteSendPipelineWithDefaultXmlAsmWithImportedSchemaTest.xaml");

            // Execute test csse using serialised test case to test round tripping of serialisation...
            var bu =
                new BizUnit(TestCase.LoadFromFile("ExecuteSendPipelineWithDefaultXmlAsmWithImportedSchemaTest.xaml"));

            bu.RunTest();
        }
        public List <TestResult> CollectTestResults(IEnumerable <TestCase> testCasesRun, string testExecutable, string resultXmlFile, List <string> consoleOutput, TestCase crashedTestCase)
        {
            var testResults = new List <TestResult>();

            TestCase[] arrTestCasesRun = testCasesRun as TestCase[] ?? testCasesRun.ToArray();

            if (testResults.Count < arrTestCasesRun.Length)
            {
                CollectResultsFromXmlFile(arrTestCasesRun, testExecutable, resultXmlFile, testResults);
            }

            var consoleParser = new StandardOutputTestResultParser(arrTestCasesRun, consoleOutput, _logger);

            if (testResults.Count < arrTestCasesRun.Length)
            {
                CollectResultsFromConsoleOutput(consoleParser, testResults);
            }

            if (testResults.Count < arrTestCasesRun.Length)
            {
                if (crashedTestCase == null)
                {
                    crashedTestCase = consoleParser.CrashedTestCase;
                }

                var remainingTestCases = arrTestCasesRun
                                         .Where(tc => !testResults.Exists(tr => tr.TestCase.FullyQualifiedName == tc.FullyQualifiedName))
                                         .ToArray();

                if (crashedTestCase != null)
                {
                    CreateMissingResults(remainingTestCases, crashedTestCase, testResults);
                }
                else
                {
                    ReportSuspiciousTestCases(remainingTestCases, testResults);
                }
            }

            return(testResults);
        }