public void IncludeAlphanumeric() { var generator = new RandomValueGenerator(); var str = generator.String(RandomValueGenerator.CharsToInclude.AlphaNumeric, _length); ValidateString(str, CharTypesAllowed.Upper | CharTypesAllowed.Lower | CharTypesAllowed.Digit); }
public void IncludeDigits() { var generator = new RandomValueGenerator(); var str = generator.String(RandomValueGenerator.CharsToInclude.Digits, _length); ValidateString(str, CharTypesAllowed.Digit); }
public void IncludeSymbol() { var generator = new RandomValueGenerator(); var str = generator.String(RandomValueGenerator.CharsToInclude.Symbols, _length); ValidateString(str, CharTypesAllowed.Symbol); }
/// <summary>真偽の占い</summary> /// <param name="percentage">確率</param> /// <returns>真偽</returns> private bool Fortune(uint percentage) { return((RandomValueGenerator.GenerateRandomUint() % 100) < percentage); }
public void Creation() { var obj = new RandomValueGenerator(); Assert.That(Value.Of(obj).Is().Not().Null()); }
public void IncludeDefault() { var generator = new RandomValueGenerator(); var list = generator.Strings(_count); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(_count, (uint) list.Length); ValidateStrings(list, CharTypesAllowed.Upper | CharTypesAllowed.Lower | CharTypesAllowed.Digit | CharTypesAllowed.Symbol | CharTypesAllowed.Space); }
public void Count() { var generator = new RandomValueGenerator(); for (uint count = 0; count < 100; ++count) { generator.DefaultStringListCount = count; var list = generator.Strings(RandomValueGenerator.CharsToInclude.All); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(count, (uint) list.Length, count.ToString(CultureInfo.InvariantCulture)); } }
public byte[] Generate() { return(RandomValueGenerator.NextBytes(Options.Min, Options.Max)); }
public RandomizerBytes(FieldOptionsBytes options) : base(options) { _randomValueGenerator = new RandomValueGenerator(Options.Seed ?? Environment.TickCount); }
/// <summary> /// Am I going to remember this MemoryItem? /// </summary> /// <returns>true, remember the item, false I won't remember</returns> private bool DoIRememberThisInformation() { return(_knowledgeRetentionPercentage >= RandomValueGenerator.GeneratePercentileIntegerValue()); }
public ActionResult <IEnumerable <StudentQueryDto> > Get() { _logger.LogInformation($"{this.GetType().Name}: Get"); var rng = new Random(); return(Ok(CreateStudents().Select(item => item.ToQueryDto()))); IEnumerable <Student> CreateStudents() { return(Enumerable.Range(1, 3) .Select(_ => { long tuitionAgencyId = rng.Next(1, 5000); return new Student { StudentId = rng.Next(1, 5000), Person = CreatePerson(), TuitionAgency = CreateAgency(tuitionAgencyId), CoursesRegistered = CreateCourses(tuitionAgencyId) }; })); } Person CreatePerson() { return(new Person { PersonId = rng.Next(1, 5000), BirthDate = RandomValueGenerator.RandomDay(), Name = Guid.NewGuid().ToString() }); } TuitionAgency CreateAgency(long agencyId) { return(new TuitionAgency { TuitionAgencyId = agencyId, Name = Guid.NewGuid().ToString(), Branches = CreateBranches(agencyId), Courses = CreateCourses(agencyId) }); } ICollection <TuitionAgencyBranch> CreateBranches(long agencyId) { return(Enumerable.Range(1, 3).Select(_ => { return new TuitionAgencyBranch { TuitionAgencyBranchId = rng.Next(1, 5000), BranchAddress = Guid.NewGuid().ToString(), BranchName = Guid.NewGuid().ToString(), TuitionAgencyId = agencyId }; }).ToArray()); } ICollection <Course> CreateCourses(long agencyId) { return(Enumerable.Range(1, 3).Select(_ => { long courseId = rng.Next(1, 5000); return new Course { CourseId = courseId, Name = Guid.NewGuid().ToString(), TuitionAgencyId = agencyId, Subjects = CreateSubjects(courseId) }; }).ToArray()); } ICollection <Subject> CreateSubjects(long courseId) { return(Enumerable.Range(1, 3).Select(_ => { long courseId = rng.Next(1, 5000); return new Subject { SubjectId = courseId, Name = Guid.NewGuid().ToString(), CreditHours = rng.Next(1, 5), CourseId = courseId, }; }).ToArray()); } }
/// <summary> /// Randomly set some information to be wrong /// </summary> /// <param name="knowledgeItem">an item to randomize</param> /// <returns>The memory item with randomly falsified info</returns> public MemoryItem RandomizeKnowledgeItem(MemoryItem knowledgeItem) { int comparisonValue = RandomValueGenerator.GeneratePercentileIntegerValue(); return(_knowledgeAccuracyPercentage >= comparisonValue?knowledgeItem.GetAccurateCopy() : knowledgeItem.GetInaccurateCopy()); }
public void IncludeLetters() { var generator = new RandomValueGenerator(); var list = generator.Chars(RandomValueGenerator.CharsToInclude.Letters, _count); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(_count, (uint) list.Length); ValidateChars(list, CharTypesAllowed.Upper | CharTypesAllowed.Lower); }
public void IncludeDefault() { var generator = new RandomValueGenerator(); var space = false; var digit = false; var upper = false; var lower = false; var symbl = false; for (var i = 0; i < _iterations; ++i) { var ch = generator.Char(); space |= ch.IsSpace(); digit |= ch.IsDigit(); upper |= ch.IsUppercase(); lower |= ch.IsLowercase(); symbl |= ch.IsSymbol(); } Assert.That(Value.Of(upper).Is().True(), "Uppercase"); Assert.That(Value.Of(lower).Is().True(), "Lowercase"); Assert.That(Value.Of(digit).Is().True(), "Digit"); Assert.That(Value.Of(space).Is().True(), "Space"); Assert.That(Value.Of(symbl).Is().True(), "Symbol"); }
public void Default() { var generator = new RandomValueGenerator(); var obj = generator.Strings(); Assert.That(Value.Of(obj).Is().TypeOf(typeof (string[]))); }
public void GetInt_WhenBordersInconsistent_ThrowsArgumentOutOfRangeException() { var generator = new RandomValueGenerator(); Assert.Throws <ArgumentOutOfRangeException>(() => generator.GetInt(5, 1)); }
public void IncludeSymbol() { var generator = new RandomValueGenerator(); var list = generator.Strings(RandomValueGenerator.CharsToInclude.Symbols, _count); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(_count, (uint) list.Length); ValidateStrings(list, CharTypesAllowed.Symbol); }
private void InitRandomValues() { Name = RandomValueGenerator.GetEnumRandomValue <NameEnum>().ToString(); Surname = RandomValueGenerator.GetEnumRandomValue <SurnameEnum>().ToString(); Phone = RandomValueGenerator.GetPhoneNumber(); }
public void IncludeAndLength() { var generator = new RandomValueGenerator(); { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.Space; for (uint length = 100; length < 200; ++length) { generator.DefaultStringLength = length; var str = generator.String(); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(length, (uint) str.Length, length.ToString(CultureInfo.InvariantCulture)); ValidateString(str, CharTypesAllowed.Space); } } { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.AlphaNumeric; for (uint length = 100; length < 200; ++length) { generator.DefaultStringLength = length; var str = generator.String(); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(length, (uint) str.Length, length.ToString(CultureInfo.InvariantCulture)); ValidateString(str, CharTypesAllowed.Upper | CharTypesAllowed.Lower | CharTypesAllowed.Digit); } } }
public void Setup() { // initialize using a seed for deterministic tests randomValueGenerator = new RandomValueGenerator(Seed); }
public void IncludeAlphanumeric() { var generator = new RandomValueGenerator(); var digit = false; var upper = false; var lower = false; for (var i = 0; i < _iterations; ++i) { var ch = generator.Char(RandomValueGenerator.CharsToInclude.AlphaNumeric); Assert.That(Value.Of(ch.IsSpace()).Is().False(), "Space"); Assert.That(Value.Of(ch.IsSymbol()).Is().False(), ch.ToString(CultureInfo.InvariantCulture)); digit |= ch.IsDigit(); upper |= ch.IsUppercase(); lower |= ch.IsLowercase(); } Assert.That(Value.Of(upper).Is().True(), "Uppercase"); Assert.That(Value.Of(lower).Is().True(), "Lowercase"); Assert.That(Value.Of(digit).Is().True(), "Digit"); }
private static string GetRandomRelName() { return(RandomValueGenerator.GetRandomString()); }
public T Generate() { return(RandomValueGenerator.Next(_min, _max)); }
protected override double GenerateValue() { return(RandomValueGenerator.GenerateDouble(Constraints[ConstraintTypes.Min], Constraints[ConstraintTypes.Max])); }
public void Length() { var generator = new RandomValueGenerator(); for (uint length = 0; length < _length; ++length) { var str = generator.String(length); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(length, (uint) str.Length, length.ToString(CultureInfo.InvariantCulture)); } }
public void CanCallShortenText() { TextManipulations.ShortenText(RandomValueGenerator.AlphaNumericText(100, 200), 50); }
public void IncludeUpper() { var generator = new RandomValueGenerator(); var str = generator.String(RandomValueGenerator.CharsToInclude.Uppercase, _length); ValidateString(str, CharTypesAllowed.Upper); }
public void CanShortenTextWithSpaces() { var limit = 50; var spacePosition = RandomValueGenerator.Integer(100, 200); var text = $"{RandomValueGenerator.AlphaNumericText(spacePosition)} {RandomValueGenerator.AlphaNumericText(100, 200)}"; var newText = TextManipulations.ShortenText(text, limit); Assert.AreEqual(spacePosition + EllipsisLength, newText.Length); }
public void IncludeLetters() { var generator = new RandomValueGenerator(); var str = generator.String(RandomValueGenerator.CharsToInclude.Letters, _length); ValidateString(str, CharTypesAllowed.Upper | CharTypesAllowed.Lower); }
public void CanStripLyricMarkerWhenSummarizing() { var text = $"#{RandomValueGenerator.AlphaNumericTextWithSpaces(10, 20)}\n#{RandomValueGenerator.AlphaNumericTextWithSpaces(10, 20)}"; var newText = TextManipulations.Summarize(text); Assert.IsFalse(newText.Contains('#')); }
public void IncludeDefault() { var generator = new RandomValueGenerator(); var str = generator.String(_length); ValidateString(str, CharTypesAllowed.Upper | CharTypesAllowed.Lower | CharTypesAllowed.Digit | CharTypesAllowed.Space | CharTypesAllowed.Symbol); }
/// <summary> /// Socially interact with this character /// </summary> /// <param name="interaction">The action that the character is reacting to</param> /// <returns>The character's reaction</returns> public List <Reaction> InteractWithMe(RNPC.Core.Action.Action interaction) { if (interaction == null) { return new List <Reaction> { new Reaction { Source = MyName, Target = null, EventType = EventType.Interaction, Intent = Intent.Neutral, Message = ErrorMessages.WhatIsGoingOn } } } ; //I'm asleep. You can try to wake me up, but it might be hard. if (_wakingProbability < 100) { //You didn't wake me up. I'm still sleeping. if (_wakingProbability <= RandomValueGenerator.GeneratePercentileIntegerValue()) { return new List <Reaction> { new Reaction { InitialEvent = interaction, Source = MyName, Target = null, EventType = EventType.Interaction, Intent = Intent.Neutral, Message = (MyTraits.Energy <= 10) ? string.Format(CharacterMessages.Snoring, MyMemory.Me.Name) : string.Format(CharacterMessages.Sleeping, MyMemory.Me.Name) } } } ; //I woke up. But I'm confused! //TODO: interupt learning return(new List <Reaction> { new Reaction { Tone = Tone.Confused, InitialEvent = interaction, Source = MyName, Target = null, EventType = EventType.Interaction, Intent = Intent.Neutral, Message = CharacterMessages.JustWokeUp } }); } switch (interaction.EventType) { //TODO : Log case EventType.Environmental: return(new List <Reaction> { new Reaction { InitialEvent = interaction, Source = MyName, Target = null, EventType = EventType.Interaction, Intent = Intent.Neutral, Message = ErrorMessages.EnvironmentEventPassedInWrongWay } }); //TODO : Log case EventType.Temperature: return(new List <Reaction> { new Reaction { InitialEvent = interaction, Source = MyName, Target = null, EventType = EventType.Interaction, Intent = Intent.Neutral, Message = ErrorMessages.TemperatureEventPassedInWrongWay } }); //TODO : Log case EventType.Weather: return(new List <Reaction> { new Reaction { InitialEvent = interaction, Source = MyName, Target = null, EventType = EventType.Interaction, Intent = Intent.Neutral, Message = ErrorMessages.EnvironmentEventPassedInWrongWay } }); //TODO : Log case EventType.Time: return(new List <Reaction> { new Reaction { InitialEvent = interaction, Source = MyName, Target = null, EventType = EventType.Interaction, Intent = Intent.Neutral, Message = ErrorMessages.TimeEventPassedInWrongWay } }); case EventType.Interaction: return(HandleSocialInteraction(interaction)); case EventType.Biological: return(new List <Reaction> { new Reaction { InitialEvent = interaction, Source = MyName, Target = null, EventType = EventType.Interaction, Intent = Intent.Neutral, Message = ErrorMessages.PhysicalEventPassedInWrongWay } }); case EventType.Unknown: return(new List <Reaction> { new Reaction { InitialEvent = interaction, Source = MyName, Target = null, EventType = EventType.Interaction, Intent = Intent.Neutral, Message = ErrorMessages.WhatIsGoingOn } }); default: throw new ArgumentOutOfRangeException(); } }
public void Count() { var generator = new RandomValueGenerator(); var list = generator.Strings(_count); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(_count, (uint) list.Length); }
protected override bool GenerateValue() { return(RandomValueGenerator.GenerateBool()); }
public void IncludeAlphanumeric() { var generator = new RandomValueGenerator(); var list = generator.Strings(RandomValueGenerator.CharsToInclude.AlphaNumeric, _count); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(_count, (uint) list.Length); ValidateStrings(list, CharTypesAllowed.Upper | CharTypesAllowed.Lower | CharTypesAllowed.Digit); }
private static PropertiesDefBuilder <T> GetPropertiesDefBuilder <T>() where T : BusinessObject { return(new PropertiesDefBuilder <T>(new ClassDefBuilder2 <T>(new ClassDefBuilder <T>(), new List <PropDefBuilder <T> >(), new List <string> { RandomValueGenerator.GetRandomString() }), new List <PropDefBuilder <T> >())); }
public void Length() { var generator = new RandomValueGenerator(); for (uint length = 200; length < 400; ++length) { generator.DefaultStringLength = length; var str = generator.String(RandomValueGenerator.CharsToInclude.All); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(length, (uint) str.Length, length.ToString(CultureInfo.InvariantCulture)); } }
internal virtual IEnumerator <IndexEntryUpdate <IndexDescriptor> > RandomUpdateGenerator(RandomRule random, ValueType[] types) { IEnumerator <Value> valueIterator = new RandomValueGenerator(this, random.RandomValues(), types, FractionDuplicates()); return(new RandomUpdateGenerator(this, valueIterator)); }
public void IncludeList() { var generator = new RandomValueGenerator(); { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.Space; var list = generator.Strings(_count, _length); ValidateStrings(list, CharTypesAllowed.Space); } { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.Digits; var list = generator.Strings(_count, _length); ValidateStrings(list, CharTypesAllowed.Digit); } { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.Uppercase; var list = generator.Strings(_count, _length); ValidateStrings(list, CharTypesAllowed.Upper); } { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.LowerCase; var list = generator.Strings(_count, _length); ValidateStrings(list, CharTypesAllowed.Lower); } { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.Symbols; var list = generator.Strings(_count, _length); ValidateStrings(list, CharTypesAllowed.Symbol); } { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.Letters; var list = generator.Strings(_count, _length); ValidateStrings(list, CharTypesAllowed.Upper | CharTypesAllowed.Lower); } { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.AlphaNumeric; var list = generator.Strings(_count, _length); ValidateStrings(list, CharTypesAllowed.Upper | CharTypesAllowed.Lower | CharTypesAllowed.Digit); } { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.All; var list = generator.Strings(_count, _length); ValidateStrings(list, CharTypesAllowed.Upper | CharTypesAllowed.Lower | CharTypesAllowed.Digit | CharTypesAllowed.Symbol | CharTypesAllowed.Space); } }
public bool AnalyzeAndLearn(Character learningCharacter) { var testResults = learningCharacter.MyMemory.GetAllCurrentNodeTestInfos(); var testedQualities = testResults.Where(t => t.TestedCharacteristic == CharacteristicType.Quality).ToList(); int qualityEvolveRate = LearningParameters.QualityLearningRate; int qualityDevolveRate = LearningParameters.QualityDevolveRate; //If there are not enough nodes for change we stop here. if (testedQualities.Count < LearningParameters.QualityLearningThreshold) { return(true); } var groupedQualitiesTest = testedQualities.GroupBy(q => q.CharacteristicName).ToList(); foreach (var testInfos in groupedQualitiesTest) { if (testInfos.Count() < LearningParameters.QualityLearningThreshold) { continue; } int failedTests = testInfos.Count(q => q.Result == false); int succeededTests = testInfos.Count(q => q.Result); //if they're identical or almost identical it cancels out. if (failedTests == succeededTests || Math.Abs(failedTests - succeededTests) == 1) { continue; } string quality = testInfos.ToList()[0].CharacteristicName; Type type = learningCharacter.MyTraits.GetType(); PropertyInfo info = type.GetProperty(quality); if (info == null) { return(false); } int currentTraitValue = (int)info.GetValue(learningCharacter.MyTraits); if (currentTraitValue <= 1 || currentTraitValue >= 100) { continue; } if (failedTests > succeededTests) { //if you lose the lottery you go down! if (RandomValueGenerator.GeneratePercentileIntegerValue() <= qualityDevolveRate) { info.SetValue(learningCharacter.MyTraits, currentTraitValue - 1); } } //This makes it linearly harder to evolve a strong point. if (currentTraitValue >= Constants.MinStrongPoint && Constants.MaxStrongPoint - currentTraitValue < qualityEvolveRate) { qualityEvolveRate = Constants.MaxStrongPoint - currentTraitValue; } //This makes it harder to evolve out of a weak point. if (currentTraitValue <= Constants.MaxWeakPoint && currentTraitValue < qualityEvolveRate) { qualityEvolveRate = currentTraitValue; } //if you win the lottery you go up! if (RandomValueGenerator.GeneratePercentileIntegerValue() >= 100 - qualityEvolveRate) { info.SetValue(learningCharacter.MyTraits, currentTraitValue + 1); } } return(true); }
public void IncludeAndCount() { var generator = new RandomValueGenerator(); { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.Space; for (uint count = 100; count < 200; ++count) { generator.DefaultStringListCount = count; var list = generator.Strings(); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(count, (uint) list.Length, count.ToString(CultureInfo.InvariantCulture)); ValidateStrings(list, CharTypesAllowed.Space); } } { generator.DefaultCharsToInclude = RandomValueGenerator.CharsToInclude.AlphaNumeric; for (uint count = 100; count < 200; ++count) { generator.DefaultStringListCount = count; var list = generator.Strings(); Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(count, (uint) list.Length, count.ToString(CultureInfo.InvariantCulture)); ValidateStrings(list, CharTypesAllowed.Upper | CharTypesAllowed.Lower | CharTypesAllowed.Digit); } } }
public void IncludeSymbol() { var generator = new RandomValueGenerator(); for (var i = 0; i < _iterations; ++i) { var ch = generator.Char(RandomValueGenerator.CharsToInclude.Symbols); var valid = ch.IsSymbol(); Assert.That(Value.Of(valid).Is().True(), ch.ToString(CultureInfo.InvariantCulture)); } }