public void A2B4()
{
var result = CharacterCounter.Frequency("ABABBB");
Assert.AreEqual(result['A'], 2);
Assert.AreEqual(result['B'], 4);
}
public void CountTest()
{
Assert.AreEqual(0, _counter.Count);
var counter = new CharacterCounter(10);
Assert.AreEqual(10, counter.Count);
}
public void CountingEmpty()
{
CharacterCounter cc = new CharacterCounter();
int length = cc.Characters("");
Assert.IsTrue(length == 0);
}
public void A1B1()
{
var result = CharacterCounter.Frequency("AB");
Assert.AreEqual(result['A'], 1);
Assert.AreEqual(result['B'], 1);
}
public static void Main(string[] args)
{
string phrase;
if (args.Length == 0)
{
Console.WriteLine("Enter a phrase");
phrase = Console.ReadLine();
}
else
{
if (!File.Exists(args[0]))
{
Console.WriteLine("Enter a valid file name");
return;
}
phrase = File.ReadAllText(args[0]);
}
CharacterCounter counter = new CharacterCounter();
counter.ParseString(phrase);
foreach (var letter in Alphabet)
{
Console.WriteLine("{0} : {1}", letter, counter.GetCountForLetter(letter));
}
}
public void return_a_count_of_1_if_there_is_a_single_letter_to_parse()
{
CharacterCounter counter = new CharacterCounter();
counter.ParseString("a");
Assert.Equal(1, counter.GetCountForLetter('a'));
}
public void Should_return_a_count_of_1_if_there_is_a_single_letter_to_parse()
{
CharacterCounter counter = new CharacterCounter();
counter.ParseString("a");
Assert.Equal(1, counter.GetCountForLetter('a'));
counter.GetCountForLetter('a').Should().Be(1);//FluentAssertions
}
public void ShouldAcceptAString()
{
ICharacterCounter characterCounter = new CharacterCounter(forbiddenCharacters, false);
characterCounter.Add("abc");
int expectedResult = 3;
Assert.AreEqual(expectedResult, characterCounter.GetTotalNumberOfCharacters());
}
public void CountUniqueCharacters_Test()
{
string testString = "TEST_string";
int numberOfUniqueCharacters = 10;
var result = CharacterCounter.CountUniqueCharacters(testString);
Assert.Equal(numberOfUniqueCharacters, result);
}
public void ShouldAcknowledgeCaseWhenAddingAString()
{
ICharacterCounter characterCounter = new CharacterCounter(forbiddenCharacters, true);
characterCounter.Add("AAA aaa");
int expectedResult = 3;
Assert.AreEqual(expectedResult, characterCounter.GetCharacterCount('a'));
}
public void GenericTests()
{
Assert.AreEqual(true, CharacterCounter.ValidateWord("abcabc"), "The word was: \"abcabc\"");
Assert.AreEqual(true, CharacterCounter.ValidateWord("Abcabc"), "The word was: \"Abcabc\"");
Assert.AreEqual(true, CharacterCounter.ValidateWord("abc123"), "The word was: \"abc123\"");
Assert.AreEqual(false, CharacterCounter.ValidateWord("abcabcd"), "The word was: \"abcabcd\"");
Assert.AreEqual(true, CharacterCounter.ValidateWord("abc!abc!"), "The word was: \"abc!abc!\"");
Assert.AreEqual(false, CharacterCounter.ValidateWord("abc:abc"), "The word was: \"abc:abc\"");
}
static void Main(string[] args)
{
var repo = new CandidateRepo();
var characterCounter = new CharacterCounter(repo);
var result = characterCounter.Count();
var x = 1;
}
public void ShouldIgnoreCaseWhenAddingCharacters()
{
ICharacterCounter characterCounter = new CharacterCounter(forbiddenCharacters, false);
characterCounter.Add('a');
characterCounter.Add('A');
characterCounter.Add('a');
int expectedResult = 3;
Assert.AreEqual(expectedResult, characterCounter.GetCharacterCount('a'));
}
public void ShouldIgnoreForbiddenCharactersWhenAddingCharacters()
{
ICharacterCounter characterCounter = new CharacterCounter(forbiddenCharacters, false);
characterCounter.Add('a');
characterCounter.Add('b');
characterCounter.Add('c');
characterCounter.Add('\t');
characterCounter.Add(' ');
int expectedResult = 3;
Assert.AreEqual(expectedResult, characterCounter.GetTotalNumberOfCharacters());
}
public string TryDecryptFile(string location)
{
string[] lines = File.ReadAllLines(location);
foreach (string line in lines)
{
var decrypted = this.TryDecrypt(new Hex(line));
char c = CharacterCounter.FindKey(decrypted);
if (c != '\0')
{
return(decrypted[c]);
}
}
return(String.Empty);
}
public Dictionary <char, string> TryDecrypt(Hex source)
{
var result = new Dictionary <char, string>();
foreach (char c in CharacterCounter.GetAlphabet())
{
string s = new string(c, source.Length);
string decrypted = xorCipher.Decrypt(source, s);
result.Add(c, decrypted);
}
return(result);
}
public void When_the_name_only_has_one_word_Then_an_exception_will_be_stored()
{
var testData = new List <string> {
Guid.NewGuid().ToString()
};
var repo = new TestRepository(testData, null);
var sut = new CharacterCounter(repo);
var result = sut.Count();
Assert.That(result.Exceptions.Count, Is.EqualTo(1));
}
public int Calculate(string input)
{
var lines = input.Split("|");
int twos = 0, threes = 0;
foreach (var line in lines)
{
var counts = new CharacterCounter().CountCharacters(line);
twos += counts.twoCount;
threes += counts.threeCount;
}
return(twos * threes);
}
public ActionResult CharacterCount(CharacterCountTool countTool)
{
if (ModelState.IsValid)
{
var charCounter = new CharacterCounter();
var counts = new CharacterCounts();
counts = charCounter.CountCharacters(countTool.TextInput);
countTool.Consonants = counts.Consonants;
countTool.ConsonantList = counts.ConsonantList;
countTool.Vowels = counts.Vowels;
countTool.VowelList = counts.VowelList;
countTool.Ys = counts.Ys;
countTool.Spaces = counts.Spaces;
countTool.TotalCharacters = counts.TotalCharacters;
countTool.Punctuation = counts.Punctuation;
countTool.NonLetters = counts.NonLetters;
return(View("CharacterCount", countTool));
}
return(View("CharacterCount"));
}
/// NOTE: don't use [SetUp] attribute with virtual.
public override void SetUp()
{
_all = new CharacterCounter(10);
_counter = new CharacterFrequencyCounter(_all);
}
public void Count_Empty_ReturnNotCountingMessage()
{
string result = CharacterCounter.Count("");
Assert.That(result, Is.EqualTo("No word."));
}
public void Count_Word_ReturnWordAndCountMessage(string word, string expected)
{
string result = CharacterCounter.Count(word);
Assert.That(result, Is.EqualTo(expected));
}
private Dictionary <char, int> CounterCharacters()
{
CharacterCounter characterCounter = new CharacterCounter(Input);
return(characterCounter.Assess());
}
public void Should_Return_Encoded_Minus_Code_Length(string data, int expected)
{
var result = CharacterCounter.GetCharactersEncode(data);
Assert.Equal(expected, result);
}
public char TryDecryptAndFindKey(Hex source)
{
return(CharacterCounter.FindKey(this.TryDecrypt(source)));
}
public string[] BreakXorFile(Base64 data, int startKeySize = 2, int endKeySize = 60, int numberOfBlocks = 2)
{
int take = 10;
Hex source = data;
var possibleKeySizes = HammingDistance.FindDistancePerKeySize(startKeySize, endKeySize, source.ToString(), numberOfBlocks).OrderBy(x => x.Value).Select(x => x.Key).Take(take);
foreach (var possibleKeySize in possibleKeySizes)
{
StringBuilder sb = new StringBuilder();
var transposedBlocks = source.CreateAndTransposeBlocks(possibleKeySize);
var decryptedBlocks = new List <string>();
bool foundOne = false;
foreach (var block in transposedBlocks)
{
var decrypted = this.TryDecrypt(block);
var c = CharacterCounter.FindKey(decrypted);
if (c == '\0')
{
if (foundOne)
{
sb.Append('?');
decryptedBlocks.Add(decrypted['A']);
}
else
{
break;
}
}
else
{
foundOne = true;
sb.Append(c);
decryptedBlocks.Add(decrypted[c]);
}
}
string key = sb.ToString();
if (key.Length > 0)
{
StringBuilder decrypted = new StringBuilder();
for (int i = 0; i < decryptedBlocks[0].Length; i++)
{
foreach (string block in decryptedBlocks)
{
if (i < block.Length)
{
decrypted.Append(block[i]);
}
}
}
return(new string[] { key, decrypted.ToString() });
}
}
return(new string[] { "", "" });
}
public void ShouldIgnoreForbiddenCharactersWhenAddingAString()
{
ICharacterCounter characterCounter = new CharacterCounter(forbiddenCharacters, false);
characterCounter.Add("Aa \n Bb \t Cc \r");
int expectedResult = 6;
Assert.AreEqual(expectedResult, characterCounter.GetTotalNumberOfCharacters());
}
