private static Gen <string[]> AlphaStringSetGen(int length, int count)
{
var regex = $"[a-z]{{{length}}}";
var xeger = new Xeger(regex);
return(Gen.ArrayOf(count, Arb.Generate <bool>().Select(_ => xeger.Generate())));
}
public async Task <CreateNewShortUrlCommandResponse> Handle(CreateNewShortUrlCommand request, CancellationToken cancellationToken)
{
var slug = request.ShortUrl.Slug;
if (!string.IsNullOrEmpty(slug))
{
var url = await _repository.Get(slug);
if (url != null)
{
return(new CreateNewShortUrlCommandResponse()
{
IsConflict = true, ConflictMessage = $"Slug '{url.Slug}' is in use"
});
}
}
if (string.IsNullOrEmpty(slug))
{
var xeger = new Xeger("[a-z0-9]{5}", new Random());
slug = xeger.Generate();
}
request.ShortUrl.Slug = slug.ToLower();
var res = await _repository.Create(request.ShortUrl);
return(new CreateNewShortUrlCommandResponse()
{
ShortUrl = res
});
}
private object GenerateRegularExpression(RegularExpressionRequest request)
{
string pattern = request.Pattern;
try
{
// Use the Xeger constructor overload that that takes an instance of Random.
// Otherwise identically strings can be generated, if regex are generated within short time.
string regex = new Xeger(pattern, new Random(this.GenerateSeed())).Generate();
if (Regex.IsMatch(regex, pattern))
{
return(regex);
}
}
catch (InvalidOperationException)
{
return(new NoSpecimen());
}
catch (ArgumentException)
{
return(new NoSpecimen());
}
return(new NoSpecimen());
}
private static string GenerateSingleValuedStringTests(BindingDescription bindingDescription)
{
var nonMatchTest = "";
var val = "A string";
if (!string.IsNullOrEmpty(bindingDescription.StringRegex))
{
var xeger = new Xeger(bindingDescription.StringRegex);
val = xeger.Generate();
var nonMatch = @"flkj3332@!!!$
fd333
";
nonMatchTest = string.Format(Templates.NonMatchTest,
GetValidCSharpIdentifier(bindingDescription.BoundAttributeType.Name),
nonMatch);
}
string tests = string.Format(Templates.SingleValuedStringFormatTests,
GetValidCSharpIdentifier(bindingDescription.BoundAttributeType.Name),
val,
nonMatchTest);
return(tests);
}
public static String RandomPAN()
{
var xeger = new Xeger(@"[A-Z]{5}\d{4}[A-Z]{1}");
var randomPAN = xeger.Generate();
return(randomPAN);
}
private static object CreateAnonymous(RegularExpressionRequest request)
{
string pattern = request.Pattern;
try
{
string regex = new Xeger(pattern).Generate();
if (Regex.IsMatch(regex, pattern))
{
return(regex);
}
}
catch (InvalidOperationException)
{
#pragma warning disable 618
return(new NoSpecimen(request));
#pragma warning restore 618
}
catch (ArgumentException)
{
#pragma warning disable 618
return(new NoSpecimen(request));
#pragma warning restore 618
}
#pragma warning disable 618
return(new NoSpecimen(request));
#pragma warning restore 618
}
public IActionResult Create([FromBody] ShortUrl shortUrl)
{
if (!string.IsNullOrEmpty(shortUrl.Slug))
{
var url = _shortUrlService.Get(shortUrl.Slug);
if (url != null)
{
return(Conflict($"Slug '{url.Slug}' is in use"));
}
}
if (string.IsNullOrEmpty(shortUrl.Slug))
{
var xeger = new Xeger("[a-z0-9]{5}", new Random());
shortUrl.Slug = xeger.Generate();
}
shortUrl.Slug = shortUrl.Slug.ToLower();
try
{
var res = _shortUrlService.Create(shortUrl);
return(Ok(res));
}
catch (Exception e)
{
Console.WriteLine(e);
return(StatusCode(500));
}
}
public static string GenerateRandomRegistrationPlateNumber()
{
string regexString = "[A-Z]{2}-[0-9]{4}-[A-Z]{2}";
Xeger generator = new Xeger(regexString);
string result = generator.Generate();
return(result);
}
static IEnumerable <string> Xegers(string pattern, System.Random rnd)
{
var xeger = new Xeger(pattern, rnd);
var result = Enumerable.Range(0, 10).Select(x => xeger.Generate());
result.ToList().ForEach(Console.WriteLine);
return(result);
}
public StreamingServer(IPAddress ipAddress, StreamSettings settings)
{
Identifier = Guid.NewGuid();
_streamSettings = settings;
_symbols = new Dictionary <string, int>();
_xeger = new Xeger(_streamSettings.MessagePattern, new Random(DateTime.Now.Millisecond));
_listener = new TcpListener(ipAddress, _streamSettings.ListeningPort);
}
public static IEnumerable <string> NextStrings(this IRandom random, string expression)
{
var xeger = new Xeger(expression, random);
while (true)
{
yield return(xeger.Generate());
}
}
private static Gen <string> GenRegex(string pattern)
{
return(Gen.Sized(size =>
{
var xegar = new Xeger(pattern);
var count = size < 1 ? 1 : size;
return Gen.Elements(Enumerable.Range(1, count).Select(i => xegar.Generate()))
.Resize(count);
}));
}
string GenerateCallsign(Airline airline)
{
string[] patternsArray = { "[0-9]{3}", "[0-9]{4}", "[0-9]{2}[A-Z]{1}", "[0-9]{2}[A-Z]{2}" };
var random = new Random();
var pattern = patternsArray[random.Next(patternsArray.Length)];
var callsign = new Xeger($"{airline.Icao}{pattern}").Generate();
return(callsign);
}
private void button1_Click(object sender, EventArgs e)
{
var random = new Random();
var xeger = new Xeger(txtGenStringRegex.Text, random);
for (int i = 0; i < 100; i++)
{
Debug.Print(xeger.Generate());
}
}
public string GenerateId(string?id)
{
if (string.IsNullOrEmpty(id))
{
var pattern = new Xeger("^[0-9a-fA-F]{24}$");
return(pattern.Generate());
}
return(id);
}
public RegexTestInput(string input)
{
if (input.StartsWith("^") && input.EndsWith("$"))
{
Value = new Xeger(input).Generate();
}
else
{
Value = input;
}
}
private string GenerateSecret(int?secretLength)
{
if (secretLength == null)
{
secretLength = 5;
}
var regex = "^[0-9]{" + secretLength + "}$";
var xeger = new Xeger(regex);
return(xeger.Generate());
}
public static string GeneratePassword()
{
var rand = new Random();
var xeger = new Xeger(PATTERN, rand);
var password = string.Empty;
for (int i = default; i < PASSWORD_LENGTH; i++)
{
password += xeger.Generate();
}
return(password);
}
public PasswordBenchmark()
{
var pattern = "a*(11,15)";
var ticks = Environment.TickCount;
generator = new Generator(pattern, new RandomGenerator(ticks));
mersenneGenerator = new Generator(pattern, new MersenneTwister(ticks));
cryptoGenerator = new Generator(pattern, new CryptoRandomGenerator());
var random = new Random(Environment.TickCount);
xeger = new Xeger("^[a-zA-Z0-9][!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~]{11,15}", random);
}
public CreateAddressBenchmark()
{
var pattern = "9(1,5)[ ]#Main,1st,8th#[ ]#Street,Avenue,Court#[, ]#Brooklyn,Newark#[, ]#NY,NJ#[ ]0(5)";
var ticks = Environment.TickCount;
generator = new Generator(pattern, new RandomGenerator(ticks));
mersenneGenerator = new Generator(pattern, new MersenneTwister(ticks));
cryptoGenerator = new Generator(pattern, new CryptoRandomGenerator());
var random = new Random(Environment.TickCount);
xeger = new Xeger("^[1-9]{1,5} (Main|1st|8th) (Street|Avenue|Court), (Brooklyn|Newark), (NY|NJ) \\d{5}$", random);
}
public SelectionFromGroupBenchmark()
{
var pattern = "#First,Fizzy,Fuzzy#(2,5)";
var ticks = Environment.TickCount;
generator = new Generator(pattern, new RandomGenerator(ticks));
mersenneGenerator = new Generator(pattern, new MersenneTwister(ticks));
cryptoGenerator = new Generator(pattern, new CryptoRandomGenerator());
var random = new Random(Environment.TickCount);
xeger = new Xeger("^(First|Fizzy|Fuzzy){2,5}$", random);
}
public SocialSecurityNumbersBenchmark()
{
var pattern = "0(3)[-]0(2)[-]0(4)";
var ticks = Environment.TickCount;
generator = new Generator(pattern, new RandomGenerator(ticks));
mersenneGenerator = new Generator(pattern, new MersenneTwister(ticks));
cryptoGenerator = new Generator(pattern, new CryptoRandomGenerator());
var random = new Random(Environment.TickCount);
xeger = new Xeger("^\\d{3}-\\d{2}-\\d{4}$", random);
}
private static void Produce(string regex)
{
var xeger = new Xeger(regex);
while (true)
{
var sb = new StringBuilder();
for (int i = 0; i < 1000; ++i)
{
sb.AppendLine(xeger.Generate());
}
Console.Write(sb.ToString());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ReverseRegEx"/> class.
/// </summary>
/// <param name="regularExpression">The regular expression that generated strings must match.</param>
public ReverseRegEx(string regularExpression)
{
if (regularExpression == null)
{
throw new ArgumentNullException(nameof(regularExpression), "Regular expression parameter must not be null.");
}
try
{
_regExGenerator = new Xeger(regularExpression);
}
catch (Exception e)
{
throw new InvalidOperationException("Regular expression value is not supported.", e);
}
}
public static Credential GenerateRandomCredential(string usernameRegex, string passwordRegex)
{
if (!usernameRegex.IsValidRegexPattern() ||
!passwordRegex.IsValidRegexPattern())
{
return(null);
}
var usernameGenerator = new Xeger(usernameRegex);
var passwordGenerator = new Xeger(passwordRegex);
var credential = new Credential
{
Username = usernameGenerator.Generate(),
Password = passwordGenerator.Generate()
};
return(credential);
}
public void TestFormat()
{
var javaValidator = new DguvJavaIkvmValidator();
var checks = new DguvTextCheckProvider().Checks;
foreach (var check in checks)
{
foreach (string pattern in check.Patterns)
{
var farePattern = pattern.Replace("(?<checksum>", "(");
var membershipNumber = new Xeger(farePattern).Generate();
/*
* var pi = new System.Diagnostics.ProcessStartInfo(@"lib\pl_mgnr.exe",
* $"-p 2 -u {check.BbnrUv} -m {membershipNumber}");
* pi.CreateNoWindow = true;
* pi.RedirectStandardOutput = true;
* pi.UseShellExecute = false;
* var process = new System.Diagnostics.Process
* {
* StartInfo = pi
*
* };
* process.Start();
* process.WaitForExit();
* var processExitCode = process.ExitCode;
*
* // FIXIT J.Oberst: Ein Fehler tritt auf.
* //var plausi = de.werum.dguv.mgnr.plausi.PlausiFacade.getInstance();
* //var result = plausi.doPlausi(2, check.BbnrUv, membershipNumber);
* //var result = de.werum.dguv.mgnr.plausi.PlausiFacade.getInstance().doPlausi(2, check.BbnrUv, membershipNumber);
*/
var status1 = (UvCheckStatus)check.Validate(membershipNumber);
var status2 = (UvJavaCheckStatus)javaValidator.Validate(check.BbnrUv, membershipNumber);
output.WriteLine($"Test von {membershipNumber} für {check.BbnrUv} mit Status {status2.Code} ({status2.GetStatusText()})");
Assert.Equal(status2.Code, status1.Code);
}
}
}
public static PersonalInformation GenerateRandomPersonalInformation(string familyNameRegex,
string givenNameRegex)
{
if (!familyNameRegex.IsValidRegexPattern() ||
!givenNameRegex.IsValidRegexPattern())
{
return(null);
}
var familyNameGenerator = new Xeger(familyNameRegex);
var givenNameGenerator = new Xeger(givenNameRegex);
var personalInformation = new PersonalInformation
{
FamilyName = familyNameGenerator.Generate(),
GivenName = givenNameGenerator.Generate()
};
return(personalInformation);
}
private string RandomizeString(Aspect aspect)
{
string randomValue = string.Empty;
if (aspect.StringType != StringType.Regex)
{
int stringLength = RandomCore.Next(aspect.Minimum, aspect.Maximum);
int characterCodeMax = characterCodes[aspect.StringType].Count - 1;
for (int loopCounter = 0; loopCounter < stringLength; loopCounter++)
{
randomValue += characterCodes[aspect.StringType]
.ElementAt(RandomCore.Next(0, characterCodeMax)).Value;
}
}
else
{
Xeger regexStringGenerator = new Xeger(aspect.RegexPattern);
randomValue = regexStringGenerator.Generate();
}
return(randomValue);
}
private static object GenerateRegularExpression(RegularExpressionRequest request)
{
string pattern = request.Pattern;
try
{
string regex = new Xeger(pattern).Generate();
if (Regex.IsMatch(regex, pattern))
{
return(regex);
}
}
catch (InvalidOperationException)
{
return(new NoSpecimen());
}
catch (ArgumentException)
{
return(new NoSpecimen());
}
return(new NoSpecimen());
}
public static string GenerateString(Format format, string pattern)
{
if (format == Format.DateTime)
{
var currentDate = DateTime.Now;
return($"\"{currentDate.ToString("s", CultureInfo.InvariantCulture)}\"");
}
if (pattern == null)
{
return("\"String text\"");
}
try
{
// Generate a string based on the pattern regex
var regexGenerator = new Xeger(pattern, new Random());
return($"\"{regexGenerator.Generate()}\"");
}
catch
{
return("\"Invalid pattern\"");
}
}
public void GeneratedTextIsCorrect(string pattern)
{
var sut = new Xeger(pattern);
var result = Enumerable.Range(1, 3).Select(i => sut.Generate()).ToArray();
Array.ForEach(result, regex => Assert.True(Regex.IsMatch(regex, pattern)));
}
