public void CanExecuteFromFiles()
{
foreach (var testFile in TestFileHelper.GetTestFiles())
{
CanGenerateFromFile(testFile);
}
}
public void WhenDictionaryDoesNotContainWordThenTheNewWordShouldBeAdded()
{
var word = "sheep";
var definition = TestFileHelper.SheepPermanentDefinition;
_wordService.AmendDictionary(Filename, word, definition);
_wordService.UpdateDictionaryFile();
var json = TestFileHelper.Read(Filename);
var response = JsonConvert.DeserializeObject <Dictionary>(json);
response.Should().BeEquivalentTo(new Dictionary
{
Words = new List <WordData>
{
new WordData
{
Word = "pelican",
Status = WordStatus.Temporary,
PermanentDefinition = null,
TemporaryDefinition = null
},
new WordData
{
Word = "sheep",
Status = WordStatus.Permanent,
PermanentDefinition = definition,
TemporaryDefinition = null
}
}
});
}
public GetDomainsVideoServiceTest()
{
var httpService = HttpServiceBuilder.Build();
_getDomainsVideoService = GetDomainsVideoServiceBuilder.Build(httpService);
_testFileHelper = new TestFileHelper();
}
public void WhenDoingIsAddedThenTemporaryDefinitionIsSetToBaseWord()
{
var word = "slothning";
var shortenedWord = "sloth";
_wordDefinitionHelper.GetDefinitionForWord("sloth").Returns(TestFileHelper.SlothTemporaryDefinition);
_webDictionaryRequestHelper.MakeContentRequest(shortenedWord).Returns("sloth word forms doing slothning");
_wordExistenceHelper.DoesWordExist(shortenedWord).Returns(true);
_temporaryDefinitionHelper = new TemporaryDefinitionHelper(_fileHelper);
var wordHelper = new WordHelper(_webDictionaryRequestHelper, _wordExistenceHelper, _wordDefinitionHelper, _fileHelper, _temporaryDefinitionHelper);
wordHelper.StrippedSuffixDictionaryCheck(_dictionary, word);
_wordService.UpdateDictionaryFile();
var json = TestFileHelper.Read(Filename);
var dictionary = JsonConvert.DeserializeObject <Dictionary>(json);
dictionary.Words.Should().ContainEquivalentOf(new WordData
{
Word = "slothning",
PermanentDefinition = null,
TemporaryDefinition = TestFileHelper.SlothTemporaryDefinition,
Status = WordStatus.Suffix
});
}
public AddDomainToVideoServiceTest()
{
var httpService = HttpServiceBuilder.Build();
_addDomainToVideoService = AddDomainToVideoServiceBuilder.Build(httpService);
_testFileHelper = new TestFileHelper();
}
public UploadVideoTest()
{
_testFileHelper = new TestFileHelper();
var httpService = HttpServiceBuilder.Build();
_uploadVideoService = UploadVideoServiceBuilder.Build(httpService);
}
public void test()
{
var folder = new DirectoryInfo(TestFileHelper.getOriginalResourcePath(""));
var files = folder.EnumerateFiles("*.jade", SearchOption.TopDirectoryOnly);
JadeConfiguration jade = new JadeConfiguration();
jade.setMode(Jade4Net.Mode.XHTML); // original jade uses xhtml by default
jade.setFilter("plain", new PlainFilter());
jade.setFilter("cdata", new CDATAFilter());
foreach (var file in files)
{
JadeTemplate template = jade.getTemplate(file.FullName);
TextWriter writer = new StringWriter();
jade.renderTemplate(template, new Dictionary <String, Object>(), writer);
String html = writer.ToString();
String expected = File.ReadAllText(file.FullName.Replace(".jade", ".html"));
// Trace.WriteLine("\n>> " + file.getName());
// Trace.WriteLine(html);
// Trace.WriteLine("-- " + file.getName());
// Trace.WriteLine(expected);
// Trace.WriteLine("<< " + file.getName());
if (Array.IndexOf(manualCompared, file.Name.Replace(".jade", "")) >= 0)
{
Assert.AreEqual(file.FullName, expected, html);
}
}
}
public GetOEmbedVideoTest()
{
var httpService = HttpServiceBuilder.Build();
_getOEmbedVideoService = GetOEmbedVideoServiceBuilder.Build(httpService);
_testFileHelper = new TestFileHelper();
}
public DeleteVideoTest()
{
var httpService = HttpServiceBuilder.Build();
_deleteVideoService = DeleteVideoServiceBuilder.Build(httpService);
_testFileHelper = new TestFileHelper();
}
private void run(String testName, bool pretty, JadeModel model)
{
JadeParser parser = null;
try
{
FileTemplateLoader loader = new FileTemplateLoader(TestFileHelper.getCompilerErrorsResourcePath(""),
"UTF-8");
parser = new JadeParser(testName, loader);
}
catch (IOException e)
{
Trace.WriteLine(e);
}
Node root = parser.parse();
Jade.Compiler.Compiler compiler = new Jade.Compiler.Compiler(root);
compiler.setPrettyPrint(pretty);
String expected = readFile(testName + ".html");
model.addFilter("markdown", new MarkdownFilter());
model.addFilter("plain", new PlainFilter());
String html;
try
{
html = compiler.compileToString(model);
Assert.AreEqual(expected.Trim(), html.Trim(), testName);
Assert.Fail();
}
catch (JadeCompilerException e)
{
Trace.WriteLine(e);
}
}
public void WhenWordDoesNotExistButUpdateHappensNothingShouldBeChanged()
{
var newDefinition = "This is not a definition";
var word = "Not a word";
_wordService.UpdateExistingWord(Filename, word, newDefinition);
_wordService.UpdateDictionaryFile();
var json = TestFileHelper.Read(Filename);
var dictionary = JsonConvert.DeserializeObject <Dictionary>(json);
dictionary
.Words
.Count
.Should()
.Be(8);
dictionary.Words.Should().Contain(x => x.Word == "sheep");
dictionary.Words.Should().Contain(x => x.Word == "sloth");
dictionary.Words.Should().Contain(x => x.Word == "pelican");
dictionary.Words.Should().Contain(x => x.Word == "lion");
dictionary.Words.Should().Contain(x => x.Word == "boxing");
dictionary.Words.Should().Contain(x => x.Word == "dodo");
dictionary.Words.Should().Contain(x => x.Word == "unicorn");
dictionary.Words.Should().Contain(x => x.Word == "dinosaur");
}
public AmendDictionaryTests()
{
var data = new Dictionary
{
Words = new List <WordData>
{
new WordData
{
Word = "pelican",
Status = WordStatus.Temporary,
PermanentDefinition = null,
TemporaryDefinition = null
}
}
};
_filenameHelper = Substitute.For <IFilenameHelper>();
_filenameHelper
.GetGuessedWordsFilename()
.Returns(GuessedWordsFilename);
_filenameHelper.GetDictionaryFilename().Returns(Filename);
TestFileHelper.CreateCustomFile(Filename, data);
_fileHelper = new FileHelper();
_wordService = new WordService(_wordExistenceHelper, _wordHelper, _wordDefinitionHelper, _fileHelper, _filenameHelper);
}
public void WhenUpdateRequestedButBothWordAndDefinitionAreEmptyNothingShouldBeChanged()
{
var newDefinition = "";
var word = "";
_wordService.UpdateExistingWord(Filename, word, newDefinition);
_wordService.UpdateDictionaryFile();
var json = TestFileHelper.Read(Filename);
var dictionary = JsonConvert.DeserializeObject <Dictionary>(json);
dictionary
.Words
.Count
.Should()
.Be(8);
dictionary.Words.Should().Contain(x => x.Word == "sheep");
dictionary.Words.Should().Contain(x => x.Word == "sloth");
dictionary.Words.Should().Contain(x => x.Word == "pelican");
dictionary.Words.Should().Contain(x => x.Word == "lion");
dictionary.Words.Should().Contain(x => x.Word == "boxing");
dictionary.Words.Should().Contain(x => x.Word == "dodo");
dictionary.Words.Should().Contain(x => x.Word == "unicorn");
dictionary.Words.Should().Contain(x => x.Word == "dinosaur");
}
public FileHelperTests()
{
_filename = "test-dictionary.json";
_filenameToCreate = "created-new-file.json";
TestFileHelper.Create(_filename);
}
public WordManagerTests()
{
TestFileHelper.Create(Filename);
_filenameHelper = Substitute.For <IFilenameHelper>();
_filenameHelper.GetDictionaryFilename().Returns(Filename);
_wordService = Substitute.For <IWordService>();
}
private async Task SaveAsync(MemoryActivity activity, string fileName)
{
using (var output = await TestFileHelper.OpenForWriteAsync(fileName))
{
var exporter = new FitExporter(activity);
await exporter.SaveAsync(output);
}
}
private async Task Export(MemoryActivity activity)
{
using (var output = await TestFileHelper.OpenForWriteAsync(GetExportedFileName()))
{
var exporter = new GpxExporter(activity);
await exporter.SaveAsync(output);
}
}
public async Task TcxImport()
{
using (var input = await TestFileHelper.OpenForReadAsync(_fileName))
{
var activity = new MemoryActivity();
var importer = new TcxImporter(activity);
importer.Load(input);
Assert.IsTrue(activity.TimeFrames.Count > 0);
}
}
public JadeLexerTest() //throws Exception
{
FileTemplateLoader loader1 = new FileTemplateLoader(TestFileHelper.getLexerResourcePath(""), "UTF-8");
lexer1 = new JadeLexer("test_file1.jade", loader1);
FileTemplateLoader loader2 = new FileTemplateLoader(TestFileHelper.getLexerResourcePath(""), "UTF-8");
lexer2 = new JadeLexer("empty_file.jade", loader2);
}
public void TidyUpXmlFilesDeletesXmlFilesWhenNotDebugging()
{
string testFilePath = TestFileHelper.UseTestMasterFile("YourXmlFile.xml");
FilesUtility util = new FilesUtility();
util.TidyUpXmlFiles(false, TestFileHelper.TestDirectoryName);
Assert.IsFalse(File.Exists(testFilePath));
// any other tests here.
}
public AddAnimatedThumbnailsToVideoTest()
{
var httpService = HttpServiceBuilder.Build();
_addAnimatedThumbnailsToVideoService = AddAnimatedThumbnailsToVideoServiceBuilder.Build(httpService);
_getStatusAnimatedThumbnailService = GetStatusAnimatedThumbnailServiceBuilder.Build(httpService);
_getAnimatedThumbnailService = GetAnimatedThumbnailServiceBuilder.Build(httpService);
_getVideoService = GetVideoServiceBuilder.Build(httpService);
_testFileHelper = new TestFileHelper();
}
public void StatementOfFunds()
{
var file = new TestFileHelper().ReadXmlFiles("StatementOfFunds").Single();
var response = new Reader().GetByString(file);
var anyEntry = response.FlexStatements.FlexStatement[0].StatementOfFunds.StatementOfFundsLine.First(x => x.TradeID == "554955532");
anyEntry.ActivityDescription.Should().Be("Buy 1 XSP 05DEC18 270.0 C ");
anyEntry.BuySell.Should().Be(BuySell.BUY);
anyEntry.TradePrice.Should().Be(14.2);
}
public async Task ReturnsVttGivenSrtTest()
{
var srt = await TestFileHelper.BuildSrtAsync();
var expectedVtt = await TestFileHelper.BuildVttAsync();
var vtt = SubtitleConverter.ConvertSrtToVtt(srt);
vtt.RemoveSpecialCharacters().ShouldBe(expectedVtt.RemoveSpecialCharacters());
}
public void TestUserWordGame()
{
TestFileHelper.Create(Filename);
var userGame = new UserWordGame(_wordService, _filenameHelper);
userGame.AddWordToList("sheep");
userGame.AddWordToList("sloth");
userGame.AddWordToList("dinosaur");
userGame.WordList.Should().HaveCount(3);
}
public UpdateExistingWordInDictionary()
{
_filenameHelper = Substitute.For <IFilenameHelper>();
_filenameHelper
.GetGuessedWordsFilename()
.Returns(Filename);
_filenameHelper.GetDictionaryFilename().Returns(Filename);
TestFileHelper.Create(Filename);
_fileHelper = new FileHelper();
_wordService = new WordService(_wordExistenceHelper, _wordHelper, _wordDefinitionHelper, _fileHelper, _filenameHelper);
}
public String getResourcePath(String fileName)
{
try
{
return(TestFileHelper.getRootResourcePath() + "/template/" + fileName);
}
catch (FileNotFoundException e)
{
Trace.WriteLine(e);
}
return(null);
}
private String readFile(String fileName)
{
try
{
return(File.ReadAllText(TestFileHelper.getCompilerErrorsResourcePath(fileName)));
}
catch (Exception)
{
// Trace.WriteLine(e);
}
return("");
}
public async Task TcxStripHeartRate()
{
using (var input = await TestFileHelper.OpenForReadAsync(_fileName))
{
var stripper = new TcxStripper();
using (var output = await TestFileHelper.OpenForWriteAsync(GetStrippedFileName(_fileName, "_stripped_hr")))
{
stripper.Strip(input, output, StripOptions.HeartRate);
Assert.True(output.Length > 0);
}
}
}
private async Task <MemoryActivity> LoadAsync(string fileName)
{
var activity = new MemoryActivity();
using (var input = await TestFileHelper.OpenForReadAsync(fileName))
{
var importer = new FitImporter(activity);
await importer.LoadAsync(input);
}
return(activity);
}
/// <summary>
/// Loads an <see cref="MemoryActivity"/> from a file
/// </summary>
/// <param name="fileName">Path of the file.</param>
/// <param name="funcImporter">The importer to be created for loading the activity.</param>
/// <returns>The imported <see cref="MemoryActivity"/>.</returns>
protected async Task <MemoryActivity> LoadAsync(string fileName, Func <MemoryActivity, ActivityImporter> funcImporter)
{
var activity = new MemoryActivity();
using (var input = await TestFileHelper.OpenForReadAsync(fileName))
{
var importer = funcImporter(activity);
importer.Load(input);
}
return(activity);
}
