IsEqualIgnoringCaseTest

Complexity

Total Complexity

11

Size/Duplication

Total Lines	42
Duplicated Lines	100 %

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	testMismatchDescription()	2	2	1
A	testFailsIfAdditionalWhitespaceIsPresent()	3	3	1
A	testCanApplyUnicodeStringToUnicodeMatcher()	3	3	1
A	testDescribeMismatch()	2	2	1
A	testCanApplyUnicodeStringToPlainMatcher()	3	3	1
A	testFailsIfMatchingAgainstNonString()	2	2	1
A	testSuccessfulMatchDoesNotGenerateMismatchDescription()	2	2	1
A	testCanApplyPlainStringToUnicodeMatcher()	3	3	1
A	testIgnoresCaseOfCharsInString()	6	6	1
A	testHasAReadableDescription()	2	2	1
A	testMatcherCreationRequiresString()	2	2	1

import six
from hamcrest.library.text.isequal_ignoring_case import equal_to_ignoring_case

from hamcrest_unit_test.matcher_test import MatcherTest
import unittest

__author__ = "Jon Reid"
__copyright__ = "Copyright 2011 hamcrest.org"
__license__ = "BSD, see License.txt"


matcher = equal_to_ignoring_case('heLLo')

class IsEqualIgnoringCaseTest(MatcherTest):

This code seems to be duplicated in your project.

    def testIgnoresCaseOfCharsInString(self):
        self.assert_matches('all upper', matcher, 'HELLO')
        self.assert_matches('all lower', matcher, 'hello')
        self.assert_matches('mixed up', matcher, 'HelLo')

        self.assert_does_not_match('no match', matcher, 'bye')

    def testFailsIfAdditionalWhitespaceIsPresent(self):
        self.assert_does_not_match('whitespace suffix', matcher, 'heLLo ')
        self.assert_does_not_match('whitespace prefix', matcher, ' heLLo')

    def testMatcherCreationRequiresString(self):
        self.assertRaises(TypeError, equal_to_ignoring_case, 3)

    def testFailsIfMatchingAgainstNonString(self):
        self.assert_does_not_match('non-string', matcher, object())

    def testCanApplyUnicodeStringToUnicodeMatcher(self):
        self.assert_matches('unicode-unicode',
                            equal_to_ignoring_case(six.u('heLLo')), six.u('HelLo'))

    def testCanApplyPlainStringToUnicodeMatcher(self):
        self.assert_matches('unicode-ascii',
                            equal_to_ignoring_case(six.u('heLLo')), 'HelLo')

    def testCanApplyUnicodeStringToPlainMatcher(self):
        self.assert_matches('ascii-unicode',
                            equal_to_ignoring_case('heLLo'), six.u('HelLo'))

    def testHasAReadableDescription(self):
        self.assert_description("'heLLo' ignoring case", matcher)

    def testSuccessfulMatchDoesNotGenerateMismatchDescription(self):
        self.assert_no_mismatch_description(matcher, 'hello')

    def testMismatchDescription(self):
        self.assert_mismatch_description("was 'bad'", matcher, 'bad')

    def testDescribeMismatch(self):
        self.assert_describe_mismatch("was 'bad'", matcher, 'bad')


if __name__ == '__main__':
    unittest.main()