public void GeneratedTextIsCorrect(string pattern) { var sut = new Fare.Xeger(pattern); var result = Enumerable.Range(1, 3).Select(i => sut.Generate()).ToArray(); Array.ForEach(result, regex => Assert.True(Regex.IsMatch(regex, pattern))); }
public void GeneratedTextIsCorrect(string pattern) { // Arrange const int repeatCount = 3; var randomSeed = Environment.TickCount; this._testOutput.WriteLine($"Random seed: {randomSeed}"); var random = new Random(randomSeed); var sut = new Fare.Xeger(pattern, random); // Act var result = Enumerable.Repeat(0, repeatCount) .Select(_ => { var generatedValue = sut.Generate(); this._testOutput.WriteLine($"Generated value: {generatedValue}"); return(generatedValue); }) .ToArray(); // Assert Assert.All(result, regex => Assert.Matches(pattern, regex)); }
public void GeneratedTextIsCorrectCharset(string pattern, string output) { // Arrange const int repeatCount = 3; var randomSeed = Environment.TickCount; this._testOutput.WriteLine($"Random seed: {randomSeed}"); var random = new Random(randomSeed); var sut = new Fare.Xeger(pattern, random); // Act Tuple <string, string>[] result = Enumerable.Repeat(0, repeatCount) .Select(_ => { var generatedValue0 = sut.Generate(); var generatedValue1 = sut.UsedAlphabet; this._testOutput.WriteLine($"charset value: {generatedValue1}"); return(new Tuple <string, string>(generatedValue0, generatedValue1)); }) .ToArray(); // Assert Assert.All(result, regex => Assert.True(output == null || regex.Item2 == new string(output.Cast <char>().Distinct().OrderBy(x => x).ToArray()))); }
public void GeneratedTextIsCorrect(string pattern) { const int repeatCount = 3; var sut = new Fare.Xeger(pattern); var result = Enumerable.Repeat(0, repeatCount).Select(_ => sut.Generate()).ToArray(); Assert.All(result, regex => Assert.Matches(pattern, regex)); }
private void Restriction(XElement element, Historico historico) { if (!gerarComentarios) { return; // tudo que é gerado pelas restrições são comentários, se não quer gerar, então nem precisa processar... } var enumeration = element.Descendants().FirstOrDefault(d => d.Name.LocalName == "enumeration"); if (enumeration != null) { historico.elemento.Add(new XComment("Exemplo: " + enumeration.Attribute("value")?.Value)); } var pattern = element.Descendants().FirstOrDefault(d => d.Name.LocalName == "pattern"); if (pattern != null) { var regex = pattern.Attribute("value")?.Value; try { bool temCaractereEspecial = true; string exemplo = ""; for (int i = 0; i < 10 && temCaractereEspecial; i++) { exemplo = new Fare.Xeger(regex).Generate(); temCaractereEspecial = false; for (int j = 0; j < exemplo.Length; j++) { if (exemplo[j] < 32) { temCaractereEspecial = true; break; } } } historico.elemento.Add(new XComment("Exemplo: " + exemplo)); } catch { historico.elemento.Add(new XComment("Pattern: " + regex)); } } var minLength = element.Descendants().FirstOrDefault(d => d.Name.LocalName == "minLength")?.Attribute("value")?.Value; var maxLength = element.Descendants().FirstOrDefault(d => d.Name.LocalName == "maxLength")?.Attribute("value")?.Value; if (!string.IsNullOrEmpty(minLength) || !string.IsNullOrEmpty(maxLength)) { historico.elemento.Add(new XComment(string.Format("Tamanho: de {0} a {1} caracteres", minLength ?? "0", maxLength ?? "infinitos"))); } var atributoBase = element.Attribute("base")?.Value; if (!string.IsNullOrEmpty(atributoBase)) { //restricoesDesconhecidas.Add(historico.elemento, atributoBase); historico.elemento.Add(new XAttribute("RestricaoDesconhecidaNaoIdentificadoEmNenhumaAnalise", atributoBase)); } }
static void Main(string[] args) { var data = new Fare.Xeger(ConfigurationManager.AppSettings["pattern"]); var tick = TimeSpan.Parse(ConfigurationManager.AppSettings["timespan"]); var observable = Observable .Timer(TimeSpan.Zero, tick) .Select(t => data.Generate()); new ConsoleSink().Subscribe(observable); new FileSink("data.txt").Subscribe(observable); Console.ReadLine(); }
protected virtual string TransformPattern(string pattern, ScenarioContext context) { // supports [[key=value]] assignment var isAssignment = Regex.Match(pattern, @"(.*)=(.*)"); if (isAssignment.Success) { // bottom up travese var cxtValue = TransformText(isAssignment.Groups[2].Value.Trim(), context); // apply user filter foreach (var t in _additonalTransformers) { cxtValue = t.Invoke(cxtValue); } // apply RegEx var regExM = Regex.Match(cxtValue, @"RegEx\((.*)\)", RegexOptions.IgnoreCase); if (regExM.Success) { cxtValue = new Fare.Xeger(regExM.Groups[1].Value).Generate(); } var cxtKey = TransformText(isAssignment.Groups[1].Value.Trim(), context); context[cxtKey] = cxtValue; Console.WriteLine(string.Format("[[{0}={1}]]", cxtKey, cxtValue)); return(cxtValue); } else { // read value from context try { var cxtValue = context[pattern] as string; Console.WriteLine(string.Format("[[{0}={1}]]", pattern, cxtValue)); return(cxtValue); } catch (KeyNotFoundException) { throw new KeyNotFoundException("can't find key:" + pattern + " in scenario context"); } } }
// Uses Xeger to generate multiple values which should match the regex pattern private string[] GenerateTextOfPattern(string pattern, int repeatCount) { var randomSeed = Environment.TickCount; this._testOutput.WriteLine($"Random seed: {randomSeed}"); var random = new Random(randomSeed); var sut = new Fare.Xeger(pattern, random); // Act var result = Enumerable.Repeat(0, repeatCount) .Select(_ => { var generatedValue = sut.Generate(); this._testOutput.WriteLine($"Generated value {generatedValue} for {pattern}"); return(generatedValue); }) .ToArray(); return(result); }
bool Collide(string regex1, string regex2) { var regexStriped1 = StripNameGroups(regex1); var regexStriped2 = StripNameGroups(regex2); var automaton1 = new Fare.RegExp(regexStriped1).ToAutomaton(); var automaton2 = new Fare.RegExp(regexStriped2).ToAutomaton(); var intersection = automaton1.Intersection(automaton2); var random1 = new Random(Environment.TickCount); var sut1 = new Fare.Xeger(regexStriped1, random1); var random2 = new Random(Environment.TickCount); var sut2 = new Fare.Xeger(regexStriped2, random2); var gen1 = sut1.Generate(); var gen2 = sut2.Generate(); var result1 = intersection.Run(gen1); var result2 = intersection.Run(gen2); return(result1 || result2); }
/// <summary> /// Creates the template. /// </summary> /// <param name="objectType">Type of the object.</param> /// <returns>The template.</returns> protected object CreateTemplate(Type objectType) { if (objectType == null || ExcludeTypes.Contains(objectType)) { return(null); } if (objectType == typeof(string)) { return("abc"); } if (objectType == typeof(bool)) { return(false); } if (objectType == typeof(short) || objectType == typeof(int) || objectType == typeof(long) || objectType == typeof(double) || objectType == typeof(float) || objectType == typeof(decimal)) { return(Convert.ChangeType(1, objectType)); } if (objectType == typeof(DateTime)) { return(DefaultDateTime); } if (objectType == typeof(DateTimeOffset)) { return(DefaultDateTimeOffset); } if (objectType == typeof(Timestamp)) { return(new Timestamp(DefaultDateTimeOffset)); } if (objectType.IsEnum) { return(Enum.GetValues(objectType).GetValue(0)); } if (objectType.IsGenericType) { var genericType = objectType.GetGenericTypeDefinition(); if (genericType == typeof(Nullable <>)) { return(Activator.CreateInstance(objectType, CreateTemplate(Nullable.GetUnderlyingType(objectType)))); } if (genericType == typeof(List <>)) { var childType = objectType.GetGenericArguments()[0]; var list = Activator.CreateInstance(objectType) as IList; list?.Add(CreateTemplate(childType)); return(list); } } if (objectType.IsAbstract) { var concreteType = objectType.Assembly.GetTypes() .FirstOrDefault(x => !x.IsAbstract && objectType.IsAssignableFrom(x)); return(CreateTemplate(concreteType)); } var dataObject = Activator.CreateInstance(objectType); foreach (var property in objectType.GetProperties()) { try { if (property.CanWrite && !IsIgnored(property)) { var regex = property.GetCustomAttribute <RegularExpressionAttribute>(); if (property.PropertyType == typeof(string) && regex != null && !UidPattern.Equals(regex.Pattern)) { var attribute = property.GetCustomAttribute <RegularExpressionAttribute>(); var xeger = new Fare.Xeger(attribute.Pattern); property.SetValue(dataObject, xeger.Generate()); continue; } property.SetValue(dataObject, CreateTemplate(property.PropertyType)); } } catch { _log.WarnFormat("Error setting property value. Type: {0}; Property: {1}", objectType.FullName, property.Name); } } return(dataObject); }