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