class TestBaseNeoQuantitiesScalarTypes(unittest.TestCase): """ TestCase to make sure annotations are properly checked for quantities scalars """ def setUp(self): """create the instance to be tested, called before every test""" self.base = BaseNeo() def test_quantities_scalar_int(self): """test to make sure int type quantites scalars are accepted""" value = quantities.Quantity(99, dtype=numpy.int, units=quantities.s) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_quantities_scalar_uint(self): """test to make sure uint type quantites scalars are accepted""" value = quantities.Quantity(99, dtype=numpy.uint, units=quantities.meter) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_quantities_scalar_float(self): """test to make sure float type quantites scalars are accepted""" value = 99 * quantities.kg self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_quantities_scalar_str(self): """test to make sure str type quantites scalars are rejected""" value = quantities.Quantity(99, dtype=numpy.str, units=quantities.meter) self.assertRaises(ValueError, self.base.annotate, data=value)
def test_annotate(self): '''test to make sure annotation works properly''' base = BaseNeo() base.annotate(test1=1, test2=1) result1 = {'test1': 1, 'test2': 1} self.assertDictEqual(result1, base.annotations) base.annotate(test3=2, test4=3) result2 = {'test3': 2, 'test4': 3} result2a = dict(list(result1.items()) + list(result2.items())) self.assertDictContainsSubset(result1, base.annotations) self.assertDictContainsSubset(result2, base.annotations) self.assertDictEqual(result2a, base.annotations) base.annotate(test1=5, test2=8) result3 = {'test1': 5, 'test2': 8} result3a = dict(list(result3.items()) + list(result2.items())) self.assertDictContainsSubset(result2, base.annotations) self.assertDictContainsSubset(result3, base.annotations) self.assertDictEqual(result3a, base.annotations) self.assertNotEqual(base.annotations['test1'], result1['test1']) self.assertNotEqual(base.annotations['test2'], result1['test2'])
class TestBaseNeoContainerTypes(unittest.TestCase): ''' TestCase to make sure annotations are properly checked for data type inside python built-in container types ''' def setUp(self): '''create the instance to be tested, called before every test''' self.base = BaseNeo() def test_python_list(self): '''test to make sure list type data is accepted''' value = [None, 10, 9.2, complex(23, 11), ['this is a test', bytes('1,2,3,4,5')], [Fraction(13, 21), Decimal("3.14")]] self.base.annotate(data=value) result = {'data': value} self.assertListEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_tuple(self): '''test to make sure tuple type data is accepted''' value = (None, 10, 9.2, complex(23, 11), ('this is a test', bytes('1,2,3,4,5')), (Fraction(13, 21), Decimal("3.14"))) self.base.annotate(data=value) result = {'data': value} self.assertTupleEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_dict(self): '''test to make sure dict type data is accepted''' value = {'NoneType': None, 'int': 10, 'float': 9.2, 'complex': complex(23, 11), 'dict1': {'string': 'this is a test', 'bytes': bytes('1,2,3,4,5')}, 'dict2': {'Fraction': Fraction(13, 21), 'Decimal': Decimal("3.14")}} self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_python_set(self): '''test to make sure set type data is rejected''' value = {None, 10, 9.2, complex(23, 11)} self.assertRaises(ValueError, self.base.annotate, data=value) def test_python_frozenset(self): '''test to make sure frozenset type data is rejected''' value = frozenset([None, 10, 9.2, complex(23, 11)]) self.assertRaises(ValueError, self.base.annotate, data=value) def test_python_iter(self): '''test to make sure iter type data is rejected''' value = iter([None, 10, 9.2, complex(23, 11)]) self.assertRaises(ValueError, self.base.annotate, data=value)
class TestBaseNeoContainerTypes(unittest.TestCase): ''' TestCase to make sure annotations are properly checked for data type inside python built-in container types ''' def setUp(self): '''create the instance to be tested, called before every test''' self.base = BaseNeo() def test_python_list(self): '''test to make sure list type data is accepted''' value = [None, 10, 9.2, complex(23, 11), ['this is a test', bytes('1,2,3,4,5')], [Fraction(13, 21), Decimal("3.14")]] self.base.annotate(data=value) result = {'data': value} self.assertListEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_tuple(self): '''test to make sure tuple type data is accepted''' value = (None, 10, 9.2, complex(23, 11), ('this is a test', bytes('1,2,3,4,5')), (Fraction(13, 21), Decimal("3.14"))) self.base.annotate(data=value) result = {'data': value} self.assertTupleEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_dict(self): '''test to make sure dict type data is accepted''' value = {'NoneType': None, 'int': 10, 'float': 9.2, 'complex': complex(23, 11), 'dict1': {'string': 'this is a test', 'bytes': bytes('1,2,3,4,5')}, 'dict2': {'Fraction': Fraction(13, 21), 'Decimal': Decimal("3.14")}} self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_python_set(self): '''test to make sure set type data is rejected''' value = set([None, 10, 9.2, complex(23, 11)]) self.assertRaises(ValueError, self.base.annotate, data=value) def test_python_frozenset(self): '''test to make sure frozenset type data is rejected''' value = frozenset([None, 10, 9.2, complex(23, 11)]) self.assertRaises(ValueError, self.base.annotate, data=value) def test_python_iter(self): '''test to make sure iter type data is rejected''' value = iter([None, 10, 9.2, complex(23, 11)]) self.assertRaises(ValueError, self.base.annotate, data=value)
class TestBaseNeoQuantitiesArrayTypes(unittest.TestCase): ''' TestCase to make sure annotations are properly checked for quantities arrays ''' def setUp(self): '''create the instance to be tested, called before every test''' self.base = BaseNeo() def test_quantities_array_int(self): '''test to make sure int type quantites arrays are accepted''' value = quantities.Quantity([1, 2, 3, 4, 5], dtype=numpy.int, units=quantities.s) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_quantities_array_uint(self): '''test to make sure uint type quantites arrays are accepted''' value = quantities.Quantity([1, 2, 3, 4, 5], dtype=numpy.uint, units=quantities.meter) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_quantities_array_float(self): '''test to make sure float type quantites arrays are accepted''' value = [1, 2, 3, 4, 5] * quantities.kg self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_quantities_array_str(self): '''test to make sure str type quantites arrays are accepted''' value = quantities.Quantity([1, 2, 3, 4, 5], dtype=numpy.str, units=quantities.meter) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations)
class TestBaseNeoQuantitiesScalarTypes(unittest.TestCase): ''' TestCase to make sure annotations are properly checked for quantities scalars ''' def setUp(self): '''create the instance to be tested, called before every test''' self.base = BaseNeo() def test_quantities_scalar_int(self): '''test to make sure int type quantites scalars are accepted''' value = pq.Quantity(99, dtype=np.int, units=pq.s) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_quantities_scalar_uint(self): '''test to make sure uint type quantites scalars are accepted''' value = pq.Quantity(99, dtype=np.uint, units=pq.meter) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_quantities_scalar_float(self): '''test to make sure float type quantites scalars are accepted''' value = 99 * pq.kg self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_quantities_scalar_str(self): '''test to make sure str type quantites scalars are accepted''' value = pq.Quantity(99, dtype=np.str, units=pq.meter) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations)
def test_annotate(self): """test to make sure annotation works properly""" base = BaseNeo() base.annotate(test1=1, test2=1) result1 = {"test1": 1, "test2": 1} self.assertDictEqual(result1, base.annotations) base.annotate(test3=2, test4=3) result2 = {"test3": 2, "test4": 3} result2a = dict(result1.items() + result2.items()) self.assertDictContainsSubset(result1, base.annotations) self.assertDictContainsSubset(result2, base.annotations) self.assertDictEqual(result2a, base.annotations) base.annotate(test1=5, test2=8) result3 = {"test1": 5, "test2": 8} result3a = dict(result3.items() + result2.items()) self.assertDictContainsSubset(result2, base.annotations) self.assertDictContainsSubset(result3, base.annotations) self.assertDictEqual(result3a, base.annotations) self.assertNotEqual(base.annotations["test1"], result1["test1"]) self.assertNotEqual(base.annotations["test2"], result1["test2"])
class TestBaseNeoCoreTypes(unittest.TestCase): ''' TestCase to make sure annotations are properly checked for core built-in python data types ''' def setUp(self): '''create the instance to be tested, called before every test''' self.base = BaseNeo() def test_python_nonetype(self): '''test to make sure None type data is accepted''' value = None self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_int(self): '''test to make sure int type data is accepted''' value = 10 self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) @unittest.skipIf(sys.version_info[0] >= 3, "not supported in python %s" % python_version()) def test_python_long(self): '''test to make sure long type data is accepted''' value = long(7) self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_float(self): '''test to make sure float type data is accepted''' value = 9.2 self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_complex(self): '''test to make sure complex type data is accepted''' value = complex(23.17, 11.29) self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_string(self): '''test to make sure string type data is accepted''' value = 'this is a test' self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) @unittest.skipIf(sys.version_info[0] >= 3, "not supported in python %s" % python_version()) def test_python_unicode(self): '''test to make sure unicode type data is accepted''' value = eval("u'this is also a test'") # the eval is needed because otherwise it is a SyntaxError in Python 3.2 self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_bytes(self): '''test to make sure bytes type data is accepted''' value = bytes('1,2,3,4,5') self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations)
class TestBaseNeoNumpyScalarTypes(unittest.TestCase): ''' TestCase to make sure annotations are properly checked for numpy scalars ''' def setUp(self): '''create the instance to be tested, called before every test''' self.base = BaseNeo() def test_numpy_scalar_int(self): '''test to make sure int type numpy scalars are accepted''' value = np.array(99, dtype=np.int) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint(self): '''test to make sure uint type numpy scalars are accepted''' value = np.array(99, dtype=np.uint) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_int0(self): '''test to make sure int0 type numpy scalars are accepted''' value = np.array(99, dtype=np.int0) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint0(self): '''test to make sure uint0 type numpy scalars are accepted''' value = np.array(99, dtype=np.uint0) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_int8(self): '''test to make sure int8 type numpy scalars are accepted''' value = np.array(99, dtype=np.int8) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint8(self): '''test to make sure uint8 type numpy scalars are accepted''' value = np.array(99, dtype=np.uint8) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_int16(self): '''test to make sure int16 type numpy scalars are accepted''' value = np.array(99, dtype=np.int16) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint16(self): '''test to make sure uint16 type numpy scalars are accepted''' value = np.array(99, dtype=np.uint16) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_int32(self): '''test to make sure int32 type numpy scalars are accepted''' value = np.array(99, dtype=np.int32) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint32(self): '''test to make sure uint32 type numpy scalars are accepted''' value = np.array(99, dtype=np.uint32) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_int64(self): '''test to make sure int64 type numpy scalars are accepted''' value = np.array(99, dtype=np.int64) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint64(self): '''test to make sure uint64 type numpy scalars are accepted''' value = np.array(99, dtype=np.uint64) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_float(self): '''test to make sure float type numpy scalars are accepted''' value = np.array(99, dtype=np.float) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_floating(self): '''test to make sure floating type numpy scalars are accepted''' value = np.array(99, dtype=np.floating) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_double(self): '''test to make sure double type numpy scalars are accepted''' value = np.array(99, dtype=np.double) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_float16(self): '''test to make sure float16 type numpy scalars are accepted''' value = np.array(99, dtype=np.float16) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_float32(self): '''test to make sure float32 type numpy scalars are accepted''' value = np.array(99, dtype=np.float32) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_float64(self): '''test to make sure float64 type numpy scalars are accepted''' value = np.array(99, dtype=np.float64) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) @unittest.skipUnless(hasattr(np, "float128"), "float128 not available") def test_numpy_scalar_float128(self): '''test to make sure float128 type numpy scalars are accepted''' value = np.array(99, dtype=np.float128) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_complex(self): '''test to make sure complex type numpy scalars are accepted''' value = np.array(99, dtype=np.complex) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_complex64(self): '''test to make sure complex64 type numpy scalars are accepted''' value = np.array(99, dtype=np.complex64) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_complex128(self): '''test to make sure complex128 type numpy scalars are accepted''' value = np.array(99, dtype=np.complex128) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) @unittest.skipUnless(hasattr(np, "complex256"), "complex256 not available") def test_numpy_scalar_complex256(self): '''test to make sure complex256 type numpy scalars are accepted''' value = np.array(99, dtype=np.complex256) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_bool(self): '''test to make sure bool type numpy scalars are rejected''' value = np.array(99, dtype=np.bool) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_str(self): '''test to make sure str type numpy scalars are accepted''' value = np.array(99, dtype=np.str) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_string0(self): '''test to make sure string0 type numpy scalars are rejected''' if sys.version_info[0] >= 3: dtype = np.str0 else: dtype = np.string0 value = np.array(99, dtype=dtype) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations)
class TestBaseNeoStandardLibraryTypes(unittest.TestCase): ''' TestCase to make sure annotations are properly checked for data types from the python standard library that are not core built-in data types ''' def setUp(self): '''create the instance to be tested, called before every test''' self.base = BaseNeo() def test_python_fraction(self): '''test to make sure Fraction type data is accepted''' value = Fraction(13, 21) self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_decimal(self): '''test to make sure Decimal type data is accepted''' value = Decimal("3.14") self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_datetime(self): '''test to make sure datetime type data is accepted''' value = datetime(year=2008, month=12, day=3, hour=10, minute=4) self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_date(self): '''test to make sure date type data is accepted''' value = date(year=2008, month=12, day=3) self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_time(self): '''test to make sure time type data is accepted''' value = time(hour=10, minute=4) self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_timedelta(self): '''test to make sure timedelta type data is accepted''' value = timedelta(weeks=2, days=7, hours=18, minutes=28, seconds=18, milliseconds=28, microseconds=45) self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations)
class TestBaseNeoCoreTypes(unittest.TestCase): ''' TestCase to make sure annotations are properly checked for core built-in python data types ''' def setUp(self): '''create the instance to be tested, called before every test''' self.base = BaseNeo() def test_python_nonetype(self): '''test to make sure None type data is accepted''' value = None self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_int(self): '''test to make sure int type data is accepted''' value = 10 self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_long(self): '''test to make sure long type data is accepted''' value = long(7) self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_float(self): '''test to make sure float type data is accepted''' value = 9.2 self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_complex(self): '''test to make sure complex type data is accepted''' value = complex(23.17, 11.29) self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_string(self): '''test to make sure string type data is accepted''' value = 'this is a test' self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_unicode(self): '''test to make sure unicode type data is accepted''' value = u'this is also a test' self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_bytes(self): '''test to make sure bytes type data is accepted''' value = bytes('1,2,3,4,5') self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations)
class TestBaseNeoNumpyArrayTypes(unittest.TestCase): ''' TestCase to make sure annotations are properly checked for numpy arrays ''' def setUp(self): '''create the instance to be tested, called before every test''' self.base = BaseNeo() def test_numpy_array_int(self): '''test to make sure int type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.int) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_uint(self): '''test to make sure uint type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.uint) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_int0(self): '''test to make sure int0 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.int0) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_uint0(self): '''test to make sure uint0 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.uint0) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_int8(self): '''test to make sure int8 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.int8) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_uint8(self): '''test to make sure uint8 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.uint8) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_int16(self): '''test to make sure int16 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.int16) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_uint16(self): '''test to make sure uint16 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.uint16) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_int32(self): '''test to make sure int32 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.int32) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_uint32(self): '''test to make sure uint32 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.uint32) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_int64(self): '''test to make sure int64 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.int64) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_uint64(self): '''test to make sure uint64 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.uint64) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_float(self): '''test to make sure float type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.float) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_floating(self): '''test to make sure floating type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.floating) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_double(self): '''test to make sure double type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.double) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_float16(self): '''test to make sure float16 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.float16) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_float32(self): '''test to make sure float32 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.float32) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_float64(self): '''test to make sure float64 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.float64) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) @unittest.skipUnless(hasattr(numpy, "float128"), "float128 not available") def test_numpy_array_float128(self): '''test to make sure float128 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.float128) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_complex(self): '''test to make sure complex type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.complex) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_complex64(self): '''test to make sure complex64 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.complex64) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_complex128(self): '''test to make sure complex128 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.complex128) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) @unittest.skipUnless(hasattr(numpy, "complex256"), "complex256 not available") def test_numpy_scalar_complex256(self): '''test to make sure complex256 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.complex256) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_bool(self): '''test to make sure bool type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.bool) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_str(self): '''test to make sure str type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.str) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations) @unittest.skipIf(sys.version_info[0] >= 3, "not supported in python %s" % python_version()) def test_numpy_array_string0(self): '''test to make sure string0 type numpy arrays are accepted''' value = numpy.array([1, 2, 3, 4, 5], dtype=numpy.string0) self.base.annotate(data=value) result = {'data': value} self.assertDictEqual(result, self.base.annotations)
class TestBaseNeoContainerTypes(unittest.TestCase): """ TestCase to make sure annotations are properly checked for data type inside python built-in container types """ def setUp(self): """create the instance to be tested, called before every test""" self.base = BaseNeo() def test_python_list(self): """test to make sure list type data is accepted""" value = [ None, 10, 9.2, complex(23, 11), ["this is a test", bytes("1,2,3,4,5")], [Fraction(13, 21), Decimal(3.14)], ] self.base.annotate(data=value) result = {"data": value} self.assertListEqual(value, self.base.annotations["data"]) self.assertDictEqual(result, self.base.annotations) def test_python_tuple(self): """test to make sure tuple type data is accepted""" value = ( None, 10, 9.2, complex(23, 11), ("this is a test", bytes("1,2,3,4,5")), (Fraction(13, 21), Decimal(3.14)), ) self.base.annotate(data=value) result = {"data": value} self.assertTupleEqual(value, self.base.annotations["data"]) self.assertDictEqual(result, self.base.annotations) def test_python_dict(self): """test to make sure dict type data is accepted""" value = { "NoneType": None, "int": 10, "float": 9.2, "complex": complex(23, 11), "dict1": {"string": "this is a test", "bytes": bytes("1,2,3,4,5")}, "dict2": {"Fraction": Fraction(13, 21), "Decimal": Decimal(3.14)}, } self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_python_set(self): """test to make sure set type data is rejected""" value = set([None, 10, 9.2, complex(23, 11)]) self.assertRaises(ValueError, self.base.annotate, data=value) def test_python_frozenset(self): """test to make sure frozenset type data is rejected""" value = frozenset([None, 10, 9.2, complex(23, 11)]) self.assertRaises(ValueError, self.base.annotate, data=value) def test_python_iter(self): """test to make sure iter type data is rejected""" value = iter([None, 10, 9.2, complex(23, 11)]) self.assertRaises(ValueError, self.base.annotate, data=value)
class TestBaseNeoNumpyScalarTypes(unittest.TestCase): """ TestCase to make sure annotations are properly checked for numpy scalars """ def setUp(self): """create the instance to be tested, called before every test""" self.base = BaseNeo() def test_numpy_scalar_int(self): """test to make sure int type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.int) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint(self): """test to make sure uint type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.uint) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_int0(self): """test to make sure int0 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.int0) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint0(self): """test to make sure uint0 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.uint0) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_int8(self): """test to make sure int8 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.int8) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint8(self): """test to make sure uint8 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.uint8) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_int16(self): """test to make sure int16 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.int16) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint16(self): """test to make sure uint16 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.uint16) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_int32(self): """test to make sure int32 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.int32) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint32(self): """test to make sure uint32 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.uint32) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_int64(self): """test to make sure int64 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.int64) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_uint64(self): """test to make sure uint64 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.uint64) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_float(self): """test to make sure float type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.float) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_floating(self): """test to make sure floating type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.floating) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_double(self): """test to make sure double type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.double) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_float16(self): """test to make sure float16 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.float16) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_float32(self): """test to make sure float32 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.float32) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_float64(self): """test to make sure float64 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.float64) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_float128(self): """test to make sure float128 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.float128) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_complex(self): """test to make sure complex type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.complex) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_complex64(self): """test to make sure complex64 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.complex64) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_complex128(self): """test to make sure complex128 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.complex128) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_complex256(self): """test to make sure complex256 type numpy scalars are accepted""" value = numpy.array(99, dtype=numpy.complex256) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_scalar_bool(self): """test to make sure bool type numpy scalars are rejected""" value = numpy.array(99, dtype=numpy.bool) self.base.annotate(data=value) result = {"data": value} self.assertDictEqual(result, self.base.annotations) def test_numpy_array_str(self): """test to make sure str type numpy scalars are rejected""" value = numpy.array(99, dtype=numpy.str) self.assertRaises(ValueError, self.base.annotate, data=value) def test_numpy_scalar_string0(self): """test to make sure string0 type numpy scalars are rejected""" value = numpy.array(99, dtype=numpy.string0) self.assertRaises(ValueError, self.base.annotate, data=value)
class TestBaseNeoCoreTypes(unittest.TestCase): ''' TestCase to make sure annotations are properly checked for core built-in python data types ''' def setUp(self): '''create the instance to be tested, called before every test''' self.base = BaseNeo() def test_python_nonetype(self): '''test to make sure None type data is accepted''' value = None self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_int(self): '''test to make sure int type data is accepted''' value = 10 self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) @unittest.skipIf(sys.version_info[0] >= 3, "not supported in python %s" % python_version()) def test_python_long(self): '''test to make sure long type data is accepted''' value = long(7) self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_float(self): '''test to make sure float type data is accepted''' value = 9.2 self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_complex(self): '''test to make sure complex type data is accepted''' value = complex(23.17, 11.29) self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_string(self): '''test to make sure string type data is accepted''' value = 'this is a test' self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) @unittest.skipIf(sys.version_info[0] >= 3, "not supported in python %s" % python_version()) def test_python_unicode(self): '''test to make sure unicode type data is accepted''' value = eval( "u'this is also a test'" ) # the eval is needed because otherwise it is a SyntaxError in Python 3.2 self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations) def test_python_bytes(self): '''test to make sure bytes type data is accepted''' value = bytes('1,2,3,4,5') self.base.annotate(data=value) result = {'data': value} self.assertEqual(value, self.base.annotations['data']) self.assertDictEqual(result, self.base.annotations)
class TestBaseNeoCoreTypes(unittest.TestCase): """ TestCase to make sure annotations are properly checked for core built-in python data types """ def setUp(self): """create the instance to be tested, called before every test""" self.base = BaseNeo() def test_python_nonetype(self): """test to make sure None type data is accepted""" value = None self.base.annotate(data=value) result = {"data": value} self.assertEqual(value, self.base.annotations["data"]) self.assertDictEqual(result, self.base.annotations) def test_python_int(self): """test to make sure int type data is accepted""" value = 10 self.base.annotate(data=value) result = {"data": value} self.assertEqual(value, self.base.annotations["data"]) self.assertDictEqual(result, self.base.annotations) @unittest.skipIf(sys.version_info.major >= 3, "not supported in python %s" % python_version()) def test_python_long(self): """test to make sure long type data is accepted""" value = long(7) self.base.annotate(data=value) result = {"data": value} self.assertEqual(value, self.base.annotations["data"]) self.assertDictEqual(result, self.base.annotations) def test_python_float(self): """test to make sure float type data is accepted""" value = 9.2 self.base.annotate(data=value) result = {"data": value} self.assertEqual(value, self.base.annotations["data"]) self.assertDictEqual(result, self.base.annotations) def test_python_complex(self): """test to make sure complex type data is accepted""" value = complex(23.17, 11.29) self.base.annotate(data=value) result = {"data": value} self.assertEqual(value, self.base.annotations["data"]) self.assertDictEqual(result, self.base.annotations) def test_python_string(self): """test to make sure string type data is accepted""" value = "this is a test" self.base.annotate(data=value) result = {"data": value} self.assertEqual(value, self.base.annotations["data"]) self.assertDictEqual(result, self.base.annotations) @unittest.skipIf(sys.version_info.major >= 3, "not supported in python %s" % python_version()) def test_python_unicode(self): """test to make sure unicode type data is accepted""" value = u"this is also a test" self.base.annotate(data=value) result = {"data": value} self.assertEqual(value, self.base.annotations["data"]) self.assertDictEqual(result, self.base.annotations) def test_python_bytes(self): """test to make sure bytes type data is accepted""" value = bytes("1,2,3,4,5") self.base.annotate(data=value) result = {"data": value} self.assertEqual(value, self.base.annotations["data"]) self.assertDictEqual(result, self.base.annotations)