internal CaseWordVocabularySource(ApplicationModel model, WordVocabularySource source, HeadWordItem target)
: base(model)
{
_source = source;
_target = target;
var substitutes = new List <string>();
var tile = TileData.FromTokenString(target.Content);
var content = tile.Content;
var isPrefix = tile.IsPrefix;
var isSuffix = tile.IsSuffix;
var attributes = tile.Attributes;
var included = new HashSet <string> {
target.Content
};
var map = WordCaseMap.Create(content);
if (map.LetterCount != 0)
{
var position0 = map.Positions[0];
CheckedAdd(model.HeadItems[0].Culture.TextInfo.ToTitleCase(content));
CheckedAdd(content.ToLower());
CheckedAdd(content.ToUpper());
CheckedAdd(content.Substring(0, position0) + char.ToUpper(content[position0]) + content.Substring(position0 + 1));
for (var i = 0; i < map.Positions.Length; i++)
{
var position = map.Positions[i];
var ch = map.Uppers[i] ? char.ToLower(content[position]) : char.ToUpper(content[position]);
var cased = content.Substring(0, position) + ch + content.Substring(position + 1);
CheckedAdd(cased);
}
void CheckedAdd(string newContent)
{
var newTile = TileData.Create(content: newContent, isSuffix: isPrefix, isPrefix: isSuffix, attributes: attributes);
var version = newTile.ToTokenString();
if (included.Add(version))
{
substitutes.Add(version);
}
}
}
for (var i = 0; i < 4; i++)
{
var spacedTile = TileData.Create(content: content, isSuffix: (i & 1) != 0, isPrefix: (i & 2) != 0, attributes: attributes);
var spacedContent = spacedTile.ToTokenString();
if (included.Add(spacedContent))
{
substitutes.Add(spacedContent);
}
}
_substitutes = substitutes.ToArray();
}
public void CheckTokenizationTest()
{
CheckTokenization(TileData.Create("Normal"), "Normal");
CheckTokenization(TileData.Create("Prefix", isPrefix: true), "Prefix\0B");
CheckTokenization(TileData.Create("Suffix", isSuffix: true), "Suffix\0A");
CheckTokenization(TileData.Create("Infix", isPrefix: true, isSuffix: true), "Infix\0J");
void CheckTokenization(TileData tile, string expected)
{
var token = tile.ToTokenString();
Assert.AreEqual(expected, token);
var reborn = TileData.FromTokenString(token);
Assert.AreEqual(tile, reborn);
}
}
public void NoNullInContentTest()
{
var contents = new[] { "Good", "Bad\0", "\0Badder", "Bad\0est" };
for (var i = 0; i < contents.Length; i++)
{
var good = true;
try
{
_ = TileData.Create(contents[i]);
}
catch (ArgumentException)
{
good = false;
}
Assert.AreEqual(i == 0, good);
}
}
public void TileEqualityTest()
{
var unmatchable = TileData.Create("TEST");
var matchable = TileData.Create("1");
var plainWrong = "Wibble";
var matchCount = 0;
foreach (var element in ElementEnumerable)
{
Assert.IsFalse(unmatchable.Equals(element));
if (matchable.Equals(element))
{
matchCount++;
}
Assert.IsFalse(plainWrong.Equals(element));
Assert.AreEqual(element.Equals(matchable), matchable.Equals(element));
Assert.AreEqual(element.Equals(unmatchable), unmatchable.Equals(element));
Assert.AreEqual(element.Equals(plainWrong), plainWrong.Equals(element));
}
Assert.AreEqual(1, matchCount);
}
public void SpacingThrashTest()
{
ThrashTestHelper.Run(8, v => SequenceSanityCheck(v),
TileData.Create("X", false, false),
TileData.Create("X", true, false),
TileData.Create("X", false, true),
TileData.Create("X", true, true));
ThrashTestHelper.Run(8, v => SequenceSanityCheck(v),
TileData.Create("-", false, false),
TileData.Create("-", true, false),
TileData.Create("-", false, true),
TileData.Create("-", true, true));
ThrashTestHelper.Run(4, v => SequenceSanityCheck(v),
TileData.Create("X", false, false),
TileData.Create("X", true, false),
TileData.Create("X", false, true),
TileData.Create("X", true, true),
TileData.Create("-", false, false),
TileData.Create("-", true, false),
TileData.Create("-", false, true),
TileData.Create("-", true, true));
}
public void IsSimpleWordTest()
{
{
var tile = TileData.Create("Hello");
Assert.IsTrue(tile.ToString() == "<T>Hello</T>");
Assert.IsTrue(tile.IsSimpleWord);
}
var simples = new[] { "Hello", "This-is" };
foreach (var simple in simples)
{
var tile = TileData.Create(simple);
Assert.IsTrue(tile.IsSimpleWord);
}
foreach (var simple in simples)
{
var tile = TileData.Create(simple, isPrefix: true);
Assert.IsFalse(tile.IsSimpleWord);
}
foreach (var simple in simples)
{
var tile = TileData.Create(simple, isSuffix: true);
Assert.IsFalse(tile.IsSimpleWord);
}
var complexes = new[] { "Hello World", "&^%^" };
foreach (var complex in complexes)
{
var tile = TileData.Create(complex);
Assert.IsFalse(tile.IsSimpleWord);
}
}
public void EqualsTest()
{
var a = TileData.Create("A");
var b = TileData.Create("B");
var sequences = new[]
{
TileSequence.FromData(),
TileSequence.FromData(a, a),
TileSequence.FromData(a, b),
TileSequence.FromData(b, a)
};
for (var i = 0; i < sequences.Length; i++)
{
for (var j = 0; j < sequences.Length; j++)
{
var lhs = sequences[i];
var rhs = sequences[j];
var equals = lhs.Equals(rhs);
var lhsHash = lhs.GetHashCode();
var rhsHash = rhs.GetHashCode();
Assert.AreEqual(i == j, equals);
Assert.IsTrue(!equals || lhsHash == rhsHash);
var equalsUntyped = lhs.Equals((object)rhs);
var unequalsUntyped = lhs.Equals(42);
Assert.AreEqual(equals, equalsUntyped);
Assert.IsFalse(unequalsUntyped);
}
}
Assert.AreNotEqual(sequences[0], "Ethel the Aardvark");
}
public void HelloWorldSequenceCheck()
{
SequenceSanityCheck(TileData.Create("Hello"), TileData.Create("World"));
}
public void ComplexishConstructionTest()
{
var sequence = TileSequence.FromData(TileData.Create("hello"), TileData.Create("world"));
Assert.IsNotNull(sequence);
}
private void OnCursedTextChanged(object sender, RoutedEventArgs e)
{
var box = (TextBox)sender;
var text = box.Text;
var sequence = TileSequence.FromRaw(text);
var start = box.SelectionStart;
var length = box.SelectionLength;
Debug.WriteLine($"Selection is {start} for {length}");
var list = new List <TileVisualizationElement>();
var charPosition = 0;
var tilePosition = 0;
while (tilePosition < sequence.Count &&
charPosition + sequence[tilePosition].Content.Length <= start)
{
list.Add(new TileVisualizationElement(sequence[tilePosition].Type, sequence[tilePosition].Content, TileColor.Text, TileColor.HeadBackground));
charPosition += sequence[tilePosition].Content.Length;
tilePosition++;
if (tilePosition < sequence.Count &&
!sequence[tilePosition - 1].IsPrefix &&
!sequence[tilePosition].IsSuffix)
{
charPosition++;
}
}
if (length == 0)
{
if (tilePosition < sequence.Count)
{
if (charPosition < start)
{
var tile = sequence[tilePosition];
tilePosition++;
var prefix = TileData.Create(tile.Content.Substring(0, start - charPosition),
isPrefix: true,
isSuffix: tile.IsSuffix);
list.Add(new TileVisualizationElement(prefix.Type, prefix.Content, TileColor.Text, TileColor.HeadBackground));
var caret = TileData.Create("^");
list.Add(new TileVisualizationElement(caret.Type, caret.Content, TileColor.Text, TileColor.SuggestionPartBackground));
var suffix = TileData.Create(tile.Content.Substring(start - charPosition),
isPrefix: tile.IsPrefix,
isSuffix: true);
list.Add(new TileVisualizationElement(suffix.Type, suffix.Content, TileColor.Text, TileColor.HeadBackground));
}
else
{
var caret = TileData.Create("^",
isPrefix: start == charPosition,
isSuffix: start < charPosition);
list.Add(new TileVisualizationElement(caret.Type, caret.Content, TileColor.Text, TileColor.SuggestionPartBackground));
}
}
else
{
var caret = TileData.Create("^", isSuffix: true);
list.Add(new TileVisualizationElement(caret.Type, caret.Content, TileColor.Text, TileColor.SuggestionPartBackground));
}
}
else
{
}
while (tilePosition < sequence.Count)
{
list.Add(new TileVisualizationElement(sequence[tilePosition].Type, sequence[tilePosition].Content, TileColor.Text, TileColor.HeadBackground));
tilePosition++;
}
CursedContainer.Items.Clear();
foreach (var child in list)
{
CursedContainer.Items.Add(child);
}
}
