public void PopulateTreeTest_IgnoredSpecificationShouldIncludeExtraMetadata() { TestModel testModel = PopulateTestTree(); Test context = GetDescendantByName(testModel.RootTest.Children[0], "ignored specification spec"); Assert.IsNotNull(context); Test spec = GetDescendantByName(context, "should"); Assert.IsNotNull(spec); StringAssert.DoesNotContain("Attribute", context.Metadata.GetValue(MetadataKeys.IgnoreReason)); AssertStringContains("Attribute", spec.Metadata.GetValue(MetadataKeys.IgnoreReason)); }
public void Test_GetRandomStringWithMaxLength_ShouldReturnGuidTrimmedToMaxLength() { //---------------Set up test pack------------------- const int maxLength = 12; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var randomString = RandomValueGen.GetRandomString(maxLength); //---------------Test Result ----------------------- StringAssert.DoesNotContain("-", randomString); StringAssert.DoesNotContain("{", randomString); StringAssert.StartsWith("A", randomString); Assert.AreEqual(maxLength, randomString.Length); }
public void MetaFieldSerializes() { var result = this.Client.Map <ElasticsearchProject>(m => m .Meta(d => d .Add("attr1", "value1") .Add("attr2", new { attr3 = "value3" }) .Add("Attr4", 10) ) ); //make sure Attr4 is not serialized as attr4 var request = result.ConnectionStatus.Request.Utf8String(); StringAssert.DoesNotContain("attr4", request, request); this.DefaultResponseAssertations(result); }
public void SearchDoesntLowercaseStringFieldOverloadInSearch() { var result = this._client.Search <SomeOtherClass>(s => s .SortDescending("CreateDate2") .FacetDateHistogram("CreateDate2", fd => fd.OnField("CreateDate2").Interval(DateInterval.Hour)) .Query(query => query.Range(r => r .OnField("CreateDate2") .From(DateTime.UtcNow.AddYears(-1)) ) ) ); StringAssert.DoesNotContain("createDate2", result.ConnectionStatus.Request.Utf8String()); }
public void TargetColorNotChanged_WhenDragNotAcceptableElement() { //Act _droppablePage.AcceptTab.Click(); Builder.MoveToElement(_droppablePage.NotAcceptable) .ClickAndHold() .MoveByOffset(100, 80) .Perform(); //Assert var classAfterAction = Driver.FindElement(By.Id("droppable")).GetAttribute("class"); StringAssert.DoesNotContain(classAfterAction, "ui-droppable-active"); }
public void TestFlushAsyncContinuationDoesNotRunOnSocketReceiverThread() { var cache = GetClientCache <int>(); using (var streamer = Client.GetDataStreamer <int, int>(cache.Name)) { streamer.Add(1, 1); streamer.FlushAsync().ContinueWith(t => { var trace = new StackTrace().ToString(); StringAssert.DoesNotContain("ClientSocket", trace); }, TaskContinuationOptions.ExecuteSynchronously).Wait(); } }
public void IncludeTypes_DoesNotReturnReferenceTypes_If_IncludeTypes_NoWildcard_Swift() { var result = appHost.ExecuteService(new TypesSwift { IncludeTypes = new List <string> { "Dto" } }); var stringResult = result.ToString(); StringAssert.DoesNotContain("class DtoResponse", stringResult); StringAssert.DoesNotContain("EmbeddedRequest", stringResult); StringAssert.DoesNotContain("class EmbeddedResponse", stringResult); }
public void testStrings() { string actual = "ABCDEFG"; StringAssert.Contains("BCD", actual); StringAssert.DoesNotContain("DCB", actual); StringAssert.StartsWith("ABC", actual); StringAssert.DoesNotStartWith("BCD", actual); StringAssert.EndsWith("FG", actual); StringAssert.DoesNotEndWith("BCD", actual); StringAssert.AreEqualIgnoringCase("abcdefg", actual); StringAssert.AreNotEqualIgnoringCase("aaaaaaa", actual); StringAssert.IsMatch("A.+", actual); StringAssert.DoesNotMatch("K", actual); }
public void StringAssertsTest() { string s = "The best way to explain it is to do it"; StringAssert.Contains("explain", s, "No match found"); StringAssert.DoesNotContain("Alice", s); StringAssert.StartsWith("The", s, "No {0} found in {1}", new string[2] { "this", "that" }); StringAssert.DoesNotStartWith("An", s); StringAssert.EndsWith("do it", s, "Incorrect ending"); StringAssert.DoesNotEndWith("do that", s); string x = "ThE bEst WaY to eXplaiN iT iS tO dO iT"; StringAssert.AreEqualIgnoringCase(x, s, "No match found"); }
public async Task ShouldBlockedIfRented() { _bookingRepository.HasRentAsync(Arg.Any <int>()).Returns(true); var car = new Car { Name = "TestCar" }; var result = await _preflightService.Preflight(car); Assert.AreEqual(PreflightResultCode.BLOCKED, result.Code); Assert.AreEqual(string.Format(PreflightResultMessage.BLOCKED, car.Name), result.Message); StringAssert.DoesNotContain(string.Format(PreflightResultMessage.APPROVE, car.Name), result.Message); }
public void Last_Offset_Overwrites_All_Previous() { int first = 1; int second = 2; int last = 3; string format = String.Format("{0}={{0}}", SoqlQuery.OffsetKey); string soql = new SoqlQuery().Offset(first) .Offset(second) .Offset(last) .ToString(); StringAssert.DoesNotContain(String.Format(format, first), soql); StringAssert.DoesNotContain(String.Format(format, second), soql); StringAssert.Contains(String.Format(format, last), soql); }
public void EmptyConfigurationSerializesWithoutConfiguration() { IUtf8JsonSerializable parameters = new IndexingParameters() .SetIndexedFileNameExtensions() .SetExcludeFileNameExtensions(); using MemoryStream ms = new MemoryStream(); using (Utf8JsonWriter writer = new Utf8JsonWriter(ms)) { parameters.Write(writer); } string jsonContent = Encoding.UTF8.GetString(ms.ToArray()); StringAssert.DoesNotContain(@"""configuration""", jsonContent); }
public void PreserveVirtualMethodFromReallyUsedRootOnly() { var output = GetJavascriptWithDCE(@"DCETests\PreserveVirtualMethodFromReallyUsedRootOnly.cs"); DceAssert.Has(output, MemberType.Class, "BaseType", false); DceAssert.Has(output, MemberType.Class, "UsedMiddleDerivedType", false); DceAssert.Has(output, MemberType.Class, "UsedDerivedType", false); DceAssert.Has(output, MemberType.Class, "DerivedTypeWithoudMethodUsage", false); StringAssert.DoesNotContain("BaseType.Method - used", output, "BaseType.Method preserved, should be eliminated"); StringAssert.Contains("UsedMiddleDerivedType.Method - used", output, "UsedMiddleDerivedType.Method eliminated, should be preserved"); StringAssert.Contains("UsedDerivedType.Method - used", output, "UsedDerivedType.Method eliminated, should be preserved"); StringAssert.DoesNotContain("DerivedTypeWithoudMethodUsage.Method - used", output, "DerivedTypeWithoudMethodUsage.Method preserved, should be eliminated"); StringAssert.Contains("BaseClassWithPreservedMethod.Method - used", output, "BaseClassWithPreservedMethod.Method eliminated, should be preserved"); }
public void Last_FullTextSearch_Overwrites_All_Previous() { string first = "first text"; string second = "second text"; string last = "last text"; string format = String.Format("{0}={{0}}", SoqlQuery.SearchKey); string soql = new SoqlQuery().FullTextSearch(first) .FullTextSearch(second) .FullTextSearch(last) .ToString(); StringAssert.DoesNotContain(String.Format(format, first), soql); StringAssert.DoesNotContain(String.Format(format, second), soql); StringAssert.Contains(String.Format(format, last), soql); }
public void TestUserControlsPortingResults(string version) { var results = _resultsDict[version]; var webFormsFullResult = results.ProjectResults.First(proj => proj.CsProjectPath.EndsWith("WebFormsFull.csproj")); var projectDir = Path.GetDirectoryName(webFormsFullResult.CsProjectPath); // Component file exists FileAssert.Exists(Path.Combine(projectDir, "Components", "ViewSwitcher.razor")); // Component code-behind contents var viewSwitcherRazorCs = File.ReadAllText(Path.Combine(projectDir, "Components", "ViewSwitcher.razor.cs")); StringAssert.Contains("using Microsoft.AspNetCore.Components;", viewSwitcherRazorCs); StringAssert.Contains("public partial class ViewSwitcher : ComponentBase", viewSwitcherRazorCs); StringAssert.DoesNotContain("public partial class ViewSwitcher : System.Web.UI.UserControl", viewSwitcherRazorCs); }
public void Last_Select_Overwrites_All_Previous() { string[] first = { "first", "second", "last" }; string[] second = { "first", "second" }; string[] last = { "last" }; string format = String.Format("{0}={{0}}", SoqlQuery.SelectKey); string soql = new SoqlQuery().Select(first) .Select(second) .Select(last) .ToString(); StringAssert.DoesNotContain(String.Format(format, String.Join(SoqlQuery.Delimiter, first)), soql); StringAssert.DoesNotContain(String.Format(format, String.Join(SoqlQuery.Delimiter, second)), soql); StringAssert.Contains(String.Format(format, String.Join(SoqlQuery.Delimiter, last)), soql); }
public void OverrideNamespace() { var definition = "[csharp(namespace: DefinitionNamespace)] service TestApi { method do {}: {} }"; var parser = new FsdParser(); var service = parser.ParseDefinition(new ServiceDefinitionText("TestApi.fsd", definition)); var generator = new CSharpGenerator { GeneratorName = nameof(CSharpGeneratorTests), NamespaceName = "OverrideNamespace" }; var output = generator.GenerateOutput(service); foreach (var file in output.Files) { StringAssert.Contains("namespace OverrideNamespace", file.Text); StringAssert.DoesNotContain("DefinitionNamespace", file.Text); } }
public void UserDefinedTypeMember_ContainsObjects(string accessibility) { string inputCode = $@" Private Type TBar First As Class1 Second As Long End Type {accessibility} th|is As TBar"; string class1Code = @"Option Explicit Public Sub Foo() End Sub "; var userInput = new UserInputDataObject() .UserSelectsField("this", "MyType"); var presenterAction = Support.SetParameters(userInput); var codeString = inputCode.ToCodeString(); var actualModuleCode = RefactoredCode( "Module1", codeString.CaretPosition.ToOneBased(), presenterAction, null, false, ("Class1", class1Code, ComponentType.ClassModule), ("Module1", codeString.Code, ComponentType.StandardModule)); var actualCode = actualModuleCode["Module1"]; StringAssert.Contains("Private this As TBar", actualCode); StringAssert.DoesNotContain($"this = {Support.RHSIdentifier}", actualCode); StringAssert.DoesNotContain("MyType = this", actualCode); StringAssert.Contains($"Property Set First(ByVal {Support.RHSIdentifier} As Class1)", actualCode); StringAssert.Contains("Property Get First() As Class1", actualCode); StringAssert.Contains($"Set this.First = {Support.RHSIdentifier}", actualCode); StringAssert.Contains($"Set First = this.First", actualCode); StringAssert.Contains($"this.Second = {Support.RHSIdentifier}", actualCode); StringAssert.Contains($"Second = this.Second", actualCode); StringAssert.DoesNotContain($"Second = Second", actualCode); Assert.AreEqual(actualCode.IndexOf($"this.First = {Support.RHSIdentifier}"), actualCode.LastIndexOf($"this.First = {Support.RHSIdentifier}")); }
public void TestScriptTriggerWithNoSets() { var setupSQL1 = @" CREATE TABLE [dbo].[t1] ( a INT NOT NULL, CONSTRAINT [PK] PRIMARY KEY (a) ) "; var setupSQL2 = @" CREATE TABLE [dbo].[t2] ( a INT NOT NULL ) "; var setupSQL3 = @" CREATE TRIGGER [dbo].[TR_1] ON [dbo].[t1] FOR UPDATE,INSERT AS INSERT INTO [dbo].[t2](a) SELECT a FROM INSERTED"; var db = new Database("TestScriptTrigger"); // Set these properties to the defaults so they are not scripted db.FindProp("QUOTED_IDENTIFIER").Value = "ON"; db.FindProp("ANSI_NULLS").Value = "ON"; db.Connection = ConfigHelper.TestDB.Replace("database=TESTDB", "database=" + db.Name); db.ExecCreate(true); DBHelper.ExecSql(db.Connection, setupSQL1); DBHelper.ExecSql(db.Connection, setupSQL2); DBHelper.ExecSql(db.Connection, setupSQL3); db.Dir = db.Name; db.Load(); db.ScriptToDir(); var script = File.ReadAllText(db.Name + "\\triggers\\TR_1.sql"); StringAssert.DoesNotContain("INSERTEDENABLE", script); StringAssert.Contains("INSERTED\r\nGO\r\nENABLE", script); }
public void PrivateUDT_SelectedOtherThanObjectStateUDT() { var inputCode = $@" Private Type TTest TestValue As String TestNumber As Long End Type Private Type TTestModule1 SomeValue As Long End Type Private mTest As TTest Private this As TTestModule1 Private the|Target As Variant Public Property Get SomeValue() As Long SomeValue = this.SomeValue End Property Public Property Let SomeValue(ByVal value As Long) this.SomeValue = value End Property Public Sub Foo(arg As Long) SomeValue = arg * 4 End Sub "; var userInput = new UserInputDataObject() .UserSelectsField("theTarget"); userInput.EncapsulateUsingUDTField("mTest"); var presenterAction = Support.SetParameters(userInput); var actualCode = Support.RefactoredCode(inputCode.ToCodeString(), presenterAction); StringAssert.DoesNotContain("TheTarget = this.TheTarget", actualCode); StringAssert.Contains("TheTarget = mTest.TheTarget", actualCode); StringAssert.Contains("TheTarget As Variant", actualCode); }
public void ExtractInterfaceRefactoring_RemovesBlankLines() { const string inputCode = @" Public Function AddOne(ByVal arg1 As Long) As Long AddOne = arg1 + 1 End Function Public Function AddTwo(ByVal arg1 As Long) As Long AddTwo = arg1 + 2 End Function Public Function AddThree(ByVal arg1 As Long) As Long AddThree = arg1 + 3 End Function Public Function AddFour(ByVal arg1 As Long) As Long AddThree = arg1 + 4 End Function Public Function AddFive(ByVal arg1 As Long) As Long AddThree = arg1 + 5 End Function "; Func <ExtractInterfaceModel, ExtractInterfaceModel> presenterAction = model => { foreach (var member in model.Members) { member.IsSelected = !(member.Member.IdentifierName.EndsWith("One") || member.Member.IdentifierName.EndsWith("Five")); } model.ImplementationOption = ExtractInterfaceImplementationOption.ReplaceObjectMembersWithInterface; return(model); }; var actualCode = RefactoredCode("Class", DeclarationType.ClassModule, presenterAction, null, ("Class", inputCode, ComponentType.ClassModule)); var sourceModuleCode = actualCode["Class"]; StringAssert.DoesNotContain("Function AddTwo(", sourceModuleCode); StringAssert.DoesNotContain("Function AddThree(", sourceModuleCode); StringAssert.DoesNotContain("Function AddFour(", sourceModuleCode); StringAssert.Contains("Function IClass_AddTwo(", sourceModuleCode); StringAssert.Contains("Function IClass_AddThree(", sourceModuleCode); StringAssert.Contains("Function IClass_AddFour(", sourceModuleCode); StringAssert.Contains($"End Function{Environment.NewLine}{Environment.NewLine}Public Function", sourceModuleCode); }
public void Empty_Aliases_Are_Ignored() { string[] columns = new[] { "column1", "column2" }; string[] startOfAliases = columns.Select(c => String.Format("{0} AS ", c)).ToArray(); string[] nullAliases = new[] { (string)null, (string)null }; string[] emptyAliases = new[] { "", "" }; string nullSoql = new SoqlQuery().Select(columns).As(nullAliases).ToString(); string emptySoql = new SoqlQuery().Select(columns).As(emptyAliases).ToString(); foreach (string startOfAlias in startOfAliases) { StringAssert.DoesNotContain(startOfAlias, nullSoql); StringAssert.DoesNotContain(startOfAlias, emptySoql); } }
public void DoubleClick_IsRenderedInError_OnHiddenFailure() { Configuration.Timeout = 0.25; Configuration.PollDuringWaits = 0.1; Given.OpenedPageWithBody( @" <span id='link' ondblclick='window.location=this.href + ""#second""' style='display:none' >to h2</span> <h2 id='second'>Heading 2</h2> " ); var beforeCall = DateTime.Now; try { S("span").DoubleClick(); Assert.Fail("should fail with exception"); } catch (TimeoutException error) { var afterCall = DateTime.Now; Assert.Greater(afterCall, beforeCall.AddSeconds(0.25)); Assert.Less(afterCall, beforeCall.AddSeconds(1.0)); var lines = error.Message.Split("\n").Select( item => item.Trim() ).ToList(); Assert.Contains("Timed out after 0.25s, while waiting for:", lines); Assert.Contains( "Browser.Element(span).Actions.DoubleClick(self.ActualWebElement).Perform()", lines ); Assert.Contains("Reason:", lines); Assert.Contains( "element not interactable: [object HTMLSpanElement] has no size and location", lines ); StringAssert.DoesNotContain("second", Configuration.Driver.Url); } }
public void InValidRequired() { var AValidator = new DataValidation.Validator(); AValidator.AddField("Profile Id", (double?)null, "Required"); var Messages = AValidator.Validate(); WriteToConsole(Messages); Assert.AreEqual(Messages.Count, 1); Messages.ForEach(delegate(DataValidation.IValidationMessage message) { StringAssert.DoesNotContain(message.ErrorMessage, message.FieldName); }); }
public void InValidLengthMax() { var AValidator = new DataValidation.Validator(); AValidator.AddField("ZipCode", "12345678", "LengthMax(7)"); var Messages = AValidator.Validate(); WriteToConsole(Messages); Assert.AreEqual(Messages.Count, 1); Messages.ForEach(delegate(DataValidation.IValidationMessage message) { StringAssert.DoesNotContain(message.ErrorMessage, message.FieldName); }); }
public void InValidNotExact() { var AValidator = new DataValidation.Validator(); AValidator.AddField("Password", "MyPassword", "PasswordComfirm", "MyPassword", "NotExact"); var Messages = AValidator.Validate(); WriteToConsole(Messages); Assert.AreEqual(Messages.Count, 1); Messages.ForEach(delegate(DataValidation.IValidationMessage message) { StringAssert.DoesNotContain(message.ErrorMessage, message.FieldName); }); }
private void TestOwinSelfHostSample(string version) { TestSolutionAnalysis results = AnalyzeSolution("OwinSelfhostSample.sln", tempDir, downloadLocation, version); string projectDir = results.ProjectResults.FirstOrDefault().ProjectDirectory; var startupText = File.ReadAllText(Path.Combine(projectDir, "Startup.cs")); var programText = File.ReadAllText(Path.Combine(projectDir, "Program.cs")); StringAssert.Contains(@"UseEndpoints", startupText); StringAssert.Contains(@"ConfigureServices", startupText); StringAssert.Contains(@"MapControllers", startupText); StringAssert.Contains(@"Microsoft.AspNetCore.Builder", startupText); StringAssert.Contains(@"Microsoft.Extensions.DependencyInjection", startupText); StringAssert.DoesNotContain(@"System.Web.Http", startupText); StringAssert.Contains("WebHostBuilder", programText); }
public void InValidAreNotEqual() { var AValidator = new DataValidation.Validator(); AValidator.AddField("AccountId", "ABC123", "AccountIdComfirm", "ABC123", "AreNotEqual"); var Messages = AValidator.Validate(); WriteToConsole(Messages); Assert.AreEqual(Messages.Count, 1); Messages.ForEach(delegate(DataValidation.IValidationMessage message) { StringAssert.DoesNotContain(message.ErrorMessage, message.FieldName); }); }
public void RemovePasswordForLog_RemovesThePassword() { try { const string password = "******"; const string logFormat = "Cannot connect to https://someone:{0}@hg-public.languageforge.org/flex-proj; check your password and try again."; ServerSettingsModel.PasswordForSession = password; // SUT var scrubbed = ServerSettingsModel.RemovePasswordForLog(string.Format(logFormat, password)); Assert.AreEqual(string.Format(logFormat, ServerSettingsModel.PasswordAsterisks), scrubbed); StringAssert.DoesNotContain(password, scrubbed); } finally { ServerSettingsModel.PasswordForSession = null; } }
public void TestInternalNamespaceHasNoPublicTypes() { foreach (var file in GetCsFiles()) { if (!file.Contains(InternalDir, StringComparison.OrdinalIgnoreCase)) { continue; } var text = File.ReadAllText(file); foreach (var type in Types) { StringAssert.DoesNotContain("public " + type, text, file); } } }