コード例 #1
0
                public void ShouldNeverBecomeNegative(string sentence, int startPointDurability)
                {
                    const int expectedPointDurability = 0;
                    IPencil   pencil = GetPencil(pointDurability: startPointDurability);

                    pencil.Write(GetPaper(), sentence);

                    Assert.Equal(expectedPointDurability, pencil.CurrentPointDurability);
                }
コード例 #2
0
                public void ShouldDegradeCorrectlyForManyLowercaseLetters(string lowercaseLetters)
                {
                    const int startPointDurability    = 20;
                    int       expectedPointDurability = startPointDurability - lowercaseLetters.Length;
                    IPencil   pencil = GetPencil(pointDurability: startPointDurability);

                    pencil.Write(GetPaper(), lowercaseLetters);

                    Assert.Equal(expectedPointDurability, pencil.CurrentPointDurability);
                }
コード例 #3
0
                public void ShouldDegradCorrectlyforManyRandomCharacters(string miscCharacters)
                {
                    const int startPointDurability    = 20;
                    int       expectedPointDurability = startPointDurability - miscCharacters.Length;
                    IPencil   pencil = GetPencil(pointDurability: startPointDurability);

                    pencil.Write(GetPaper(), miscCharacters);

                    Assert.Equal(expectedPointDurability, pencil.CurrentPointDurability);
                }
コード例 #4
0
                public void ShouldDegradeCorrectlyForMixedCaseAndWhitespace(string mixedString, int degradeAmount)
                {
                    const int startPointDurability    = 40;
                    int       expectedPointDurability = startPointDurability - degradeAmount;
                    IPencil   pencil = GetPencil(pointDurability: startPointDurability);

                    pencil.Write(GetPaper(), mixedString);

                    Assert.Equal(expectedPointDurability, pencil.CurrentPointDurability);
                }
コード例 #5
0
                public void ShouldAddTextToPaper()
                {
                    const string testSentence = "This is a sentence";
                    IPencil      pencil       = GetPencil();
                    IPaper       paper        = GetPaper();

                    pencil.Write(paper, testSentence);

                    Assert.Equal(testSentence, paper.Text);
                }
コード例 #6
0
                public void ShouldDegradeByTwoWhenWritingInUppercase()
                {
                    const string uppercaseLetter         = "A";
                    const int    startPointDurability    = 5;
                    const int    expectedPointDurability = 3;
                    IPencil      pencil = GetPencil(pointDurability: startPointDurability);

                    pencil.Write(GetPaper(), uppercaseLetter);

                    Assert.Equal(expectedPointDurability, pencil.CurrentPointDurability);
                }
コード例 #7
0
                public void ShouldDegradeCorrectlyForManyUppercaseLetters(string uppercaseLetters)
                {
                    const int uppercaseDegradeValue   = 2;
                    const int startPointDurability    = 40;
                    int       expectedPointDurability = startPointDurability - (uppercaseLetters.Length * uppercaseDegradeValue);
                    IPencil   pencil = GetPencil(pointDurability: startPointDurability);

                    pencil.Write(GetPaper(), uppercaseLetters);

                    Assert.Equal(expectedPointDurability, pencil.CurrentPointDurability);
                }
コード例 #8
0
                public void ShouldWriteWhitespaceCharacters()
                {
                    const string testWhitespace  = "  \t\r\n\f\v  ";
                    const int    pointDurability = 0;
                    IPencil      pencil          = GetPencil(pointDurability: pointDurability);
                    IPaper       paper           = GetPaper();

                    pencil.Write(paper, testWhitespace);

                    Assert.Equal(testWhitespace, paper.Text);
                }
コード例 #9
0
                public void ShouldDefaultDegradingByOneIfNotWhitespaceOrUppercase()
                {
                    const string otherCharecter          = "?";
                    const int    startPointDurability    = 5;
                    const int    expectedPointDurability = 4;
                    IPencil      pencil = GetPencil(pointDurability: startPointDurability);

                    pencil.Write(GetPaper(), otherCharecter);

                    Assert.Equal(expectedPointDurability, pencil.CurrentPointDurability);
                }
コード例 #10
0
            public void ShouldResetDurabilityToOriginalValue()
            {
                const string testSentence    = "Text to waste pencil durability for testing sharpening abilities";
                const int    pointDurability = 100;
                IPencil      pencil          = GetPencil(pointDurability: pointDurability);

                pencil.Write(GetPaper(), testSentence);
                pencil.Sharpen();

                Assert.Equal(pointDurability, pencil.CurrentPointDurability);
            }
コード例 #11
0
                public void ShouldWriteCorrectNumberOfSpaces()
                {
                    const string testSentence    = "This should not be written.";
                    const string expectedString  = "                           ";
                    const int    pointDurability = 0;
                    IPencil      pencil          = GetPencil(pointDurability: pointDurability);
                    IPaper       paper           = GetPaper();

                    pencil.Write(paper, testSentence);

                    Assert.Equal(expectedString, paper.Text);
                }
コード例 #12
0
                public void ShouldAppendToExistingText()
                {
                    const string paperText    = "This is a sentence";
                    const string testSentence = " This is another sentence";
                    const string expectedText = paperText + testSentence;
                    IPencil      pencil       = GetPencil();
                    IPaper       paper        = GetPaper(paperText);

                    pencil.Write(paper, testSentence);

                    Assert.Equal(expectedText, paper.Text);
                }
コード例 #13
0
                public void ShouldWritePartOfTheSentenceWithoutEnoughDurability()
                {
                    const string testSentence     = "This should not be written and This should not be written";
                    const string expectedSentence = "This should not be written and                           ";
                    const int    pointDurability  = 26;
                    IPencil      pencil           = GetPencil(pointDurability: pointDurability);
                    IPaper       paper            = GetPaper();

                    pencil.Write(paper, testSentence);

                    Assert.Equal(expectedSentence, paper.Text);
                }
コード例 #14
0
                public void ShouldNotWriteUppercaseIfNotEnoughDurability()
                {
                    const string testString      = "aTat";
                    const string expectedText    = "a a ";
                    const int    pointDurability = 2;
                    IPencil      pencil          = GetPencil(pointDurability: pointDurability);
                    IPaper       paper           = GetPaper();

                    pencil.Write(paper, testString);

                    Assert.Equal(expectedText, paper.Text);
                }
コード例 #15
0
                public void ShouldKeepWhitespaceInMiddleOfText()
                {
                    const string testSentence    = "\vT\this is a\t sentence\n with whi\r\ntespace chara\ncters.\f";
                    const string expectedText    = "\v \t        \t         \n         \r\n             \n      \f";
                    const int    pointDurability = 0;
                    IPencil      pencil          = GetPencil(pointDurability: pointDurability);
                    IPaper       paper           = GetPaper();

                    pencil.Write(paper, testSentence);

                    Assert.Equal(expectedText, paper.Text);
                }
コード例 #16
0
                public void ShouldAppendSpacesToText()
                {
                    const string paperText       = "This already exists.";
                    const string testSentence    = " This should not be written.";
                    const string expectedText    = "This already exists.                            ";
                    const int    pointDurability = 0;
                    IPencil      pencil          = GetPencil(pointDurability: pointDurability);
                    IPaper       paper           = GetPaper(paperText);

                    pencil.Write(paper, testSentence);

                    Assert.Equal(expectedText, paper.Text);
                }
コード例 #17
0
            public void ShouldNotResetDurabilityWhenZeroLength()
            {
                const string testSentence            = "Keep it simple";
                const int    length                  = 0;
                const int    startPointDurability    = 100;
                const int    expectedPointDurability = 87;
                IPencil      pencil                  = GetPencil(pointDurability: startPointDurability, length: length);

                pencil.Write(GetPaper(), testSentence);
                pencil.Sharpen();

                Assert.Equal(expectedPointDurability, pencil.CurrentPointDurability);
            }