Exemplo n.º 1
0
    def test_is_value_of_type(self):
        """Test is_value_of_type function."""
        self.assertTrue(is_value_of_type({'one': 1}, dict))
        self.assertTrue(is_value_of_type(1, int))
        self.assertTrue(is_value_of_type("foo", str))
        self.assertTrue(is_value_of_type(['a', 'b'], list))
        self.assertTrue(is_value_of_type(('a', 'b'), tuple))

        self.assertFalse(is_value_of_type({'one': 1}, list))
        self.assertFalse(is_value_of_type(1, str))
        self.assertFalse(is_value_of_type("foo", int))

        # toolchain type check
        self.assertTrue(
            is_value_of_type({
                'name': 'intel',
                'version': '2015a'
            }, TOOLCHAIN_DICT))
        # version value should be string, not int
        self.assertFalse(
            is_value_of_type({
                'name': 'intel',
                'version': 100
            }, TOOLCHAIN_DICT))
        # missing version key
        self.assertFalse(
            is_value_of_type({
                'name': 'intel',
                'foo': 'bar'
            }, TOOLCHAIN_DICT))
        # extra key, shouldn't be there
        self.assertFalse(
            is_value_of_type(
                {
                    'name': 'intel',
                    'version': '2015a',
                    'foo': 'bar'
                }, TOOLCHAIN_DICT))

        # dependency type check
        self.assertTrue(
            is_value_of_type({
                'name': 'intel',
                'version': '2015a'
            }, DEPENDENCY_DICT))
        self.assertTrue(
            is_value_of_type(
                {
                    'name': 'intel',
                    'version': '2015a',
                    'toolchain': {
                        'name': 'intel',
                        'version': '2015a'
                    },
                    'versionsuffix': 'foo',
                }, DEPENDENCY_DICT))
        # no version key
        self.assertFalse(is_value_of_type({'name': 'intel'}, TOOLCHAIN_DICT))
        # too many keys
        self.assertFalse(
            is_value_of_type(
                {
                    'name': 'intel',
                    'version': '2015a',
                    'toolchain': 'intel, 2015a',
                    'versionsuffix': 'foo',
                    'extra': 'bar',
                }, DEPENDENCY_DICT))

        # list of dependencies type check
        dependencies = [
            {
                'name': 'intel',
                'version': '2015a'
            },
            {
                'name': 'gcc',
                'version': '4.1.3'
            },
            {
                'name': 'dummy',
                'version': 'dummy',
                'versionsuffix': 'foo',
                'toolchain': {
                    'name': 'intel',
                    'version': '2015a'
                }
            },
        ]
        self.assertTrue(is_value_of_type(dependencies, DEPENDENCIES))

        # string value for toolchain key is not OK
        dependencies.append({
            'name': 'foo',
            'version': '1.2.3',
            'toolchain': 'intel, 2015a'
        })
        self.assertFalse(is_value_of_type(dependencies, DEPENDENCIES))

        # wrong keys (name/version is strictly required)
        self.assertFalse(is_value_of_type([{
            'a': 'b',
            'c': 'd'
        }], DEPENDENCIES))

        # not a list
        self.assertFalse(
            is_value_of_type({
                'name': 'intel',
                'version': '2015a'
            }, DEPENDENCIES))

        # no extra keys allowed, only name/version/versionsuffix/toolchain
        self.assertFalse(
            is_value_of_type(
                {
                    'name': 'intel',
                    'version': '2015a',
                    'foo': 'bar'
                }, DEPENDENCIES))

        # list of strings and tuples test
        self.assertTrue(
            is_value_of_type(['foo', ('bar', 'bat')], STRING_OR_TUPLE_LIST))
        self.assertTrue(is_value_of_type(['foo', 'bar'], STRING_OR_TUPLE_LIST))
        self.assertTrue(
            is_value_of_type([('foo', 'fob'), ('bar', 'bat')],
                             STRING_OR_TUPLE_LIST))
        self.assertTrue(is_value_of_type([], STRING_OR_TUPLE_LIST))

        # list element, not allowed (should be tuple or string)
        self.assertFalse(
            is_value_of_type(['foo', ['bar', 'bat']], STRING_OR_TUPLE_LIST))
        # int element, not allowed (should be tuple or string)
        self.assertFalse(is_value_of_type(['foo', 1], STRING_OR_TUPLE_LIST))

        # sanity_check_paths test
        self.assertTrue(
            is_value_of_type(
                {
                    'files': ['one', 'two'],
                    'dirs': ['dirA', 'dirB']
                }, SANITY_CHECK_PATHS_DICT))
        self.assertTrue(
            is_value_of_type({
                'files': ['f1', ('f2a', 'f2b')],
                'dirs': []
            }, SANITY_CHECK_PATHS_DICT))
        self.assertTrue(
            is_value_of_type({
                'files': [],
                'dirs': []
            }, SANITY_CHECK_PATHS_DICT))

        # list element for 'files', should be string or tuple
        self.assertFalse(
            is_value_of_type({
                'files': ['f1', ['f2a', 'f2b']],
                'dirs': []
            }, SANITY_CHECK_PATHS_DICT))
        # missing 'dirs' key
        self.assertFalse(
            is_value_of_type({'files': ['f1', 'f2']}, SANITY_CHECK_PATHS_DICT))
        # tuple rather than list
        self.assertFalse(
            is_value_of_type({
                'files': (1, 2),
                'dirs': []
            }, SANITY_CHECK_PATHS_DICT))
        # int elements rather than strings/tuples-of-strings
        self.assertFalse(
            is_value_of_type({
                'files': [1, 2],
                'dirs': []
            }, SANITY_CHECK_PATHS_DICT))
        # one int element is not allowed either
        self.assertFalse(
            is_value_of_type({
                'files': ['foo', 2],
                'dirs': []
            }, SANITY_CHECK_PATHS_DICT))
        # extra key is not allowed
        self.assertFalse(
            is_value_of_type({
                'files': [],
                'dirs': [],
                'foo': []
            }, SANITY_CHECK_PATHS_DICT))
        # no keys at all
        self.assertFalse(is_value_of_type({}, SANITY_CHECK_PATHS_DICT))
    def test_is_value_of_type(self):
        """Test is_value_of_type function."""
        self.assertTrue(is_value_of_type({'one': 1}, dict))
        self.assertTrue(is_value_of_type(1, int))
        self.assertTrue(is_value_of_type("foo", str))
        self.assertTrue(is_value_of_type(['a', 'b'], list))
        self.assertTrue(is_value_of_type(('a', 'b'), tuple))

        self.assertFalse(is_value_of_type({'one': 1}, list))
        self.assertFalse(is_value_of_type(1, str))
        self.assertFalse(is_value_of_type("foo", int))

        # toolchain type check
        self.assertTrue(
            is_value_of_type({
                'name': 'intel',
                'version': '2015a'
            }, NAME_VERSION_DICT))
        # version value should be string, not int
        self.assertFalse(
            is_value_of_type({
                'name': 'intel',
                'version': 100
            }, NAME_VERSION_DICT))
        # missing version key
        self.assertFalse(
            is_value_of_type({
                'name': 'intel',
                'foo': 'bar'
            }, NAME_VERSION_DICT))
        # extra key, shouldn't be there
        self.assertFalse(
            is_value_of_type(
                {
                    'name': 'intel',
                    'version': '2015a',
                    'foo': 'bar'
                }, NAME_VERSION_DICT))

        # dependency type check
        self.assertTrue(
            is_value_of_type({
                'name': 'intel',
                'version': '2015a'
            }, DEPENDENCY_DICT))
        self.assertTrue(
            is_value_of_type(
                {
                    'name': 'intel',
                    'version': '2015a',
                    'toolchain': {
                        'name': 'intel',
                        'version': '2015a'
                    },
                    'versionsuffix': 'foo',
                }, DEPENDENCY_DICT))
        # no version key
        self.assertFalse(is_value_of_type({'name': 'intel'},
                                          NAME_VERSION_DICT))
        # too many keys
        self.assertFalse(
            is_value_of_type(
                {
                    'name': 'intel',
                    'version': '2015a',
                    'toolchain': 'intel, 2015a',
                    'versionsuffix': 'foo',
                    'extra': 'bar',
                }, DEPENDENCY_DICT))

        # list of dependencies type check
        dependencies = [
            {
                'name': 'intel',
                'version': '2015a'
            },
            {
                'name': 'gcc',
                'version': '4.1.3'
            },
            {
                'name': 'dummy',
                'version': 'dummy',
                'versionsuffix': 'foo',
                'toolchain': {
                    'name': 'intel',
                    'version': '2015a'
                }
            },
        ]
        self.assertTrue(is_value_of_type(dependencies, DEPENDENCIES))

        # string value for toolchain key is not OK
        dependencies.append({
            'name': 'foo',
            'version': '1.2.3',
            'toolchain': 'intel, 2015a'
        })
        self.assertFalse(is_value_of_type(dependencies, DEPENDENCIES))

        # wrong keys (name/version is strictly required)
        self.assertFalse(is_value_of_type([{
            'a': 'b',
            'c': 'd'
        }], DEPENDENCIES))

        # not a list
        self.assertFalse(
            is_value_of_type({
                'name': 'intel',
                'version': '2015a'
            }, DEPENDENCIES))

        # no extra keys allowed, only name/version/versionsuffix/toolchain
        self.assertFalse(
            is_value_of_type(
                {
                    'name': 'intel',
                    'version': '2015a',
                    'foo': 'bar'
                }, DEPENDENCIES))
Exemplo n.º 3
0
    def test_is_value_of_type(self):
        """Test is_value_of_type function."""
        self.assertTrue(is_value_of_type({'one': 1}, dict))
        self.assertTrue(is_value_of_type(1, int))
        self.assertTrue(is_value_of_type("foo", str))
        self.assertTrue(is_value_of_type(['a', 'b'], list))
        self.assertTrue(is_value_of_type(('a', 'b'), tuple))

        self.assertFalse(is_value_of_type({'one': 1}, list))
        self.assertFalse(is_value_of_type(1, str))
        self.assertFalse(is_value_of_type("foo", int))

        # toolchain type check
        self.assertTrue(is_value_of_type({'name': 'intel', 'version': '2015a'}, NAME_VERSION_DICT))
        # version value should be string, not int
        self.assertFalse(is_value_of_type({'name': 'intel', 'version': 100}, NAME_VERSION_DICT))
        # missing version key
        self.assertFalse(is_value_of_type({'name': 'intel', 'foo': 'bar'}, NAME_VERSION_DICT))
        # extra key, shouldn't be there
        self.assertFalse(is_value_of_type({'name': 'intel', 'version': '2015a', 'foo': 'bar'}, NAME_VERSION_DICT))

        # dependency type check
        self.assertTrue(is_value_of_type({'name': 'intel', 'version': '2015a'}, DEPENDENCY_DICT))
        self.assertTrue(is_value_of_type({
            'name': 'intel',
            'version': '2015a',
            'toolchain': {'name': 'intel', 'version': '2015a'},
            'versionsuffix': 'foo',
        }, DEPENDENCY_DICT))
        # no version key
        self.assertFalse(is_value_of_type({'name': 'intel'}, NAME_VERSION_DICT))
        # too many keys
        self.assertFalse(is_value_of_type({
            'name': 'intel',
            'version': '2015a',
            'toolchain': 'intel, 2015a',
            'versionsuffix': 'foo',
            'extra': 'bar',
        }, DEPENDENCY_DICT))

        # list of dependencies type check
        dependencies = [
            {'name': 'intel', 'version': '2015a'},
            {'name': 'gcc', 'version': '4.1.3'},
            {'name': 'dummy', 'version': 'dummy', 'versionsuffix': 'foo',
             'toolchain': {'name': 'intel', 'version': '2015a'}},
        ]
        self.assertTrue(is_value_of_type(dependencies, DEPENDENCIES))

        # string value for toolchain key is not OK
        dependencies.append({'name': 'foo', 'version': '1.2.3', 'toolchain': 'intel, 2015a'})
        self.assertFalse(is_value_of_type(dependencies, DEPENDENCIES))

        # wrong keys (name/version is strictly required)
        self.assertFalse(is_value_of_type([{'a':'b', 'c':'d'}], DEPENDENCIES))

        # not a list
        self.assertFalse(is_value_of_type({'name': 'intel', 'version': '2015a'}, DEPENDENCIES))

        # no extra keys allowed, only name/version/versionsuffix/toolchain
        self.assertFalse(is_value_of_type({'name': 'intel', 'version': '2015a', 'foo': 'bar'}, DEPENDENCIES))
Exemplo n.º 4
0
    def test_is_value_of_type(self):
        """Test is_value_of_type function."""
        self.assertTrue(is_value_of_type({'one': 1}, dict))
        self.assertTrue(is_value_of_type(1, int))
        self.assertTrue(is_value_of_type("foo", str))
        self.assertTrue(is_value_of_type(['a', 'b'], list))
        self.assertTrue(is_value_of_type(('a', 'b'), tuple))

        self.assertFalse(is_value_of_type({'one': 1}, list))
        self.assertFalse(is_value_of_type(1, str))
        self.assertFalse(is_value_of_type("foo", int))

        # toolchain type check
        self.assertTrue(is_value_of_type({'name': 'intel', 'version': '2015a'}, NAME_VERSION_DICT))
        # version value should be string, not int
        self.assertFalse(is_value_of_type({'name': 'intel', 'version': 100}, NAME_VERSION_DICT))
        # missing version key
        self.assertFalse(is_value_of_type({'name': 'intel', 'foo': 'bar'}, NAME_VERSION_DICT))
        # extra key, shouldn't be there
        self.assertFalse(is_value_of_type({'name': 'intel', 'version': '2015a', 'foo': 'bar'}, NAME_VERSION_DICT))

        # dependency type check
        self.assertTrue(is_value_of_type({'name': 'intel', 'version': '2015a'}, DEPENDENCY_DICT))
        self.assertTrue(is_value_of_type({
            'name': 'intel',
            'version': '2015a',
            'toolchain': {'name': 'intel', 'version': '2015a'},
            'versionsuffix': 'foo',
        }, DEPENDENCY_DICT))
        # no version key
        self.assertFalse(is_value_of_type({'name': 'intel'}, NAME_VERSION_DICT))
        # too many keys
        self.assertFalse(is_value_of_type({
            'name': 'intel',
            'version': '2015a',
            'toolchain': 'intel, 2015a',
            'versionsuffix': 'foo',
            'extra': 'bar',
        }, DEPENDENCY_DICT))

        # list of dependencies type check
        dependencies = [
            {'name': 'intel', 'version': '2015a'},
            {'name': 'gcc', 'version': '4.1.3'},
            {'name': 'dummy', 'version': 'dummy', 'versionsuffix': 'foo',
             'toolchain': {'name': 'intel', 'version': '2015a'}},
        ]
        self.assertTrue(is_value_of_type(dependencies, DEPENDENCIES))

        # string value for toolchain key is not OK
        dependencies.append({'name': 'foo', 'version': '1.2.3', 'toolchain': 'intel, 2015a'})
        self.assertFalse(is_value_of_type(dependencies, DEPENDENCIES))

        # wrong keys (name/version is strictly required)
        self.assertFalse(is_value_of_type([{'a':'b', 'c':'d'}], DEPENDENCIES))

        # not a list
        self.assertFalse(is_value_of_type({'name': 'intel', 'version': '2015a'}, DEPENDENCIES))

        # no extra keys allowed, only name/version/versionsuffix/toolchain
        self.assertFalse(is_value_of_type({'name': 'intel', 'version': '2015a', 'foo': 'bar'}, DEPENDENCIES))

        # list of strings and tuples test
        self.assertTrue(is_value_of_type(['foo', ('bar', 'bat')], STRING_OR_TUPLE_LIST))
        self.assertTrue(is_value_of_type(['foo', 'bar'], STRING_OR_TUPLE_LIST))
        self.assertTrue(is_value_of_type([('foo', 'fob'), ('bar', 'bat')], STRING_OR_TUPLE_LIST))
        self.assertTrue(is_value_of_type([], STRING_OR_TUPLE_LIST))

        # list element, not allowed (should be tuple or string)
        self.assertFalse(is_value_of_type(['foo', ['bar', 'bat']], STRING_OR_TUPLE_LIST))
        # int element, not allowed (should be tuple or string)
        self.assertFalse(is_value_of_type(['foo', 1], STRING_OR_TUPLE_LIST))

        # sanity_check_paths test
        self.assertTrue(is_value_of_type({'files': ['one', 'two'], 'dirs': ['dirA', 'dirB']}, SANITY_CHECK_PATHS_DICT))
        self.assertTrue(is_value_of_type({'files': ['f1', ('f2a', 'f2b')], 'dirs': []}, SANITY_CHECK_PATHS_DICT))
        self.assertTrue(is_value_of_type({'files': [], 'dirs': []}, SANITY_CHECK_PATHS_DICT))

        # list element for 'files', should be string or tuple
        self.assertFalse(is_value_of_type({'files': ['f1', ['f2a', 'f2b']], 'dirs': []}, SANITY_CHECK_PATHS_DICT))
        # missing 'dirs' key
        self.assertFalse(is_value_of_type({'files': ['f1', 'f2']}, SANITY_CHECK_PATHS_DICT))
        # tuple rather than list
        self.assertFalse(is_value_of_type({'files': (1, 2), 'dirs': []}, SANITY_CHECK_PATHS_DICT))
        # int elements rather than strings/tuples-of-strings
        self.assertFalse(is_value_of_type({'files': [1, 2], 'dirs': []}, SANITY_CHECK_PATHS_DICT))
        # one int element is not allowed either
        self.assertFalse(is_value_of_type({'files': ['foo', 2], 'dirs': []}, SANITY_CHECK_PATHS_DICT))
        # extra key is not allowed
        self.assertFalse(is_value_of_type({'files': [], 'dirs': [], 'foo': []}, SANITY_CHECK_PATHS_DICT))
        # no keys at all
        self.assertFalse(is_value_of_type({}, SANITY_CHECK_PATHS_DICT))