public void CalculateFullNameWithTitleCase()
{
var sut = new PlayerCharacter();
sut.FirstName = "Noob";
sut.LastName = "Player";
StringAssert.Matches(sut.FullName, new System.Text.RegularExpressions.Regex("[A-Z]{1}[a-z]+ [A-Z]{1}[a-z]+"));
}
private static void ValidateInitializeAndCleanup(ReadOnlyCollection <OM.TestResult> testResults, Func <TestResultMessage, bool> messageFilter)
{
// It is not deterministic where the class initialize and class cleanup will run, so we look at all tests, to make sure it is includes somewhere.
var output = string.Join(Environment.NewLine, testResults.SelectMany(r => r.Messages).Where(messageFilter).Select(m => m.Text));
Assert.IsNotNull(output);
StringAssert.Matches(output, new Regex("ClassInitialize"));
StringAssert.Matches(output, new Regex("ClassCleanup"));
}
public void TestMethodToString()
{
FormChangeMode.KeyDevice key = new FormChangeMode.KeyDevice()
{
Id = -1, Mode = FormChangeMode.MODE_TECCOMPONENT.PC
};
StringAssert.Matches(key.ToString(), new Regex(FormChangeMode.MODE_TECCOMPONENT.PC.ToString()));
}
public void Can_Generate_Repeat_Pattern_Long()
{
var pattern = @"(\L){1}(\d){1}(\L){2}(\d){2}(\L){4}(\d){4}(\L){8}(\d){8}(\L){16}(\d){16}(\L){32}(\d){32}(\L){64}(\d){64}(\L){128}(\d){128}(\L){256}(\d){256}(\L){512}(\d){512}(\L){1024}(\d){1024}";
var text = AlphaNumericGenerator.GenerateFromPattern(pattern);
Console.WriteLine("'" + pattern + "' produced '" + text + "'");
StringAssert.Matches(text, new Regex(@"[A-Z]{1}[0-9]{1}[A-Z]{2}[0-9]{2}[A-Z]{4}[0-9]{4}[A-Z]{8}[0-9]{8}[A-Z]{16}[0-9]{16}[A-Z]{32}[0-9]{32}[A-Z]{64}[0-9]{64}[A-Z]{128}[0-9]{128}[A-Z]{256}[0-9]{256}[A-Z]{512}[0-9]{512}[A-Z]{1024}[0-9]{1024}"));
Assert.AreEqual((1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 + 256 + 512 + 1024) * 2, text.Length);
}
public void Can_Generate_From_Template_for_ReadMe3()
{
var template = @"Hi there <<\L\v{0,2}\l{0,2}\v \L\v{0,2}\l{0,2}\v{0,2}\l{0,2}\l>> how are you doing? Your SSN is <<[1-9]\d\d-\d\d-\d\d\d\d>>";
string text = AlphaNumericGenerator.GenerateFromTemplate(template);
Console.WriteLine("'" + template + "' produced '" + text + "'");
StringAssert.Matches(text, new Regex(@"Hi there [A-Z][aeiou]{0,2}[a-z]{0,2}[aeiou] [A-Z][aeiou]{0,2}[a-z]{0,2}[aeiou]{0,2}[a-z]{0,2}[a-z] how are you doing\? Your SSN is [1-9]\d{2}-\d{2}-\d{4}"));
}
public void TestRandomWithoutArguments()
{
string testSecret = Base32.Random();
Assert.AreEqual(20, Base32.Decode(testSecret).Length);
Assert.AreEqual(32, testSecret.Length);
StringAssert.Matches(testSecret, new Regex("^[A-Z2-7]+$"));
}
public void Game_ToString_UnSolvedValid()
{
var g = new Game(LowestPuzzleValue, SideLength);
var expected = new Regex(@"^\d+ of \d+ cells solved$");
var actual = g.ToString();
StringAssert.Matches(actual, expected);
}
private static void AssertProperSitemapItemForPage(SitemapItem pageSitemapItem, string subject)
{
StringAssert.Matches(pageSitemapItem.Id, new Regex(@"t\d+-p\d+"), subject + ".Id");
Assert.AreEqual(SitemapItem.Types.Page, pageSitemapItem.Type, subject + ".Type");
Assert.IsNotNull(pageSitemapItem.Title, subject + ".Title");
Assert.IsNotNull(pageSitemapItem.Url, subject + ".Url");
Assert.IsNotNull(pageSitemapItem.PublishedDate, subject + ".PublishedDate");
Assert.IsTrue(pageSitemapItem.Visible, subject + ".Visible");
}
private static void AssertValidKeywordModel(KeywordModel keywordModel, string expectedTitle, string expectedDescription, string expectedKey, string subjectName)
{
Assert.IsNotNull(keywordModel, subjectName);
Assert.AreEqual(expectedTitle, keywordModel.Title, subjectName + ".Title");
Assert.AreEqual(expectedDescription, keywordModel.Description, subjectName + ".Description");
Assert.AreEqual(expectedKey, keywordModel.Key, subjectName + ".Key");
StringAssert.Matches(keywordModel.Id, new Regex(@"\d+"), subjectName + ".Id");
StringAssert.Matches(keywordModel.TaxonomyId, new Regex(@"\d+"), subjectName + ".TaxonomyId");
}
public void CreatePageModel_Article_Success()
{
Page testPage = (Page)TestSession.GetObject(TestFixture.ArticlePageWebDavUrl);
RenderedItem testRenderedItem;
PageModelData pageModel = CreatePageModel(testPage, out testRenderedItem);
// First assert the Page Model itself looks OK
Assert.IsNotNull(pageModel.MvcData, "pageModel.MvcData");
Assert.IsNull(pageModel.HtmlClasses, "pageModel.HtmlClasses");
Assert.IsNotNull(pageModel.XpmMetadata, "pageModel.XpmMetadata");
Assert.IsNull(pageModel.ExtensionData, "pageModel.ExtensionData");
Assert.IsNull(pageModel.SchemaId, "pageModel.SchemaId");
Assert.IsNull(pageModel.Metadata, "pageModel.Metadata");
Assert.AreEqual("9786", pageModel.Id, "pageModel.Id");
Assert.AreEqual("Test Article used for Automated Testing (Sdl.Web.Tridion.Tests)", pageModel.Title, "pageModel.Title");
Assert.AreEqual("/autotest-parent/test_article_page", pageModel.UrlPath, "pageModel.UrlPath");
Assert.IsNotNull(pageModel.Meta, "pageModel.Meta");
Assert.AreEqual(5, pageModel.Meta.Count, "pageModel.Meta.Count");
Assert.IsNotNull(pageModel.Regions, "pageModel.Regions");
Assert.AreEqual(4, pageModel.Regions.Count, "pageModel.Regions.Count");
AssertExpectedIncludePageRegions(pageModel.Regions, new[] { "Header", "Footer", "Content Tools" });
// Assert the output RenderedItem looks OK
Assert.IsNotNull(testRenderedItem, "testRenderedItem");
Assert.AreEqual(2, testRenderedItem.Binaries.Count, "testRenderedItem.Binaries.Count");
Assert.AreEqual(1, testRenderedItem.ChildRenderedItems.Count, "testRenderedItem.ChildRenderedItems.Count");
// Assert the Article EntityModelData looks OK
RegionModelData mainRegion = GetMainRegion(pageModel);
EntityModelData article = mainRegion.Entities[0];
AssertExpanded(article, true, "article");
StringAssert.Matches(article.Id, new Regex(@"\d+"));
ContentModelData articleBody = (ContentModelData)article.Content["articleBody"];
RichTextData content = (RichTextData)articleBody["content"];
Assert.IsNotNull(content, "content");
Assert.IsNotNull(content.Fragments, "content.Fragments");
// Embedded image in Rich Text field should be represented as an embedded EntityModelData
Assert.AreEqual(3, content.Fragments.Count, "content.Fragments.Count");
EntityModelData image = content.Fragments.OfType <EntityModelData>().FirstOrDefault();
Assert.IsNotNull(image, "image");
Assert.IsNotNull(image.BinaryContent, "image.BinaryContent");
Assert.AreEqual("image/jpeg", image.BinaryContent.MimeType, "image.BinaryContent.MimeType");
// Image should have "altText" metadata field obtained from the original XHTML; see TSI-2289.
Assert.IsNotNull(image.Metadata, "image.Metadata");
object altText;
Assert.IsTrue(image.Metadata.TryGetValue("altText", out altText));
Assert.AreEqual("calculator", altText, "altText");
}
public void Can_Output_Escaped_Slash()
{
string pattern;
pattern = @"[\\]{1,10}";
var text = AlphaNumericGenerator.GenerateFromPattern(pattern);
Console.WriteLine("'" + pattern + "' produced '" + text + "'");
StringAssert.Matches(text, new Regex(@"[\\]{1,10}"));
}
public void Can_Generate_Mixed_Pattern_With_Random_Length()
{
string pattern;
pattern = @"\L{10,20}";
var text = AlphaNumericGenerator.GenerateFromPattern(pattern);
Console.WriteLine("'" + pattern + "' produced '" + text + "'");
StringAssert.Matches(text, new Regex(@"[A-Z]{10,20}"));
}
public void TestDuzinaIndexa()
{
DateTime dr = DateTime.ParseExact("06.11.1996", "dd.MM.yyyy", CultureInfo.InvariantCulture);
DateTime dt = DateTime.ParseExact("24.01.2013", "dd.MM.yyyy", CultureInfo.InvariantCulture);
Bachelor ba = new Bachelor("Selma", "Hrenovica", dr, "0611996175021", dt, "shrenovica2", "pass");
String pattern = @"^([0-9]){5}$";
Regex reg = new Regex(pattern);
StringAssert.Matches(ba.DajBrojIndexa(), reg);
}
public void GiftCard_ManualCard_ShouldReverseUsingGiftCard()
{
var giftCardSvc = new HpsGiftCardService(TestServicesConfig.ValidSecretKeyConfig());
var saleResponse = giftCardSvc.Sale(TestGiftCard.Manual.validGiftCardNotEncrypted, 10.00m);
StringAssert.Matches(saleResponse.ResponseCode, new Regex("^0$"));
var reverseResponse = giftCardSvc.Reverse(TestGiftCard.Manual.validGiftCardNotEncrypted, 10.00m);
StringAssert.Matches(reverseResponse.ResponseCode, new Regex("^0$"));
}
public void GivenDomainRootIsAttachedToGeneratedEmailAddress()
{
var domainRoot = ".de";
var sut = new EmailAddresses(domainRoot);
var result = sut.GetValue();
StringAssert.EndsWith(result, domainRoot);
StringAssert.Matches(result, RFC5322RegEx, StandardAssertMessage);
}
public void StringChecks()
{
var valueToTest = "Foo Bar Baz Bin";
StringAssert.Contains(valueToTest, "Bar");
StringAssert.StartsWith(valueToTest, "Foo");
StringAssert.EndsWith(valueToTest, "Bin");
StringAssert.Matches(valueToTest, new Regex("^Foo.*Bin$"));
StringAssert.DoesNotMatch(valueToTest, new Regex("^Foo.*Bain$"));
}
/// <summary>
/// Process the specified input template and verify against the expected output regular expression.
/// </summary>
/// <param name="expectedOutputRegex"></param>
/// <param name="inputTemplate"></param>
public void AssertTemplateOutputRegex(ILavaEngine engine, string expectedOutputRegex, string inputTemplate, LavaDataDictionary mergeValues = null)
{
var outputString = GetTemplateOutput(engine, inputTemplate, mergeValues);
var regex = new Regex(expectedOutputRegex);
WriteOutputToDebug(engine, outputString);
StringAssert.Matches(outputString, regex);
}
public void GiftCard_ManualCard_ShouldVoid()
{
var giftCardSvc = new HpsGiftCardService(TestServicesConfig.ValidSecretKeyConfig());
var saleResponse = giftCardSvc.Sale(TestGiftCard.Manual.validGiftCardNotEncrypted, 10.00m);
StringAssert.Matches(saleResponse.ResponseCode, new Regex("^0$"));
var voidResponse = giftCardSvc.Void(saleResponse.TransactionId).Execute();
StringAssert.Matches(voidResponse.ResponseCode, new Regex("^0$"));
}
public void StringChecks()
{
var valueToTest = "Abc Def Klm Xyz";
StringAssert.Contains(valueToTest, "Def");
StringAssert.StartsWith(valueToTest, "Abc");
StringAssert.EndsWith(valueToTest, "Xyz");
StringAssert.Matches(valueToTest, new Regex("^Abc.*Xyz"));
StringAssert.DoesNotMatch(valueToTest, new Regex("^Abc.*Xyx$"));
}
public void NumberOfLength_CreatesOnlyNumericalValues()
{
for (int i = 0; i < sampleSize; i++)
{
Regex digits = new Regex($@"\d{{{i}}}");
string number = RandomString.NumberOfLength(i);
StringAssert.Matches(number, digits);
}
}
public void Can_Generate_Mixed_Pattern()
{
string pattern;
pattern = @"\L\L(\L\L\d\d){3}\L\L(\L){23}";
var text = AlphaNumericGenerator.GenerateFromPattern(pattern);
Console.WriteLine("'" + pattern + "' produced '" + text + "'");
StringAssert.Matches(text, new Regex(@"[A-Z]{2}[A-Z]{2}[0-9]{2}[A-Z]{2}[0-9]{2}[A-Z]{2}[0-9]{2}[A-Z]{2}[A-Z]{23}"));
}
public void CalculateFullNameWithTitleCase()
{
var sut = new PlayerCharacter();
sut.FirstName = "Sarah";
sut.LastName = "Smith";
StringAssert.Matches(sut.FullName, new Regex("[A-Z]{1}[a-z]+ [A-Z]{1}[a-z]+"));
//StringAssert.DoesNotMatch(sut.FullName, new Regex("[A-Z]{1}[a-z]+ [A-Z]{1}[a-z]+"));
}
public void StringAsserts()
{
// Trivial string asserts
StringAssert.Contains("ABC", "B");
StringAssert.EndsWith("ABC", "C");
StringAssert.StartsWith("ABC", "A");
// Pattern matching with Regex
StringAssert.Matches("-10.0", new Regex(@"[+-]?\d+\.\d*$"));
}
public void CalculateFullName()
{
Assert.AreEqual("Sarah Smith", systemUnderTest.FullName);
StringAssert.StartsWith(systemUnderTest.FullName, "Sarah");
StringAssert.EndsWith(systemUnderTest.FullName, "Smith");
StringAssert.Contains(systemUnderTest.FullName, "ah Sm");
StringAssert.Matches(systemUnderTest.FullName,
new Regex("[A-Z]{1}[a-z]+ [A-Z]{1}[a-z]+"));
}
public void ShouldPassWhenDescriptionPatternIsCorrect()
{
using (ShimsContext.Create())
{
ShimVisit.AllInstances.DescriptionGet = (Visit) => "Enter the description of the visit here (diagnosis, recommendations etc.).";
var value = visit.Description;
var pattern = new Regex("^.{0,500}$");
StringAssert.Matches(value, pattern);
}
}
public void CanProvisionTokenizedTermsTwiceNameMatch()
{
var template = new ProvisioningTemplate();
const string termGroupName = "TestProvisioningGroup";
var termGroup = new TermGroup(_termGroupGuid, termGroupName, null);
const string termSiteName = "TestProvisioningTermSet - {sitename}";
var termSet1 = new TermSet(_termSetGuid, termSiteName, null, true, false, null, null);
var term1Id = Guid.NewGuid();
const string term1Name = "TestProvisioningTerm - {siteid}";
var term1 = new Term(term1Id, term1Name, null, null, null, null, null);
termSet1.Terms.Add(term1);
termGroup.TermSets.Add(termSet1);
template.TermGroups.Add(termGroup);
for (int index = 0; index < 2; index++)
{
if (index == 1)
{
// Assign a new ID to the Term to test the name matching logic.
term1.Id = Guid.NewGuid();
}
using (ClientContext ctx = TestCommon.CreateClientContext())
{
var parser = new TokenParser(ctx.Web, template);
new ObjectTermGroups().ProvisionObjects(ctx.Web, template, parser, new ProvisioningTemplateApplyingInformation());
TaxonomySession session = TaxonomySession.GetTaxonomySession(ctx);
var store = session.GetDefaultKeywordsTermStore();
var group = store.GetGroup(_termGroupGuid);
var set = store.GetTermSet(_termSetGuid);
ctx.Load(group);
ctx.Load(set, s => s.Id, s => s.Name, s => s.Terms);
ctx.ExecuteQueryRetry();
Assert.IsInstanceOfType(group, typeof(Microsoft.SharePoint.Client.Taxonomy.TermGroup));
StringAssert.Matches(group.Name, new Regex(Regex.Escape(termGroupName)));
Assert.AreEqual(_termGroupGuid, group.Id);
Assert.IsInstanceOfType(set, typeof(Microsoft.SharePoint.Client.Taxonomy.TermSet));
Assert.AreEqual(1, set.Terms.Count);
Assert.AreEqual(_termSetGuid, set.Id);
StringAssert.DoesNotMatch(set.Name, new Regex(Regex.Escape(termSiteName)));
var remoteTerm1 = set.Terms[0];
Assert.AreEqual(term1Id, remoteTerm1.Id);
StringAssert.DoesNotMatch(remoteTerm1.Name, new Regex(Regex.Escape(term1Name)));
}
}
}
public static void Matches(string value, Regex pattern, string message = null)
{
if (message == null)
{
RegisterAction(() => StringAssert.Matches(value, pattern));
}
else
{
RegisterAction(() => StringAssert.Matches(value, pattern, message));
}
}
public void Cc_ShouldPartialReverse_Ok()
{
var chargeSvc = new HpsCreditService(TestServicesConfig.ValidServicesConfig());
var charge = chargeSvc.Charge(20, "usd", TestCreditCard.ValidVisa,
TestCardHolder.CertCardHolderShortZip);
var response = chargeSvc.Reverse(charge.TransactionId, 20, "usd", null, 10);
Assert.IsNotNull(response);
StringAssert.Matches(response.ResponseCode, new Regex("^00$"));
}
public void ParserWithBadParameterOutputsUsageWithError()
{
var textWriter = new StringWriter();
var parameters = ParameterParser.Parse(new string[] { "--bad" }, textWriter);
Assert.IsNull(parameters);
var outputString = textWriter.ToString();
StringAssert.Matches(outputString, new Regex(".*bad.*Usage.*", RegexOptions.Singleline));
}
public void ParserWithTwoArgumentsOutputsUsageWithError()
{
var textWriter = new StringWriter();
var parameters = ParameterParser.Parse(new string[] { Filename, Filename }, textWriter);
Assert.IsNull(parameters);
var outputString = textWriter.ToString();
StringAssert.Matches(outputString, new Regex(".*Only one.*Usage.*", RegexOptions.Singleline));
}
