| # |
| # 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 |