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