public void Validate_WordCount_InSentence_NegativeTesting()
{
//Step1: arrange
//test input
var line = "This is a statement, and so is this.";
IWordProcessor wordProcessor = new WordProcessor();
//expected output
var expectedDictionary = new System.Collections.Generic.Dictionary<string, int>
{
{"this",2},
{"is", 2},
{"a", 1},
{"statement", 2}, //changed for negative testing from 1 to 2
{"and", 1},
{"so", 1 }
};
//Step2: act
//Calculate the word count and store in dictionary
var outputDictionary = wordProcessor.CalculateWordCount(line);
// Step3: assert
//compare expected dictionary and actual dictionary derived from sentence
Assert.IsFalse(expectedDictionary.SequenceEqual(outputDictionary));
}
/// <summary>
/// Find and remove word
/// </summary>
/// <param name="wordText">Text to remove</param>
public void RemoveWord(string wordText)
{
float minEditDistance = WordProcessor.GetWordTyping(wordText) / 2;
WordObject missWord = null;
foreach (WordObject child in words)
{
if (child.wordText == wordText)
{
child.Destroy();
WordSpawner.inst.lastNameWordCreated -= PhaseInfo.NameSpawnReduce(currentPhase);
return;
}
else
{
int editDistance = WordProcessor.GetEditDistance(child.wordText, wordText);
if (editDistance <= minEditDistance)
{
minEditDistance = editDistance;
missWord = child;
}
}
}
if (missWord != null)
{
//For test, do word miss reaction
Debug.Log("Missed word " + missWord.wordText);
}
//Check edit distance
}
public ActionResult Words(WordModel word)
{
ClearAlerts("Alert Words M", 3);
// get the list of words from Session
List <WordModel> words = getWords();
// we'll need to validate the data
if (words.Exists(w => w.Text == word.Text))
{
Session.Add("Alert Words M2", "Word already exists. Please use a distinct text.");
return(View());
}
// we need to add the word to the database first to get the Id
word.Id = WordProcessor.CreateWord(word.Text, (int)Session["Language"], word.ClassificationId, word.Description, word.Pronounciation);
words.Add(word);
// lastly, we'll need to clear the values in the fields
ModelState.SetModelValue("Text", new ValueProviderResult("", "", ModelState["Text"].Value.Culture));
ModelState.SetModelValue("Description", new ValueProviderResult("", "", ModelState["Description"].Value.Culture));
ModelState.SetModelValue("Pronounciation", new ValueProviderResult("", "", ModelState["Pronounciation"].Value.Culture));
return(View());
}
public void WordProcessor_LastWordHasArrived_LastWordProcessedEventHasBeenThrown()
{
var wordCache = MockRepository.GenerateMock <ICache>();
bool addToCacheHappened = false;
wordCache.Expect(x => x.Add(Arg <string> .Is.Anything, Arg <long> .Is.Anything))
.Do(new Action <string, long>((a, b) => { addToCacheHappened = true; }));
wordCache.Expect(x => x.Keys).Return(new[] { "something interesting" });
bool wordProcessedEventHasBeenThrown = false;
var wordProcessedHandler = new EventHandler <WordEventArgs>(new Action <object, WordEventArgs>((a, b) =>
{ wordProcessedEventHasBeenThrown = true; }));
var lastWordProcessedEventHasBeenThrown = false;
var lastWordProcessedHandler = new EventHandler(new Action <object, EventArgs>((a, b) =>
{ lastWordProcessedEventHasBeenThrown = true; }));
var testArgs = new WordEventArgs("something", 0, 1);
var wordProcessor = new WordProcessor(wordCache);
wordProcessor.WordProcessed += new EventHandler <WordEventArgs>(wordProcessedHandler);
wordProcessor.LastWordProcessed += new EventHandler(lastWordProcessedHandler);
wordProcessor.ProcessWord(new object(), testArgs);
Assert.IsTrue(addToCacheHappened);
Assert.IsFalse(wordProcessedEventHasBeenThrown);
Assert.IsTrue(lastWordProcessedEventHasBeenThrown);
}
static void Main(string[] args)
{
bard = new Bard(GetMainProjectDirectory());
TellThemWhatWereAllAbout();
string theme = Console.ReadLine();
var words = new WordProcessor(GetMainProjectDirectory()).GetWordsFromSentence(theme);
try
{
var story = bard.TellStory(words);
Console.WriteLine("Well, here we go... are you ready? here is my story!");
Console.WriteLine(story.Title);
Console.WriteLine("==========================================================");
foreach (var line in story.Content)
{
Thread.Sleep(2000);
Console.WriteLine(line);
}
}
catch (InvalidInputException ex)
{
Console.WriteLine(ex.Message);
}
}
private void TestWord(string raw, string expected)
{
var cultue = "en-US";
var actual = WordProcessor.StemSingleWord(raw, cultue);
Assert.AreEqual(expected, actual);
}
private void StopWordTest(string raw, bool expected)
{
var cultue = "en-US";
var stemmed = WordProcessor.StemSingleWord(raw, cultue);
var actual = WordProcessor.IsStopWord(stemmed, cultue);
Assert.AreEqual(expected, actual);
}
/// <summary>
///
/// Clean this item.
///
/// </summary>
public void Dispose()
{
if (CleanAll)
{
m_StartPosition.Move();
WordProcessor.ClearAfterCursor();
Console.CursorVisible = true;
}
}
public ActionResult RemoveWord(int id)
{
// get the list of words from Session
List <WordModel> words = getWords();
words.RemoveAt(words.FindIndex(w => w.Id == id));
WordProcessor.DeleteWord(id);
return(RedirectToAction("Words", "Language"));
}
public void AddTabTest()
{
var richEdit = new RichEditBox();
var wordProcessor = new WordProcessor {
RichEdit = richEdit
};
wordProcessor.AddTabCommand.Execute(null);
Assert.AreEqual("\t", richEdit.Text);
}
public TextMesh textMesh; //Text field(text mesh) of this word object
/// <summary>
/// Create word object by text
/// </summary>
/// <param name="_wordText">Text of the word object</param>
/// <param name="pos">Initial position of the word object</param>
public virtual void Initiate(string _wordText)
{
textMesh = transform.Find("WordText").GetComponent <TextMesh>();
wordText = _wordText;
wordGrade = WordProcessor.GetWordGrade(wordText);
textMesh.text = wordText;
transform.position = new Vector2(Random.Range(minX, maxX), initialY);
wordWeight = wordGrade == 3 ? 3 : wordGrade == 2 ? 5 : wordGrade == 1 ? 7 : 10;
wordWeight *= WordProcessor.GetWordTyping(GameData.hopaeName) <= 9 ? 1 : 1 + (WordProcessor.GetWordTyping(GameData.hopaeName) - 9) * 0.1f;
WordSpace.inst.brainWeight += wordWeight;
WordSpace.inst.words.Add(this);
}
public void PrepareWords_ShouldReturnOneWord_OnSameWordUpperAndLower()
{
var words = new List <string> {
"word", "WORD", "wOrD"
};
var expectedWordsValue = new Word("word");
var processor = new WordProcessor(wordSelector, wordCounter);
var result = processor.PrepareWords(words);
result.Should().AllBeEquivalentTo(expectedWordsValue);
}
public void PrepareWords_ShouldReturnEmptyCollection_OnNoneSelected()
{
wordSelector.IsSelectedWord(Arg.Any <Word>()).ReturnsForAnyArgs(x => ((Word)x[0]).Value == "word");
var words = new List <string> {
"word1", "word2", "word3"
};
var processor = new WordProcessor(wordSelector, wordCounter);
var result = processor.PrepareWords(words);
result.Should().BeEmpty();
}
public App()
{
InitializeComponent();
WordProcessor.Initialize();
MainPage = new NavigationPage(new MainPage());
#if DEBUG
LiveReload.Init();
#endif
}
public void WordProcessor_ExcludBadWords()
{
var shellMock = new Mock <IMystemShell>();
shellMock.Setup(s => s.GetInterestingWords(It.IsAny <string>())).Returns(new List <string> {
"мама{", "мыла{", "раму{"
});
var processor = new WordProcessor(new [] { "раму" }, shellMock.Object);
processor.GetFrequencyDictionary("").GetValueOrThrow().ContainsKey("раму").Should().BeFalse();
}
public MainWindow()
{
InitializeComponent();
Viewer = InitializeDocumentViewer();
RichEditBox = InitializeRichEdit();
wordProcessor = InitializeWordProcessor();
DataContext = wordProcessor;
Loaded += (s, e) =>
{
RichEditBox.Focus();
};
}
public void PrepareWords_ShouldReturnAllWords_OnAllSelected()
{
wordSelector.IsSelectedWord(Arg.Any <Word>()).ReturnsForAnyArgs(x => ((Word)x[0]).Value == "word");
var words = new List <string> {
"word", "word", "word"
};
var processor = new WordProcessor(wordSelector, wordCounter);
var result = processor.PrepareWords(words);
result.Select(w => w.Value).Should().BeEquivalentTo(words);
}
private static void Main(string[] args)
{
Console.WriteLine("Bags!");
var rootPath = IOUtilities.GetExecutionPath() + "/";
var loadPath = rootPath + "queue/";
var savePath = rootPath + "processed/";
WordProcessor.CountWordsInFiles(rootPath, loadPath, savePath);
Console.ReadKey();
}
public void ToggleShadowTest()
{
var richEdit = new RichEditBox();
var wordProcessor = new WordProcessor {
RichEdit = richEdit
};
wordProcessor.ToggleShadowCommand.Execute(null);
var shadow = wordProcessor.RichEdit.Document.Selection.Font.Shadow;
Assert.AreEqual(FormatEffect.Off, shadow);
}
public void ToggleItalicTest()
{
var richEdit = new RichEditBox();
var wordProcessor = new WordProcessor {
RichEdit = richEdit
};
wordProcessor.ToggleItalicCommand.Execute(null);
var italic = wordProcessor.RichEdit.Document.Selection.Font.Italic;
Assert.AreEqual(FormatEffect.Off, italic);
}
public void ToggleBoldTest()
{
var richEdit = new RichEditBox();
var wordProcessor = new WordProcessor {
RichEdit = richEdit
};
wordProcessor.ToggleBoldCommand.Execute(null);
var bold = wordProcessor.RichEdit.Document.Selection.Font.Bold;
Assert.AreEqual(FormatEffect.Off, bold);
}
public void AlignParagraphTest()
{
var richEdit = new RichEditBox();
var wordProcessor = new WordProcessor {
RichEdit = richEdit
};
wordProcessor.AlignParagraphCommand.Execute(ParagraphAlignment.Justify);
var alignment = wordProcessor.RichEdit.Document.Selection.Paragraph.Alignment;
Assert.AreEqual(ParagraphAlignment.Justify, alignment);
}
public Scripting(DataSet Data, WordProcessor Processor)
{
this.Data = Data;
this.Processor = Processor;
InTemplateChunk = false;
Options = ScriptOptions.Default
.WithReferences(typeof(Scripting).Assembly)
.WithImports("System")
.WithImports("WhitePlatinumLib")
;
}
public void ToggleUnderlineTest()
{
var richEdit = new RichEditBox();
var wordProcessor = new WordProcessor {
RichEdit = richEdit
};
wordProcessor.ToggleUnderlineCommand.Execute(null);
var underline = wordProcessor.RichEdit.Document.Selection.Font.Underline;
Assert.AreEqual(0, underline);
}
public void ToggleSuperscriptTest()
{
var richEdit = new RichEditBox();
var wordProcessor = new WordProcessor {
RichEdit = richEdit
};
wordProcessor.ToggleSuperscriptCommand.Execute(null);
var superscript = wordProcessor.RichEdit.Document.Selection.Font.Superscript;
Assert.AreEqual(FormatEffect.Off, superscript);
}
public void ToggleStrikethroughTest()
{
var richEdit = new RichEditBox();
var wordProcessor = new WordProcessor {
RichEdit = richEdit
};
wordProcessor.ToggleStrikethroughCommand.Execute(null);
var strikethrough = wordProcessor.RichEdit.Document.Selection.Font.Strikethrough;
Assert.AreEqual(FormatEffect.Off, strikethrough);
}
public void ToggleSmallCapsTest()
{
var richEdit = new RichEditBox();
var wordProcessor = new WordProcessor {
RichEdit = richEdit
};
wordProcessor.ToggleSmallCapsCommand.Execute(null);
var smallCaps = wordProcessor.RichEdit.Document.Selection.Font.SmallCaps;
Assert.AreEqual(FormatEffect.Off, smallCaps);
}
public void WordProcessor_ExcludBorringWords()
{
var shellMock = new Mock <IMystemShell>();
shellMock.Setup(s => s.GetInterestingWords(It.IsAny <string>()))
.Returns(new List <string> {
"я{я=PR", "не{не=PART", "мама{мама=V"
});
var processor = new WordProcessor(new string[0], shellMock.Object);
processor.GetFrequencyDictionary("").GetValueOrThrow().Keys.Count.ShouldBeEquivalentTo(1);
}
public void PrepareWords_ShouldReturnOnlySelectedWords_OnSomeSelected()
{
wordSelector.IsSelectedWord(Arg.Any <Word>()).ReturnsForAnyArgs(x => ((Word)x[0]).Value == "word");
var words = new List <string> {
"word1", "word2", "word"
};
var expectedWordsValue = new Word("word");
var processor = new WordProcessor(wordSelector, wordCounter);
var result = processor.PrepareWords(words);
result.Should().HaveCount(1).And.AllBeEquivalentTo(expectedWordsValue);
}
private void Button2_Click(object sender, EventArgs e)
{
var myContext = new VatContext();
var myService = new VatService(new UnityOfWork(myContext), new VatRepository(myContext));
var listChecks = new JsonService(JsonDeserializer.Deserialize(_jsonFile, _companyNameFile));
var generatedWordFile = Directory.GetCurrentDirectory() + "\\" + String.Format("{0:y}", DateTime.Now).Trim() + ".docx";
var wp = new WordProcessor(listChecks.ListOfChecks, generatedWordFile);
}
public void PrepareWords_ShouldReturnLoweredWords_OnWordsInCaps()
{
var words = new List <string> {
"WORD1", "word2", "WoRd3"
};
var expectedWordsValues = new List <string> {
"word1", "word2", "word3"
};
var processor = new WordProcessor(wordSelector, wordCounter);
var result = processor.PrepareWords(words);
result.Select(w => w.Value).Should().BeEquivalentTo(expectedWordsValues);
}
static void Main()
{
ILogger logger;
//Relocate this dependency to some factory or get it's instance from repository/MEF/UNITY
logger = new Author.Logger();
try
{
Console.WriteLine ("Enter a sentence and press enter to count occurences of word");
Console.WriteLine("Input:\n--------------------");
//Enter the sentence
var line = Console.ReadLine();
//Check if the sentence is blank
if (line.Trim().Length <= 0)
{
Console.WriteLine("You have entered blank sentence. Please try again..!");
Console.WriteLine("Input:\n--------------------");
line = Console.ReadLine();
}
//Relocate this dependency to some factory or get it's instance from repository/MEF/UNITY
IWordProcessor wordProcessor = new WordProcessor();
//Calculate wordcount
var dictionary = wordProcessor.CalculateWordCount(line);
//Display wordcount
wordProcessor.DisplayWordCount(dictionary);
Console.WriteLine("\nPress enter to exit..");
Console.ReadLine();
}
catch (Exception ex)
{
logger.WriteLog("Error occured :" + ex.Message);
}
}
internal static void ExtractAllWords(string original, WordProcessor process)
{
foreach (Match match in wordBrk.Matches(original))
{
process(match.Value);
}
}
