# SPDX-License-Identifier: Apache-2.0
#
# Copyright 2015 ClusterHQ
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

"""
Tests for _nvlist module.
The tests convert from a `dict` to C ``nvlist_t`` and back to a `dict`
and verify that no information is lost and value types are correct.
The tests also check that various error conditions like unsupported
value types or out of bounds values are detected.
"""
from __future__ import absolute_import, division, print_function

import unittest

from .._nvlist import nvlist_in, nvlist_out, _lib
from ..ctypes import (
    uint8_t, int8_t, uint16_t, int16_t, uint32_t, int32_t,
    uint64_t, int64_t, boolean_t, uchar_t
)


class TestNVList(unittest.TestCase):

    def _dict_to_nvlist_to_dict(self, props):
        res = {}
        nv_in = nvlist_in(props)
        with nvlist_out(res) as nv_out:
            _lib.nvlist_dup(nv_in, nv_out, 0)
        return res

    def _assertIntDictsEqual(self, dict1, dict2):
        self.assertEqual(
            len(dict1), len(dict1),
            b"resulting dictionary is of different size")
        for key in dict1.keys():
            self.assertEqual(int(dict1[key]), int(dict2[key]))

    def _assertIntArrayDictsEqual(self, dict1, dict2):
        self.assertEqual(
            len(dict1), len(dict1),
            b"resulting dictionary is of different size")
        for key in dict1.keys():
            val1 = dict1[key]
            val2 = dict2[key]
            self.assertEqual(
                len(val1), len(val2), b"array values of different sizes")
            for x, y in zip(val1, val2):
                self.assertEqual(int(x), int(y))

    def test_empty(self):
        res = self._dict_to_nvlist_to_dict({})
        self.assertEqual(len(res), 0, b"expected empty dict")

    def test_invalid_key_type(self):
        with self.assertRaises(TypeError):
            self._dict_to_nvlist_to_dict({1: None})

    def test_invalid_val_type__tuple(self):
        with self.assertRaises(TypeError):
            self._dict_to_nvlist_to_dict({b"key": (1, 2)})

    def test_invalid_val_type__set(self):
        with self.assertRaises(TypeError):
            self._dict_to_nvlist_to_dict({b"key": set(1, 2)})

    def test_invalid_array_val_type(self):
        with self.assertRaises(TypeError):
            self._dict_to_nvlist_to_dict({b"key": [(1, 2), (3, 4)]})

    def test_invalid_array_of_arrays_val_type(self):
        with self.assertRaises(TypeError):
            self._dict_to_nvlist_to_dict({b"key": [[1, 2], [3, 4]]})

    def test_string_value(self):
        props = {b"key": b"value"}
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)

    def test_implicit_boolean_value(self):
        props = {b"key": None}
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)

    def test_boolean_values(self):
        props = {b"key1": True, b"key2": False}
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)

    def test_explicit_boolean_true_value(self):
        props = {b"key": boolean_t(1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_boolean_false_value(self):
        props = {b"key": boolean_t(0)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_boolean_invalid_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": boolean_t(2)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_boolean_another_invalid_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": boolean_t(-1)}
            self._dict_to_nvlist_to_dict(props)

    def test_uint64_value(self):
        props = {b"key": 1}
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)

    def test_uint64_max_value(self):
        props = {b"key": 2 ** 64 - 1}
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)

    def test_uint64_too_large_value(self):
        props = {b"key": 2 ** 64}
        with self.assertRaises(OverflowError):
            self._dict_to_nvlist_to_dict(props)

    def test_uint64_negative_value(self):
        props = {b"key": -1}
        with self.assertRaises(OverflowError):
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_uint64_value(self):
        props = {b"key": uint64_t(1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_uint64_max_value(self):
        props = {b"key": uint64_t(2 ** 64 - 1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_uint64_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": uint64_t(2 ** 64)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_uint64_negative_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": uint64_t(-1)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_uint32_value(self):
        props = {b"key": uint32_t(1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_uint32_max_value(self):
        props = {b"key": uint32_t(2 ** 32 - 1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_uint32_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": uint32_t(2 ** 32)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_uint32_negative_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": uint32_t(-1)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_uint16_value(self):
        props = {b"key": uint16_t(1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_uint16_max_value(self):
        props = {b"key": uint16_t(2 ** 16 - 1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_uint16_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": uint16_t(2 ** 16)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_uint16_negative_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": uint16_t(-1)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_uint8_value(self):
        props = {b"key": uint8_t(1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_uint8_max_value(self):
        props = {b"key": uint8_t(2 ** 8 - 1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_uint8_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": uint8_t(2 ** 8)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_uint8_negative_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": uint8_t(-1)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_byte_value(self):
        props = {b"key": uchar_t(1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_byte_max_value(self):
        props = {b"key": uchar_t(2 ** 8 - 1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_byte_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": uchar_t(2 ** 8)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_byte_negative_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": uchar_t(-1)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_int64_value(self):
        props = {b"key": int64_t(1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int64_max_value(self):
        props = {b"key": int64_t(2 ** 63 - 1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int64_min_value(self):
        props = {b"key": int64_t(-(2 ** 63))}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int64_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": int64_t(2 ** 63)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_int64_too_small_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": int64_t(-(2 ** 63) - 1)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_int32_value(self):
        props = {b"key": int32_t(1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int32_max_value(self):
        props = {b"key": int32_t(2 ** 31 - 1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int32_min_value(self):
        props = {b"key": int32_t(-(2 ** 31))}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int32_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": int32_t(2 ** 31)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_int32_too_small_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": int32_t(-(2 ** 31) - 1)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_int16_value(self):
        props = {b"key": int16_t(1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int16_max_value(self):
        props = {b"key": int16_t(2 ** 15 - 1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int16_min_value(self):
        props = {b"key": int16_t(-(2 ** 15))}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int16_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": int16_t(2 ** 15)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_int16_too_small_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": int16_t(-(2 ** 15) - 1)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_int8_value(self):
        props = {b"key": int8_t(1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int8_max_value(self):
        props = {b"key": int8_t(2 ** 7 - 1)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int8_min_value(self):
        props = {b"key": int8_t(-(2 ** 7))}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_explicit_int8_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": int8_t(2 ** 7)}
            self._dict_to_nvlist_to_dict(props)

    def test_explicit_int8_too_small_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": int8_t(-(2 ** 7) - 1)}
            self._dict_to_nvlist_to_dict(props)

    def test_nested_dict(self):
        props = {b"key": {}}
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)

    def test_nested_nested_dict(self):
        props = {b"key": {b"key": {}}}
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)

    def test_mismatching_values_array(self):
        props = {b"key": [1, b"string"]}
        with self.assertRaises(TypeError):
            self._dict_to_nvlist_to_dict(props)

    def test_mismatching_values_array2(self):
        props = {b"key": [True, 10]}
        with self.assertRaises(TypeError):
            self._dict_to_nvlist_to_dict(props)

    def test_mismatching_values_array3(self):
        props = {b"key": [1, False]}
        with self.assertRaises(TypeError):
            self._dict_to_nvlist_to_dict(props)

    def test_string_array(self):
        props = {b"key": [b"value", b"value2"]}
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)

    def test_boolean_array(self):
        props = {b"key": [True, False]}
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)

    def test_explicit_boolean_array(self):
        props = {b"key": [boolean_t(False), boolean_t(True)]}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntArrayDictsEqual(props, res)

    def test_uint64_array(self):
        props = {b"key": [0, 1, 2 ** 64 - 1]}
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)

    def test_uint64_array_too_large_value(self):
        props = {b"key": [0, 2 ** 64]}
        with self.assertRaises(OverflowError):
            self._dict_to_nvlist_to_dict(props)

    def test_uint64_array_negative_value(self):
        props = {b"key": [0, -1]}
        with self.assertRaises(OverflowError):
            self._dict_to_nvlist_to_dict(props)

    def test_mixed_explict_int_array(self):
        with self.assertRaises(TypeError):
            props = {b"key": [uint64_t(0), uint32_t(0)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_uint64_array(self):
        props = {b"key": [uint64_t(0), uint64_t(1), uint64_t(2 ** 64 - 1)]}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntArrayDictsEqual(props, res)

    def test_explict_uint64_array_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [uint64_t(0), uint64_t(2 ** 64)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_uint64_array_negative_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [uint64_t(0), uint64_t(-1)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_uint32_array(self):
        props = {b"key": [uint32_t(0), uint32_t(1), uint32_t(2 ** 32 - 1)]}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntArrayDictsEqual(props, res)

    def test_explict_uint32_array_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [uint32_t(0), uint32_t(2 ** 32)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_uint32_array_negative_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [uint32_t(0), uint32_t(-1)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_uint16_array(self):
        props = {b"key": [uint16_t(0), uint16_t(1), uint16_t(2 ** 16 - 1)]}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntArrayDictsEqual(props, res)

    def test_explict_uint16_array_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [uint16_t(0), uint16_t(2 ** 16)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_uint16_array_negative_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [uint16_t(0), uint16_t(-1)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_uint8_array(self):
        props = {b"key": [uint8_t(0), uint8_t(1), uint8_t(2 ** 8 - 1)]}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntArrayDictsEqual(props, res)

    def test_explict_uint8_array_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [uint8_t(0), uint8_t(2 ** 8)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_uint8_array_negative_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [uint8_t(0), uint8_t(-1)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_byte_array(self):
        props = {b"key": [uchar_t(0), uchar_t(1), uchar_t(2 ** 8 - 1)]}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntArrayDictsEqual(props, res)

    def test_explict_byte_array_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [uchar_t(0), uchar_t(2 ** 8)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_byte_array_negative_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [uchar_t(0), uchar_t(-1)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_int64_array(self):
        props = {b"key": [
            int64_t(0), int64_t(1), int64_t(2 ** 63 - 1), int64_t(-(2 ** 63))]}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntArrayDictsEqual(props, res)

    def test_explict_int64_array_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [int64_t(0), int64_t(2 ** 63)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_int64_array_too_small_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [int64_t(0), int64_t(-(2 ** 63) - 1)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_int32_array(self):
        props = {b"key": [
            int32_t(0), int32_t(1), int32_t(2 ** 31 - 1), int32_t(-(2 ** 31))]}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntArrayDictsEqual(props, res)

    def test_explict_int32_array_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [int32_t(0), int32_t(2 ** 31)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_int32_array_too_small_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [int32_t(0), int32_t(-(2 ** 31) - 1)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_int16_array(self):
        props = {b"key": [
            int16_t(0), int16_t(1), int16_t(2 ** 15 - 1), int16_t(-(2 ** 15))]}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntArrayDictsEqual(props, res)

    def test_explict_int16_array_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [int16_t(0), int16_t(2 ** 15)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_int16_array_too_small_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [int16_t(0), int16_t(-(2 ** 15) - 1)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_int8_array(self):
        props = {b"key": [
            int8_t(0), int8_t(1), int8_t(2 ** 7 - 1), int8_t(-(2 ** 7))]}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntArrayDictsEqual(props, res)

    def test_explict_int8_array_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [int8_t(0), int8_t(2 ** 7)]}
            self._dict_to_nvlist_to_dict(props)

    def test_explict_int8_array_too_small_value(self):
        with self.assertRaises(OverflowError):
            props = {b"key": [int8_t(0), int8_t(-(2 ** 7) - 1)]}
            self._dict_to_nvlist_to_dict(props)

    def test_dict_array(self):
        props = {b"key": [{b"key": 1}, {b"key": None}, {b"key": {}}]}
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)

    def test_implicit_uint32_value(self):
        props = {b"rewind-request": 1}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_implicit_uint32_max_value(self):
        props = {b"rewind-request": 2 ** 32 - 1}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_implicit_uint32_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"rewind-request": 2 ** 32}
            self._dict_to_nvlist_to_dict(props)

    def test_implicit_uint32_negative_value(self):
        with self.assertRaises(OverflowError):
            props = {b"rewind-request": -1}
            self._dict_to_nvlist_to_dict(props)

    def test_implicit_int32_value(self):
        props = {b"pool_context": 1}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_implicit_int32_max_value(self):
        props = {b"pool_context": 2 ** 31 - 1}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_implicit_int32_min_value(self):
        props = {b"pool_context": -(2 ** 31)}
        res = self._dict_to_nvlist_to_dict(props)
        self._assertIntDictsEqual(props, res)

    def test_implicit_int32_too_large_value(self):
        with self.assertRaises(OverflowError):
            props = {b"pool_context": 2 ** 31}
            self._dict_to_nvlist_to_dict(props)

    def test_implicit_int32_too_small_value(self):
        with self.assertRaises(OverflowError):
            props = {b"pool_context": -(2 ** 31) - 1}
            self._dict_to_nvlist_to_dict(props)

    def test_complex_dict(self):
        props = {
            b"key1": b"str",
            b"key2": 10,
            b"key3": {
                b"skey1": True,
                b"skey2": None,
                b"skey3": [
                    True,
                    False,
                    True
                ]
            },
            b"key4": [
                b"ab",
                b"bc"
            ],
            b"key5": [
                2 ** 64 - 1,
                1,
                2,
                3
            ],
            b"key6": [
                {
                    b"skey71": b"a",
                    b"skey72": b"b",
                },
                {
                    b"skey71": b"c",
                    b"skey72": b"d",
                },
                {
                    b"skey71": b"e",
                    b"skey72": b"f",
                }

            ],
            b"type": 2 ** 32 - 1,
            b"pool_context": -(2 ** 31)
        }
        res = self._dict_to_nvlist_to_dict(props)
        self.assertEqual(props, res)


# vim: softtabstop=4 tabstop=4 expandtab shiftwidth=4
