Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder, IMessageSink diagnosticMessageSink) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); Guard.FileExists("xunitExecutionAssemblyPath", xunitExecutionAssemblyPath); DiagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); appDomain = new RemoteAppDomainManager(assemblyFileName ?? xunitExecutionAssemblyPath, configFileName, shadowCopy, shadowCopyFolder); var testFrameworkAssemblyName = GetTestFrameworkAssemblyName(xunitExecutionAssemblyPath); // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) assemblyInfo = appDomain.CreateObject<IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); framework = appDomain.CreateObject<ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider, DiagnosticMessageSink); discoverer = Framework.GetDiscoverer(assemblyInfo); }
/// <summary> /// Initializes a new instance of the <see cref="TestFrameworkProxy"/> class. /// </summary> /// <param name="testAssemblyObject">The test assembly (expected to implement <see cref="IAssemblyInfo"/>).</param> /// <param name="sourceInformationProviderObject">The source information provider (expected to implement <see cref="ISourceInformationProvider"/>).</param> public TestFrameworkProxy(object testAssemblyObject, object sourceInformationProviderObject) { var testAssembly = (IAssemblyInfo)testAssemblyObject; var sourceInformationProvider = (ISourceInformationProvider)sourceInformationProviderObject; Type testFrameworkType = typeof(XunitTestFramework); try { var attr = testAssembly.GetCustomAttributes(typeof(TestFrameworkAttribute)).FirstOrDefault(); if (attr != null) { var ctorArgs = attr.GetConstructorArguments().Cast<string>().ToArray(); testFrameworkType = Reflector.GetType(ctorArgs[1], ctorArgs[0]); } } catch { // TODO: Log environmental error } try { testFramework = (ITestFramework)Activator.CreateInstance(testFrameworkType); } catch { // TODO: Log environmental error testFramework = new XunitTestFramework(); } SourceInformationProvider = sourceInformationProvider; }
Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); #if !ANDROID Guard.ArgumentValid("xunitExecutionAssemblyPath", "File not found: " + xunitExecutionAssemblyPath, File.Exists(xunitExecutionAssemblyPath)); #endif appDomain = new RemoteAppDomainManager(assemblyFileName ?? xunitExecutionAssemblyPath, configFileName, shadowCopy, shadowCopyFolder); #if !ANDROID var name = AssemblyName.GetAssemblyName(xunitExecutionAssemblyPath); var testFrameworkAssemblyName = name.FullName; #else var name = Assembly.Load(xunitExecutionAssemblyPath); var testFrameworkAssemblyName = name.FullName; #endif // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) assemblyInfo = appDomain.CreateObject<IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); framework = appDomain.CreateObject<ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider); discoverer = Framework.GetDiscoverer(assemblyInfo); }
MockCSharpProject CreateCSharpProjectSupportedByTestFramework() { MockCSharpProject project = CreateCSharpProjectNotSupportedByTestFramework(); fakeTestFramework = MockRepository.GenerateStrictMock<ITestFramework>(); fakeTestFramework.Stub(f => f.IsTestProject(project)).Return(true); return project; }
MockCSharpProject CreateCSharpProjectNotSupportedByTestFramework() { var project = new MockCSharpProject(); project.FileName = FileName.Create(@"d:\projects\MyProject\MyProject.csproj"); fakeTestFramework = MockRepository.GenerateStrictMock<ITestFramework>(); fakeTestFramework.Stub(f => f.IsTestProject(project)).Return(false); return project; }
public static void Throw(string message) { if (testFramework == null) { testFramework = DetectFramework(); } testFramework.Throw(message); }
public static void Throw(string message) { if (testFramework == null) { testFramework = FindStrategy(); } testFramework.Throw(message); }
/// <inheritdoc/> public void Assert(ITestFramework testFramework, object value, string messagePrefix) { if (value == null) { value = string.Empty; } testFramework.IsInstanceOfType(value, typeof(string), $"{messagePrefix} is not a valid String object"); testFramework.AreEqual(ExpectedLength, ((string)value)?.Length ?? 0, $"{messagePrefix} has an unexpected length"); }
public void TearDown() { if (harness != null) { harness.Dispose(); harness = null; framework = null; sampleAssembly = null; } }
public bool IsBuildNeededBeforeTestRunForProject(IProject project) { ITestFramework testFramework = GetTestFrameworkForProject(project); if (testFramework != null) { return(testFramework.IsBuildNeededBeforeTestRun); } return(true); }
public void SetUp() { sampleAssembly = GetSampleAssembly(); harness = new DefaultTestHarness(TestContextTrackerAccessor.GetInstance(), RuntimeAccessor.Instance.Resolve<ILoader>()); framework = CreateFramework(); harness.AddTestFramework(framework); }
public ITestRunner CreateTestDebugger(IProject project) { ITestFramework testFramework = GetTestFrameworkForProject(project); if (testFramework != null) { return(testFramework.CreateTestDebugger()); } return(null); }
public void GetTestFrameworkForProject_MbUnitTestFrameworkRegisteredForUseWithProjectsWithVBNetProjectFileExtension_ReturnsMBUnitTestFramework() { MockCSharpProject project = new MockCSharpProject(); project.FileName = @"d:\projects\test\MyProj.vbproj"; mbUnitTestFramework.AddTestProject(project); ITestFramework testFramework = testFrameworks.GetTestFrameworkForProject(project); Assert.AreEqual(mbUnitTestFramework, testFramework); }
public TestConfiguration( ITestFramework testFramework, string applicationProjectBaseNamespace, string testProjectBaseNamespace, string testProjectBasePath) { TestFramework = testFramework; ApplicationProjectBaseNamespace = applicationProjectBaseNamespace; TestProjectBaseNamespace = testProjectBaseNamespace; TestProjectBasePath = testProjectBasePath; }
private static ITestFramework FindStrategy() { ITestFramework detectedFramework = null; detectedFramework = AttemptToDetectUsingAssemblyScanning(); if (detectedFramework == null) { FailWithIncorrectConfiguration(); } return detectedFramework; }
public FrameworkSet(ITestFramework testFramework, IMockingFramework mockingFramework, IGenerationContext context, string testTypeNaming) { if (string.IsNullOrWhiteSpace(testTypeNaming)) { throw new ArgumentNullException(nameof(testTypeNaming)); } TestFramework = testFramework ?? throw new ArgumentNullException(nameof(testFramework)); MockingFramework = mockingFramework ?? throw new ArgumentNullException(nameof(mockingFramework)); Context = context ?? throw new ArgumentNullException(nameof(context)); TestTypeNaming = testTypeNaming; }
public void TestFrameworkDescriptorTestFrameworkPropertyOnlyCreatesOneObject() { ITestFramework testFramework = descriptor.TestFramework; testFramework = descriptor.TestFramework; List <string> expectedClassNames = new List <string>(); expectedClassNames.Add("UnitTesting.Tests.Utils.MockTestFramework"); Assert.AreEqual(expectedClassNames, mockTestFrameworkFactory.ClassNamesPassedToCreateMethod); }
/// <inheritdoc/> public void Assert(ITestFramework testFramework, object value, string messagePrefix) { testFramework.IsInstanceOfType(value, typeof(DateTime), $"{messagePrefix} is not a valid DateTime object"); DateTime actualDay = GetDateDay((DateTime)value); TimeSpan difference = actualDay - ExpectedDateDay; testFramework.AreEqual(ExpectedDateDay, actualDay, $"{messagePrefix} is different by {{0}}", $"{difference.TotalDays} day{(Math.Abs(difference.TotalDays) == 1 ? "" : "s")}"); }
/// <summary> /// <para>Asserts that the value is correct, according to the expected value.</para> /// <para>Where the expected value is a native type, object equality is used as the test. Where the expected value is an <see cref="IComparison"/> object, the specific <see cref="IComparison"/> assertion logic is used</para> /// </summary> /// <param name="testFramework">The test framework to use for assertions</param> /// <param name="expectedValue">The expected value. This can be either a native type or an <see cref="IComparison"/> object</param> /// <param name="value">The value to test</param> /// <param name="messagePrefix">The prefix of the message to use during assertion failure</param> public static void Assert(ITestFramework testFramework, object expectedValue, object value, string messagePrefix) { expectedValue = expectedValue ?? DBNull.Value; value = value ?? DBNull.Value; if (expectedValue is IComparison comparisonValue) { comparisonValue.Assert(testFramework, value, messagePrefix); } else { testFramework.AreEqual(expectedValue, value, $"{messagePrefix} has an unexpected value"); } }
internal TestFixture(TestSuite suite, ITestFramework framework, AsyncTestFixtureAttribute attr, Type type) { this.Suite = suite; this.Framework = framework; this.Attribute = attr; this.Type = type; IDictionary <Type, TestCategoryAttribute> categories; IList <TestWarning> warnings; Resolve(suite, null, type, out categories, out warnings, out config, out disabled); Categories = categories.Values.ToList().AsReadOnly(); Warnings = warnings; }
public void TestFramework_PropertyAccessTwice_OnlyOneObjectCreated() { CreateDoozer(); ITestFramework testFramework = descriptor.TestFramework; testFramework = descriptor.TestFramework; List <string> expectedClassNames = new List <string>(); expectedClassNames.Add("UnitTesting.Tests.Utils.MockTestFramework"); List <string> classNamesCreated = mockTestFrameworkFactory.ClassNamesPassedToCreateMethod; Assert.AreEqual(expectedClassNames, classNamesCreated); }
Xunit2Discoverer(AppDomainSupport appDomainSupport, ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder, IMessageSink diagnosticMessageSink, bool verifyAssembliesOnDisk) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); #if NET35 || NET452 // Only safe to assume the execution reference is copied in a desktop project if (verifyAssembliesOnDisk) { Guard.FileExists("xunitExecutionAssemblyPath", xunitExecutionAssemblyPath); } CanUseAppDomains = !IsDotNet(xunitExecutionAssemblyPath); #else CanUseAppDomains = false; #endif DiagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); var appDomainAssembly = assemblyFileName ?? xunitExecutionAssemblyPath; appDomain = AppDomainManagerFactory.Create(appDomainSupport != AppDomainSupport.Denied && CanUseAppDomains, appDomainAssembly, configFileName, shadowCopy, shadowCopyFolder); #if NET35 || NET452 var runnerUtilityAssemblyLocation = Path.GetDirectoryName(typeof(AssemblyHelper).Assembly.GetLocalCodeBase()); assemblyHelper = appDomain.CreateObjectFrom <AssemblyHelper>(typeof(AssemblyHelper).Assembly.Location, typeof(AssemblyHelper).FullName, runnerUtilityAssemblyLocation); #endif testFrameworkAssemblyName = GetTestFrameworkAssemblyName(xunitExecutionAssemblyPath); // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) { assemblyInfo = appDomain.CreateObject <IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); } framework = appDomain.CreateObject <ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider, DiagnosticMessageSink); discoverer = Framework.GetDiscoverer(assemblyInfo); }
public static SyntaxTestCasesBuilder For( ICollection <IMethodSignature> signatures, IMethods methods, ITestFramework framework) { if (!signatures.Any()) { return(new SyntaxTestCaseBuilderNoParameters(methods)); } if (framework.TestAssertException().Supported) { return(new SyntaxTestCaseBuilderWrapPartialsWithTryBlock(signatures, methods, framework)); } return(new SyntaxTestCaseBuilderCallPartialDirect(signatures, methods)); }
private static ITestFramework DetectFramework() { ITestFramework detectedFramework = null; detectedFramework = AttemptToDetectUsingAppSetting(); if (detectedFramework == null) { detectedFramework = AttemptToDetectUsingAssemblyScanning(); } if (detectedFramework == null) { FailWithIncorrectConfiguration(); } return(detectedFramework); }
/// <summary> /// Initializes a new instance of the <see cref="AppDomainTestFramework"/> class. /// </summary> /// <param name="sourceInformationProvider">The source code information provider.</param> /// <param name="assemblyFileName">The test assembly.</param> /// <param name="testFrameworkFileName">The file path of the test framework assembly (i.e., xunit2.dll).</param> /// <param name="testFrameworkTypeName">The fully qualified type name of the implementation of <see cref="ITestFramework"/> /// in the test framework assembly.</param> /// <param name="configFileName">The test assembly configuration file.</param> /// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows /// tests to be discovered and run without locking assembly files on disk.</param> public AppDomainTestFramework(ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string testFrameworkFileName, string testFrameworkTypeName, string configFileName = null, bool shadowCopy = true) { Guard.ArgumentNotNull("sourceInformationProvider", sourceInformationProvider); Guard.ArgumentNotNullOrEmpty("testFrameworkFileName", testFrameworkFileName); testFrameworkFileName = Path.GetFullPath(testFrameworkFileName); Guard.ArgumentValid("testFrameworkFileName", "File not found: " + testFrameworkFileName, File.Exists(testFrameworkFileName)); SourceInformationProvider = sourceInformationProvider; // assemblyFileName might be null (during AST-based discovery), so pass along with the test // framework filename instead if we don't have an assembly under test yet. appDomain = new RemoteAppDomainManager(assemblyFileName ?? testFrameworkFileName, configFileName, shadowCopy); testFrameworkAssemblyName = AssemblyName.GetAssemblyName(testFrameworkFileName); testFramework = appDomain.CreateObject <ITestFramework>(testFrameworkAssemblyName.FullName, testFrameworkTypeName); testFramework.SourceInformationProvider = SourceInformationProvider; }
Xunit2Discoverer(ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); Guard.ArgumentValid("xunitExecutionAssemblyPath", "File not found: " + xunitExecutionAssemblyPath, File.Exists(xunitExecutionAssemblyPath)); appDomain = new RemoteAppDomainManager(assemblyFileName ?? xunitExecutionAssemblyPath, configFileName, shadowCopy); var testFrameworkAssemblyName = AssemblyName.GetAssemblyName(xunitExecutionAssemblyPath).FullName; // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) { assemblyInfo = appDomain.CreateObject <IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); } framework = appDomain.CreateObject <ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider); discoverer = Framework.GetDiscoverer(assemblyInfo); }
private static CompilationUnitSyntax AppendUsings( CompilationUnitSyntax syntaxFactory, ClassInformation classInfo, ITestFramework testFramework) { classInfo.AppendUsing(UsingEntry.CreateFrom("Moq")); classInfo.AppendUsing(testFramework.UsingEntry); classInfo.AppendUsing(UsingEntry.CreateFrom(classInfo.NamespaceDecl)); foreach (var usingName in classInfo.SortedUsingEntries) { syntaxFactory = syntaxFactory .AddUsings( SyntaxFactory.UsingDirective( SyntaxFactory.ParseName(usingName.Value))); } return(syntaxFactory); }
private static ITestFramework FindStrategy() { ITestFramework detectedFramework = null; #if !WINRT detectedFramework = AttemptToDetectUsingAppSetting(); #endif if (detectedFramework == null) { detectedFramework = AttemptToDetectUsingAssemblyScanning(); } if (detectedFramework == null) { FailWithIncorrectConfiguration(); } return(detectedFramework); }
private static ITestFramework AttemptToDetectUsingAppSetting() { string frameworkName = ConfigurationManager.AppSettings[AppSettingKey]; if (!string.IsNullOrEmpty(frameworkName) && frameworks.ContainsKey(frameworkName.ToLower())) { ITestFramework framework = frameworks[frameworkName.ToLower()]; if (!framework.IsAvailable) { throw new Exception( "FluentAssertions was configured to use " + frameworkName + " but the required test framework assembly could not be found"); } return(framework); } return(null); }
/// <summary> /// Create an appropriate implementation for the given /// environment. /// </summary> /// <returns>a new <see cref="ITestFramework"/></returns> public ITestFramework NewImplementation() { Type implementationType = getStaticImplementationType(); if (implementationType == null) { implementationType = getDynamicImplementationType(); } if (implementationType == null) { throw new SystemException( "Cannot find an appropriate test framework implementation." ); } ITestFramework implementation = (ITestFramework) _linker.CreateInstance(implementationType); return(implementation); }
Xunit2Discoverer(AppDomainSupport appDomainSupport, ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder, IMessageSink diagnosticMessageSink, bool verifyAssembliesOnDisk) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); if (verifyAssembliesOnDisk) { Guard.FileExists("xunitExecutionAssemblyPath", xunitExecutionAssemblyPath); } #if PLATFORM_DOTNET CanUseAppDomains = false; #else CanUseAppDomains = !IsDotNet(xunitExecutionAssemblyPath); #endif DiagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); var appDomainAssembly = assemblyFileName ?? xunitExecutionAssemblyPath; appDomain = AppDomainManagerFactory.Create(appDomainSupport != AppDomainSupport.Denied && CanUseAppDomains, appDomainAssembly, configFileName, shadowCopy, shadowCopyFolder); var testFrameworkAssemblyName = GetTestFrameworkAssemblyName(xunitExecutionAssemblyPath); // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) { assemblyInfo = appDomain.CreateObject <IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); } framework = appDomain.CreateObject <ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider, DiagnosticMessageSink); discoverer = Framework.GetDiscoverer(assemblyInfo); }
public void AddTestFrameworkForProject(IProject project, ITestFramework testFramework) { testFrameworks.Add(project, testFramework); }
void CreateTestFrameworkIfNotCreated() { if (testFramework == null) { testFramework = (ITestFramework)objectFactory(ClassName); } }
/// <summary> /// Constructor, including the test framework to use and the query result data /// </summary> /// <param name="testFramework">The test framework to use for assertions</param> /// <param name="rawData">The data returned from the query execution</param> public QueryResult(ITestFramework testFramework, DataTable rawData) { TestFramework = testFramework; RawData = rawData ?? new DataTable(); }
/// <summary> /// Constructor, including the test framework to use /// </summary> /// <param name="testFramework">The test framework to use for assertions</param> public QueryResult(ITestFramework testFramework) { TestFramework = testFramework; RawData = new DataTable(); }
public IEnumerable<Violation> Apply(TestCase testCase) { // Store the framework so that we don't have to pass it around everywhere. _framework = testCase.Framework; var calledAssertingMethods = testCase.GetCalledAssertingMethods(); var tracker = new MethodValueTracker(testCase.TestMethod); var whitelistedFields = FindWhitelistedFields(testCase.TestMethod.DeclaringType); // For each asserting method with >= 1 parameters: foreach (var cm in calledAssertingMethods.Where(cm => cm.MethodDefinition.HasParameters)) { var method = cm.MethodDefinition; //TODO: if the method is a helper, we need to "unfold" the helper // to get to the real asserting methods, and this will require us // to join value-generation graphs across method calls... var paramPurposes = _framework.GetParameterPurposes(method); if (paramPurposes == null) continue; // unknown method, rule does not apply 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 // Build a list of arguments with the details we need to know if the rule applies. var arguments = method.Parameters .Select((p, index) => new ArgumentDetails { Method = method, Index = index, Purpose = paramPurposes[index], ConsumedValue = consumedValues[index] }).ToList(); // Handle cases like Assert.IsTrue(x == 5) by expanding arguments ExpandIfSingleTruthCheckingMethod(method, ref arguments); // We're only interested in arguments that represent expectations! var interestingArguments = arguments.Where(a => IsPerhapsExpectation(a.Purpose)).ToList(); // This might happen with for example Assert.Fail("some reason"). if (interestingArguments.Count == 0) continue; // Add in the "forbidden producer", if any, for each argument. A forbidden producer is an // instruction that generates a value externally, such as a call. interestingArguments = interestingArguments.Select( a => { a.ForbiddenProducer = FirstForbiddenProducer(valueGraph, a.ConsumedValue, whitelistedFields); return a; }).ToList(); // If there is at least one locally produced argument, the rule doesn't apply. if (interestingArguments.Any(IsLocallyProduced)) continue; if (interestingArguments.All(a => a.Purpose == ParameterPurpose.ExpectedOrActual)) { // Since we don't know exactly which parameter that represents the expectation, we // just generate a single violation. yield return new Violation(this, testCase, interestingArguments[0].ConsumedValue.Consumer, CreateViolationMessageForUncertainCase(interestingArguments[0])); continue; } foreach (var a in interestingArguments.Where(IsExternallyProduced)) { // Generate a violation at the location of the forbidden producer! yield return new Violation(this, testCase, a.ForbiddenProducer, CreateViolationMessage(a)); } } } }
/// <summary> /// Adds the references. /// </summary> /// <param name="vsProject">The vs project.</param> /// <param name="testFramework">The test framework.</param> private static void AddReferences(VSProject vsProject, ITestFramework testFramework) { if (vsProject != null) { string executingDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); foreach (string reference in testFramework.References) { try { vsProject.References.Add(Path.Combine(executingDirectory, reference)); } catch (Exception ex) { Logger.Write(ex.ToString()); } } } }
void CreateTestFrameworkIfNotCreated() { if (testFramework == null) { testFramework = factory.Create(ClassName); } }
public void Add(string className, ITestFramework framework) { frameworks.Add(className, framework); }
public void CannotCallCreateTestMethodWithInvalidName(ITestFramework testClass) { Assert.Throws <ArgumentNullException>(() => testClass.CreateTestMethod(null, true, false)); }
public void CannotCallCreateTestCaseMethodWithNullValueType(ITestFramework testClass) { Assert.Throws <ArgumentNullException>(() => testClass.CreateTestCaseMethod("TestValue160877669", true, false, default(TypeSyntax), new[] { new object(), new object(), new object() })); }
public void CannotCallCreateTestCaseMethodWithNullTestValues(ITestFramework testClass) { Assert.Throws <ArgumentNullException>(() => testClass.CreateTestCaseMethod("TestValue1054789916", false, true, SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)), default(IEnumerable <object>))); }
public void CannotCallCreateTestCaseMethodWithNullName(ITestFramework testClass) { Assert.Throws <ArgumentNullException>(() => testClass.CreateTestCaseMethod(default(string), true, false, SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword)), new[] { new object(), new object(), new object() })); }
public void CannotCallCreateSetupMethodWithInvalidTargetTypeName(ITestFramework testClass) { Assert.Throws <ArgumentNullException>(() => testClass.CreateSetupMethod(null)); }
internal TestFixture (TestSuite suite, ITestFramework framework, AsyncTestFixtureAttribute attr, Type type) { this.Suite = suite; this.Framework = framework; this.Attribute = attr; this.Type = type; IDictionary<Type, TestCategoryAttribute> categories; IList<TestWarning> warnings; Resolve (suite, null, type, out categories, out warnings, out config, out disabled); Categories = categories.Values.ToList ().AsReadOnly (); Warnings = warnings; }
/// <summary> /// Updates the model. /// </summary> /// <param name="projectItems">The project items.</param> /// <param name="fw">The fw.</param> public static void UpdateModel( ProjectItems projectItems, ITestFramework fw) { for (var i = 1; i < projectItems.Count - 1; i++) { var projectItem = projectItems.Item(i); if (projectItem.Name.EndsWith( ".log", StringComparison.OrdinalIgnoreCase)) continue; var testClass = (from tc in fw.Classes where tc.Name == projectItem.Name.Replace(".cs", "") select tc).FirstOrDefault(); if (testClass == null) { //todo: dump code to log.... continue; } string fileContent; using (var sr = new StreamReader(projectItem.FileNames[0])) { fileContent = sr.ReadToEnd(); } var usingMatches = s_usingRegex.Matches(fileContent); for (var j = 0; j < usingMatches.Count; j++) { var match = usingMatches[j]; if (!testClass.UsingStatements.Contains(match.Value)) { testClass.UsingStatements.Add(match.Value); } } var matches = s_codeRegex.Matches(fileContent); for (var j = 0; j < matches.Count; j++) { var match = matches[j]; if (!match.Success) continue; var testName = match.Groups["testname"].Value; var testAttributes = match.Groups["attributes"].Value; var testImplementation = match.Groups["code"].Value; var test = (from t in testClass.Tests where t.Name == testName select t).FirstOrDefault(); if (test == null) { //todo: dump code to log.... continue; } test.Attributes = testAttributes; test.Implementation = testImplementation; } } }
public RelatedFrameworks(ITestFramework framework, params IMockFramework[] others) { MockFrameworks = others.ToArray(); // make copy TestFramework = framework; }
internal void CheckTestFramework() { ITestFramework newTestFramework = testSolution.testService.GetTestFrameworkForProject(project); if (newTestFramework == oldTestFramework) return; // test framework is unchanged // Remove old testProject if (testProject != null) { testSolution.NestedTestCollection.Remove(testProject); testProject = null; } // Create new testProject if (newTestFramework != null) { testProject = newTestFramework.CreateTestProject(testSolution, project); if (testProject == null) throw new InvalidOperationException("CreateTestProject() returned null"); testSolution.NestedTestCollection.Add(testProject); } oldTestFramework = newTestFramework; }
/// <summary> /// Constructor, including the test framework and the query result data /// </summary> /// <param name="testFramework">The test framework to use for assertions</param> /// <param name="rawData">The data returned from the query execution</param> public ScalarResult(ITestFramework testFramework, T rawData) { TestFramework = testFramework; RawData = rawData; }
Xunit2Discoverer(AppDomainSupport appDomainSupport, ISourceInformationProvider sourceInformationProvider, IAssemblyInfo assemblyInfo, string assemblyFileName, string xunitExecutionAssemblyPath, string configFileName, bool shadowCopy, string shadowCopyFolder, IMessageSink diagnosticMessageSink, bool verifyAssembliesOnDisk) { Guard.ArgumentNotNull("assemblyInfo", (object)assemblyInfo ?? assemblyFileName); if (verifyAssembliesOnDisk) Guard.FileExists("xunitExecutionAssemblyPath", xunitExecutionAssemblyPath); #if PLATFORM_DOTNET CanUseAppDomains = false; #else CanUseAppDomains = !IsDotNet(xunitExecutionAssemblyPath); #endif DiagnosticMessageSink = diagnosticMessageSink ?? new NullMessageSink(); var appDomainAssembly = assemblyFileName ?? xunitExecutionAssemblyPath; appDomain = AppDomainManagerFactory.Create(appDomainSupport != AppDomainSupport.Denied && CanUseAppDomains, appDomainAssembly, configFileName, shadowCopy, shadowCopyFolder); var testFrameworkAssemblyName = GetTestFrameworkAssemblyName(xunitExecutionAssemblyPath); // If we didn't get an assemblyInfo object, we can leverage the reflection-based IAssemblyInfo wrapper if (assemblyInfo == null) assemblyInfo = appDomain.CreateObject<IAssemblyInfo>(testFrameworkAssemblyName, "Xunit.Sdk.ReflectionAssemblyInfo", assemblyFileName); framework = appDomain.CreateObject<ITestFramework>(testFrameworkAssemblyName, "Xunit.Sdk.TestFrameworkProxy", assemblyInfo, sourceInformationProvider, DiagnosticMessageSink); discoverer = Framework.GetDiscoverer(assemblyInfo); }