public void Provider_WithCustomVowelProbability_AffectsNameGenerationSuccess()
{
// Defining at least one vowel sequence, but no individual vowels also shouldn't work if
// the probability of vowel sequences is not set to 100%
var provider = new SyllableProvider().WithVowelSequences("aa");
var generator = new NameGenerator().UsingProvider(provider);
Assert.ThrowsException <InvalidOperationException>(() => // Some will succeed, but expecting some to fail
{
for (int i = 0; i < 1000; i++)
{
generator.Next();
}
});
// Defining at least one vowel sequence, set to 100% probability
// without any possibility of vowels starting name shoudl work
// provider.WithVowelSequenceProbability(1.0).WithStartingSyllableLeadingVowelSequenceProbability(1.0);
//provider.WithProbability(x => x.OfVowelSequences(1.0).OfStartingSyllableLeadingVowelSequence(1.0));
provider.WithProbability(vowelIsSequence: 1.0, vowelBeginsStartingSyllableAndIsSequence: 1.0);
for (int i = 0; i < 1000; i++)
{
Assert.IsNotNull(generator.Next());
}
// The normal scenario where at least one individual vowel is defined
//provider.WithVowels("a").WithProbability(x => x.OfVowelSequences(0));
provider.WithVowels("a").WithProbability(vowelIsSequence: 0);
for (int i = 0; i < 1000; i++)
{
Assert.IsNotNull(generator.Next());
}
}
private bool EachOutputContainsAnyOf(SyllableProvider p, params string[] validSubstrings)
{
bool outputAlwaysAppears = true;
for (int i = 0; i < 1000; i++)
{
var s = p.NextSyllable();
if (!s.ContainsAny(validSubstrings))
{
outputAlwaysAppears = false;
break;
}
}
return(outputAlwaysAppears);
}
public void Provider_WithOnlyVowelsDefined_SyllablesGeneratedCorrectly()
{
// Define all vowels
var provider = new SyllableProvider().WithVowels("aeiou");
// Check that every syllable-generating method works and generates nothing but the vowels
for (int i = 0; i < 1000; i++)
{
var startingSyllable = provider.NextStartingSyllable();
var syllable = provider.NextStartingSyllable();
var endingSyllable = provider.NextEndingSyllable();
Assert.IsTrue(!string.IsNullOrEmpty(startingSyllable) && Regex.IsMatch(startingSyllable, "^[aeiouAEIOU]+$"));
Assert.IsTrue(!string.IsNullOrEmpty(syllable) && Regex.IsMatch(syllable, "^[aeiouAEIOU]+$"));
Assert.IsTrue(!string.IsNullOrEmpty(endingSyllable) && Regex.IsMatch(endingSyllable, "^[aeiouAEIOU]+$"));
}
}
public void Provider_WithNoVowelsDefined_ProviderThrowsInvalidOperationException()
{
// Define everything except vowel and vowel sequences
var provider = new SyllableProvider()
.WithLeadingConsonants("b")
.WithLeadingConsonantSequences("bb", "bbb")
.WithTrailingConsonants("b")
.WithTrailingConsonantSequences("bbbb", "bbbbb");
// Syllables always require a vowel so syllable generation should fail
for (int i = 0; i < 1000; i++)
{
Assert.ThrowsException <InvalidOperationException>(() => provider.NextStartingSyllable());
Assert.ThrowsException <InvalidOperationException>(() => provider.NextSyllable());
Assert.ThrowsException <InvalidOperationException>(() => provider.NextEndingSyllable());
}
}
public void Provider_WithNoVowelsDefined_NameGeneratorThrowsInvalidOperationException()
{
// Same as Provider_WithNoVowelsDefined_ProviderThrowsInvalidOperationException
// except it applies to a NameGenerator
var provider = new SyllableProvider()
.WithLeadingConsonants("b")
.WithLeadingConsonantSequences("bb", "bbb")
.WithTrailingConsonants("b")
.WithTrailingConsonantSequences("bbbb", "bbbbb");
var generator = new NameGenerator().UsingProvider(provider);
for (int i = 0; i < 1000; i++)
{
Assert.ThrowsException <InvalidOperationException>(() => generator.Next());
}
}
private bool AllOutputContainsAtLeastOnce(SyllableProvider p, params string[] validSubstrings)
{
bool[] substringAppeared = new bool[validSubstrings.Length];
for (int i = 0; i < 1000; i++)
{
var s = p.NextSyllable();
for (int j = 0; j < validSubstrings.Length; j++)
{
if (s.Contains(validSubstrings[j]))
{
substringAppeared[j] = true;
}
}
}
return(substringAppeared.All(x => x));
}
public void Provider_WhenCustomVowelsDefined_OnlyCustomVowelsAppearInProviderOutput()
{
// Define one and only one vowel then check name output
var provider = new SyllableProvider()
.WithVowels("a")
.WithLeadingConsonants("bcdfg")
.WithTrailingConsonants("bcdfg");
for (int i = 0; i < 1000; i++)
{
var startingSyllable = provider.NextStartingSyllable();
var syllable = provider.NextSyllable();
var endingSyllable = provider.NextEndingSyllable();
Assert.IsTrue(startingSyllable.Contains("a"));
Assert.IsTrue(syllable.Contains("a"));
Assert.IsTrue(endingSyllable.Contains("a"));
Assert.IsFalse(Regex.IsMatch(startingSyllable, "[e|i|o|u]"));
Assert.IsFalse(Regex.IsMatch(syllable, "[e|i|o|u]"));
Assert.IsFalse(Regex.IsMatch(endingSyllable, "[e|i|o|u]"));
}
// Change the one and only vowel and check name output again
provider = new SyllableProvider()
.WithVowels("y")
.WithLeadingConsonants("bcdfg")
.WithTrailingConsonants("bcdfg");
for (int i = 0; i < 1000; i++)
{
var startingSyllable = provider.NextStartingSyllable();
var syllable = provider.NextSyllable();
var endingSyllable = provider.NextEndingSyllable();
Assert.IsTrue(startingSyllable.Contains("y"));
Assert.IsTrue(syllable.Contains("y"));
Assert.IsTrue(endingSyllable.Contains("y"));
Assert.IsFalse(Regex.IsMatch(startingSyllable, "[a|e|i|o|u]"));
Assert.IsFalse(Regex.IsMatch(syllable, "[a|e|i|o|u]"));
Assert.IsFalse(Regex.IsMatch(endingSyllable, "[a|e|i|o|u]"));
}
}
public static void Main(string[] args)
{
{
// Quickest way to use Syllabore's name generator
// without specifying any configuration. This instance
// will default to using StandaloneSyllableProvider for
// name generator and will not use any NameValidator to
// improve output.
var g = new NameGenerator();
for (int i = 0; i < 10; i++)
{
Console.WriteLine(g.Next());
}
}
{
// Normally the constructor takes a SyllableProvider
// and NameValidator. There are "Standalone" classes
// available for quick and dirty use. It is recommended
// you create your own by using ISyllableProvider/INameValidator
// or inheriting from ConfigurableSyllableProvider/ConfigurableNameValidator.
var provider = new DefaultSyllableProvider();
var validator = new NameValidator()
.DoNotAllowPattern(@"[j|p|q|w]$") // Invalidate these awkward endings
.DoNotAllowPattern(@"(\w)\1\1") // Invalidate any sequence of 3 or more identical letters
.DoNotAllowPattern(@"([^aeiouAEIOU])\1\1\1"); // Invalidate any sequence of 4 or more consonants
var g = new NameGenerator(provider, validator);
for (int i = 0; i < 10; i++)
{
Console.WriteLine(g.Next());
}
}
{
// You can choose to build name generators programmatically.
var g = new NameGenerator()
.UsingProvider(x => x
.WithLeadingConsonants("str")
.WithVowels("ae"))
.LimitSyllableCount(3);
for (int i = 0; i < 10; i++)
{
Console.WriteLine(g.Next());
}
Console.WriteLine();
}
{
// Creating variations of a single name
var g = new NameGenerator().UsingMutator(new VowelMutator());
for (int i = 0; i < 3; i++)
{
var name = g.NextName();
Console.WriteLine(name);
for (int j = 0; j < 4; j++)
{
var variation = g.Mutate(name);
Console.WriteLine(variation);
}
}
}
{
Console.WriteLine();
var g = new NameGenerator()
.UsingProvider(p => p
.WithVowels("aeoy")
.WithLeadingConsonants("vstlr")
.WithTrailingConsonants("zrt")
.WithVowelSequences("ey", "ay", "oy"))
.UsingMutator(m => m
.WithMutation(x => x.ReplaceSyllable(0, "Gran"))
.WithMutation(x => x.ReplaceSyllable(0, "Bri"))
.WithMutation(x => x.InsertSyllable(0, "Deu").AppendSyllable("gard").WithWeight(2))
.WithMutation(x => x.When(-2, "[aeoyAEOY]$").ReplaceSyllable(-1, "opolis"))
.WithMutation(x => x.When(-2, "[^aeoyAEOY]$").ReplaceSyllable(-1, "polis"))
.WithMutationCount(1))
.UsingValidator(v => v
.DoNotAllowPattern(
@".{12,}",
@"(\w)\1\1", // Prevents any letter from occuring three times in a row
@".*([y|Y]).*([y|Y]).*", // Prevents double y
@".*([z|Z]).*([z|Z]).*", // Prevents double z
@"(zs)", // Prevents "zs"
@"(y[v|t])")) // Prevents "yv" and "yt"
.LimitMutationChance(0.99)
.LimitSyllableCount(2, 4);
ConfigurationFile.Save(g, "city-name-generator.txt");
var g2 = ConfigurationFile.Load("city-name-generator.txt");
for (int i = 0; i < 50; i++)
{
var name = g.NextName();
Console.WriteLine(name);
}
Console.WriteLine();
}
{
var provider = new SyllableProvider();
provider.WithVowels("a", "e", "o", "y");
provider.WithLeadingConsonants("v", "s", "t", "l", "r");
provider.WithTrailingConsonants("z", "r", "t");
provider.WithVowelSequences("ey", "ay", "oy");
provider.DisallowLeadingConsonantSequences();
provider.DisallowTrailingConsonantSequences();
var shifter = new VowelMutator("a", "e", "o", "y");
var validator = new NameValidator();
validator.DoNotAllowPattern(@"(\w)\1\1");
validator.DoNotAllowPattern(@"([^aeoyAEOY])\1");
validator.DoNotAllowPattern(@".*([y|Y]).*([y|Y]).*");
validator.DoNotAllowPattern(@".*([z|Z]).*([z|Z]).*");
validator.DoNotAllowPattern(@"(zs)");
validator.DoNotAllowPattern(@"(y[v|t])");
var g = new NameGenerator(provider, shifter, validator);
g.LimitSyllableCount(2, 3);
}
{
var name = new Name("syl", "la", "bore");
var mutator = new NameMutator()
.Join(new DefaultNameMutator())
.Join(new VowelMutator());
for (int i = 0; i < 20; i++)
{
Console.WriteLine(mutator.Mutate(name));
}
}
}
public void Provider_CustomConsonantProbabilityDefined_AffectsSyllableGenerationCorrectly()
{
var provider = new SyllableProvider()
.WithVowels("a")
.WithVowelSequences("ee")
.WithLeadingConsonants("b")
.WithLeadingConsonantSequences("cc")
.WithTrailingConsonants("d")
.WithTrailingConsonantSequences("ff");
// Disable all leading and trailing consonants
Assert.IsTrue(EachOutputNeverContainsAnyOf(
provider.WithProbability(
consonantBeginsSyllable: 0.0,
consonantBeginsSyllableAndIsSequence: 0.0,
consonantEndsSyllable: 0.0,
consonantEndsSyllableAndIsSequence: 0.0),
"b", "cc", "d", "ff"));
// Consonant sequence probability doesn't matter
// if the consonant probability is zero
Assert.IsTrue(EachOutputNeverContainsAnyOf(
provider.WithProbability(
consonantBeginsSyllable: 0.0,
consonantBeginsSyllableAndIsSequence: 1.0,
consonantEndsSyllable: 0.0,
consonantEndsSyllableAndIsSequence: 1.0),
"b", "cc", "d", "ff"));
// Consonant sequence probability only matters
// if the consonant probability is not zero
provider.WithProbability(
consonantBeginsSyllable: 1.0,
consonantBeginsSyllableAndIsSequence: 0.0,
consonantEndsSyllable: 1.0,
consonantEndsSyllableAndIsSequence: 0.0);
// There should be no consonant sequences
Assert.IsTrue(EachOutputContainsAnyOf(provider, "b", "d"));
Assert.IsTrue(EachOutputNeverContainsAnyOf(provider, "cc", "ff"));
provider.WithProbability(
consonantBeginsSyllable: 1.0,
consonantBeginsSyllableAndIsSequence: 1.0,
consonantEndsSyllable: 1.0,
consonantEndsSyllableAndIsSequence: 1.0);
// There should always be consonant sequences
Assert.IsTrue(EachOutputNeverContainsAnyOf(provider, "b", "d"));
Assert.IsTrue(EachOutputContainsAnyOf(provider, "cc", "ff"));
// Test whether a value between 0 and 1 ouputs both consonants and consonant sequences
provider.WithProbability(
consonantBeginsSyllable: 1.0,
consonantBeginsSyllableAndIsSequence: 0.5,
consonantEndsSyllable: 1.0,
consonantEndsSyllableAndIsSequence: 0.5);
Assert.IsTrue(AllOutputContainsAtLeastOnce(provider, "b", "d", "cc", "ff"));
// Not all output will have a consonant
provider.WithProbability(
consonantBeginsSyllable: 0.5,
consonantBeginsSyllableAndIsSequence: 0.5,
consonantEndsSyllable: 0.5,
consonantEndsSyllableAndIsSequence: 0.5);
Assert.IsTrue(AllOutputContainsAtLeastOnce(provider, "b", "d", "cc", "ff"));
}
public void Provider_WithCustomComponents_AllComponentsAppearInProviderOutput()
{
// In this test we define one instance of a vowel, vowel sequence
// leading consonant, leading consonant sequence, trailing consonant
// and trailing consonant sequence, then check that each instance occurs
// at least once in the provider's syllable generation.
var provider = new SyllableProvider()
.WithVowels("a")
.WithVowelSequences("ee")
.WithLeadingConsonants("b")
.WithLeadingConsonantSequences("cc")
.WithTrailingConsonants("d")
.WithTrailingConsonantSequences("ff")
.WithProbability(
vowelIsSequence: 0.5,
vowelBeginsStartingSyllable: 0.25,
consonantBeginsSyllable: 0.50,
consonantEndsSyllable: 0.50);
/*
* .WithProbability(y => y
* .OfVowelSequences(0.5)
* .OfStartingSyllableLeadingVowels(0.25)
* .OfLeadingConsonantSequences(0.50)
* .OfTrailingConsonants(0.50));
*/
bool foundVowel = false;
bool foundVowelSequence = false;
bool foundStartingConsonant = false;
bool foundStartingConsonantSequence = false;
bool foundEndingConsonant = false;
bool foundEndingConsonantSequence = false;
// Starting syllables only
for (int i = 0; i < 500; i++)
{
var syllable = provider.NextStartingSyllable();
if (syllable.Contains("a"))
{
foundVowel = true;
}
if (syllable.Contains("ee"))
{
foundVowelSequence = true;
}
if (syllable.Contains("b"))
{
foundStartingConsonant = true;
}
if (syllable.Contains("cc"))
{
foundStartingConsonantSequence = true;
}
if (syllable.Contains("d"))
{
foundEndingConsonant = true;
}
if (syllable.Contains("ff"))
{
foundEndingConsonantSequence = true;
}
}
Assert.IsTrue(foundVowel);
Assert.IsTrue(foundVowelSequence);
Assert.IsTrue(foundStartingConsonant);
Assert.IsTrue(foundStartingConsonantSequence);
Assert.IsTrue(foundEndingConsonant);
Assert.IsTrue(foundEndingConsonantSequence);
// Reset
foundVowel = false;
foundVowelSequence = false;
foundStartingConsonant = false;
foundStartingConsonantSequence = false;
foundEndingConsonant = false;
foundEndingConsonantSequence = false;
// All syllables
for (int i = 0; i < 500; i++)
{
var syllable = provider.NextSyllable();
if (syllable.Contains("a"))
{
foundVowel = true;
}
if (syllable.Contains("ee"))
{
foundVowelSequence = true;
}
if (syllable.Contains("b"))
{
foundStartingConsonant = true;
}
if (syllable.Contains("cc"))
{
foundStartingConsonantSequence = true;
}
if (syllable.Contains("d"))
{
foundEndingConsonant = true;
}
if (syllable.Contains("ff"))
{
foundEndingConsonantSequence = true;
}
}
Assert.IsTrue(foundVowel);
Assert.IsTrue(foundVowelSequence);
Assert.IsTrue(foundStartingConsonant);
Assert.IsTrue(foundStartingConsonantSequence);
Assert.IsTrue(foundEndingConsonant);
Assert.IsTrue(foundEndingConsonantSequence);
// Reset
foundVowel = false;
foundVowelSequence = false;
foundStartingConsonant = false;
foundStartingConsonantSequence = false;
foundEndingConsonant = false;
foundEndingConsonantSequence = false;
// Ending syllables only
for (int i = 0; i < 500; i++)
{
var syllable = provider.NextEndingSyllable();
if (syllable.Contains("a"))
{
foundVowel = true;
}
if (syllable.Contains("ee"))
{
foundVowelSequence = true;
}
if (syllable.Contains("b"))
{
foundStartingConsonant = true;
}
if (syllable.Contains("cc"))
{
foundStartingConsonantSequence = true;
}
if (syllable.Contains("d"))
{
foundEndingConsonant = true;
}
if (syllable.Contains("ff"))
{
foundEndingConsonantSequence = true;
}
}
Assert.IsTrue(foundVowel);
Assert.IsTrue(foundVowelSequence);
Assert.IsTrue(foundStartingConsonant);
Assert.IsTrue(foundStartingConsonantSequence);
Assert.IsTrue(foundEndingConsonant);
Assert.IsTrue(foundEndingConsonantSequence);
}
