Esempio n. 1
0
        public void DataSerializerShouldRoundTripDateTimeOffset()
        {
            var source = new DateTimeOffset(628381323438126060, TimeSpan.FromHours(-8));

            var actual = DataSerializationHelper.Deserialize(
                DataSerializationHelper.Serialize(new object[] { source }));

            actual.Should().HaveCount(1);
            actual[0].Should().BeOfType <DateTimeOffset>();
            actual[0].As <DateTimeOffset>().Should().Be(source);
        }
Esempio n. 2
0
        public void DataSerializerShouldRoundTripDateTimeOfKindUtc()
        {
            var source = new DateTime(628381323438126060, DateTimeKind.Utc);

            var actual = DataSerializationHelper.Deserialize(
                DataSerializationHelper.Serialize(new object[] { source }));

            actual.Should().HaveCount(1);
            actual[0].Should().BeOfType <DateTime>();
            actual[0].As <DateTime>().Should().Be(source);
            actual[0].As <DateTime>().Kind.Should().Be(source.Kind);
        }
Esempio n. 3
0
        internal UnitTestResult[] RunTestMethod()
        {
            Debug.Assert(this.test != null, "Test should not be null.");
            Debug.Assert(this.testMethodInfo.TestMethod != null, "Test method should not be null.");

            List <UTF.TestResult> results = new List <UTF.TestResult>();
            var isDataDriven = false;

            if (this.testMethodInfo.TestMethodOptions.Executor != null)
            {
                if (this.test.DataType == DynamicDataType.ITestDataSource)
                {
                    var data        = DataSerializationHelper.Deserialize(this.test.SerializedData);
                    var testResults = this.ExecuteTestWithDataSource(null, data);
                    results.AddRange(testResults);
                }
                else if (this.ExecuteDataSourceBasedTests(results))
                {
                    isDataDriven = true;
                }
                else
                {
                    var testResults = this.ExecuteTest(this.testMethodInfo);

                    foreach (var testResult in testResults)
                    {
                        if (string.IsNullOrWhiteSpace(testResult.DisplayName))
                        {
                            testResult.DisplayName = this.test.DisplayName;
                        }
                    }

                    results.AddRange(testResults);
                }
            }
            else
            {
                PlatformServiceProvider.Instance.AdapterTraceLogger.LogError(
                    "Not able to get executor for method {0}.{1}",
                    this.testMethodInfo.TestClassName,
                    this.testMethodInfo.TestMethodName);
            }

            // Get aggregate outcome.
            var aggregateOutcome = this.GetAggregateOutcome(results);

            this.testContext.SetOutcome(aggregateOutcome);

            // Set a result in case no result is present.
            if (!results.Any())
            {
                results.Add(new UTF.TestResult()
                {
                    Outcome = aggregateOutcome, TestFailureException = new TestFailedException(UnitTestOutcome.Error, Resource.UTA_NoTestResult)
                });
            }

            // In case of data driven, set parent info in results.
            if (isDataDriven)
            {
                results = this.UpdateResultsWithParentInfo(results, Guid.NewGuid());
            }

            return(results.ToArray().ToUnitTestResults());
        }