def test_dict(self):
fun = sys._getframe().f_code.co_name
print("Run: %s.%s() " % (self.__class__.__name__, fun))
el = NTP()
self.assertTrue(isinstance(el, object))
for it in self._pTt:
self.assertEqual(el.pTt[it], self._pTt[it])
self.assertEqual(NTP.pTt[it], self._pTt[it])
for it in self._npTt:
self.assertEqual(el.pTt[it], self._npTt[it])
self.assertEqual(NTP.pTt[it], self._npTt[it])
for it in self._nTnp:
self.assertEqual(el.nTnp[it], self._nTnp[it])
self.assertEqual(NTP.nTnp[it], self._nTnp[it])
for it in self._convert:
self.assertEqual(el.convert[it], self._convert[it])
self.assertEqual(NTP.convert[it], self._convert[it])
for it in self._aTn:
self.assertEqual(el.aTn[it], self._aTn[it])
self.assertEqual(NTP.aTn[it], self._aTn[it])
for it in self._aTnv:
self.assertEqual(el.aTnv[it], self._aTnv[it])
self.assertEqual(NTP.aTnv[it], self._aTnv[it])
for it in self._rTf:
self.assertEqual(el.rTf[it], self._rTf[it])
self.assertEqual(NTP.rTf[it], self._rTf[it])
def test_createArray_spectrum(self):
fun = sys._getframe().f_code.co_name
print("Run: %s.%s() " % (self.__class__.__name__, fun))
arrs = {}
arrs["b"] = {
"SpectrumBoolean": ["bool", "DevBoolean", True, [1, 0]],
}
arrs["i"] = {
"SpectrumShort": ["int16", "DevShort", -13, [1, 0]],
"SpectrumLong": ["int64", "DevLong", -14, [1, 0]],
"SpectrumLong64": ["int64", "DevLong64", -24, [1, 0]],
}
arrs["u"] = {
"SpectrumUChar": ["uint8", "DevUChar", 23, [1, 0]],
"SpectrumULong": ["uint64", "DevULong", 2, [1, 0]],
"SpectrumUShort": ["uint16", "DevUShort", 1, [1, 0]],
"SpectrumULong64": ["uint64", "DevULong64", 3, [1, 0]],
}
arrs["f"] = {
"SpectrumFloat": ["float32", "DevFloat", 12.234, [1, 0], 1e-5],
"SpectrumDouble":
["float64", "DevDouble", -2.456673e+02, [1, 0], 1e-14],
}
arrs["s"] = {
"SpectrumString": ["string", "DevString", "MyTrue", [1, 0]],
# "State":[ "string", "DevState", PyTango._PyTango.DevState.ON],
}
types = {}
types["i"] = {"int": 0, "int8": 0, "int16": 0, "int32": 0, "int64": 0}
types["u"] = {
"uint": 0,
"uint8": 0,
"uint16": 0,
"uint32": 0,
"uint64": 0
}
types["f"] = {
"float": 1e-5,
"float16": 1e-01,
"float32": 1e-5,
"float64": 1e-14
}
types["s"] = {"string": 0}
types["b"] = {"bool": 0}
ca = {
"i": {
"i": True,
"u": True,
"f": True,
"s": False,
"b": True
},
"u": {
"i": True,
"u": True,
"f": True,
"s": False,
"b": True
},
"f": {
"i": True,
"u": True,
"f": True,
"s": False,
"b": True
},
"s": {
"i": True,
"u": True,
"f": True,
"s": True,
"b": True
},
"b": {
"i": True,
"u": True,
"f": True,
"s": True,
"b": True
}
}
for s in arrs:
arr = arrs[s]
for k in arr:
if arr[k][1] != "DevBoolean":
mlen = [
self.__rnd.randint(1, 10),
self.__rnd.randint(0, 3)
]
arr[k][2] = [
arr[k][2] * self.__rnd.randint(1, 3)
for c in range(mlen[0])
]
else:
mlen = [self.__rnd.randint(1, 10)]
arr[k][2] = [(True if self.__rnd.randint(0, 1) else False)
for c in range(mlen[0])]
arr[k][3] = [mlen[0], 0]
for k in arrs:
arr = arrs[k]
for a in arr:
value = arr[a][2]
for c in ca:
for it in types[c]:
if ca[c][k] is True:
evalue = [NTP.convert[it](e) for e in value]
elc = NTP().createArray(value, NTP.convert[it])
self.assertEqual(len(evalue), len(elc))
for i in range(len(evalue)):
if types[c][it]:
self.assertTrue(
abs(evalue[i] -
elc[i]) <= types[c][it])
else:
self.assertEqual(evalue[i], elc[i])
evalue = [e for e in value]
elc = NTP().createArray(value)
self.assertEqual(len(evalue), len(elc))
for i in range(len(evalue)):
if k != "s":
self.assertTrue(
abs(evalue[i] - elc[i]) <= types[c][it])
else:
self.assertEqual(evalue[i], elc[i])
def test_createArray_scalar_from_string(self):
fun = sys._getframe().f_code.co_name
print("Run: %s.%s() " % (self.__class__.__name__, fun))
arrs = {}
arrs["f"] = {
"ScalarString1": ["string", "DevString", "12.3243"],
"ScalarString2": ["string", "DevString", "-12.3243"],
"ScalarString3": ["string", "DevString", "12.3243"],
}
arrs["i"] = {
"ScalarString1": ["string", "DevString", "-1"],
"ScalarString2": ["string", "DevString", "-125"],
"ScalarString3": ["string", "DevString", "-124"],
}
arrs["u"] = {
"ScalarString1": ["string", "DevString", "-1"],
"ScalarString2": ["string", "DevString", "-125"],
"ScalarString3": ["string", "DevString", "-124"],
}
arrs["s"] = {
"ScalarString1": ["string", "DevString", "bnle"],
"ScalarString2": ["string", "DevString", "What"],
"ScalarString3": ["string", "DevString", "Cos"],
}
arrs["b"] = {
"ScalarString1": ["string", "DevString", "True"],
"ScalarString2": ["string", "DevString", "False"],
"ScalarString3": ["string", "DevString", "true"],
}
types = {}
types["i"] = ["int", "int8", "int16", "int32", "int64"]
types["u"] = ["uint", "uint8", "uint16", "uint32", "uint64"]
types["f"] = ["float", "float16", "float32", "float64"]
types["s"] = ["string"]
types["b"] = ["bool"]
ca = {
"i": {
"i": True,
"u": True,
"f": False,
"s": False,
"b": False
},
"u": {
"i": True,
"u": True,
"f": False,
"s": False,
"b": False
},
"f": {
"i": True,
"u": True,
"f": True,
"s": False,
"b": False
},
"s": {
"i": True,
"u": True,
"f": True,
"s": True,
"b": True
},
"b": {
"i": True,
"u": True,
"f": True,
"s": True,
"b": True
}
}
for k in arrs:
arr = arrs[k]
for a in arr:
value = arr[a][2]
for c in ca:
for it in types[c]:
if ca[c][k] is True:
res = NTP().createArray(value, NTP.convert[it])
self.assertEqual(NTP.convert[it](value), res)
res = NTP().createArray(value)
self.assertEqual(value, res)
def test_createArray_scalar(self):
fun = sys._getframe().f_code.co_name
print("Run: %s.%s() " % (self.__class__.__name__, fun))
arrs = {}
arrs["b"] = {
"ScalarBoolean": ["bool", "DevBoolean", True],
}
arrs["i"] = {
"ScalarShort": ["int16", "DevShort", -123],
"ScalarLong": ["int64", "DevLong", -124],
"ScalarLong64": ["int64", "DevLong64", 234],
}
arrs["u"] = {
"ScalarUChar": ["uint8", "DevUChar", 23],
"ScalarUShort": ["uint16", "DevUShort", 1234],
"ScalarULong": ["uint64", "DevULong", 234],
"ScalarULong64": ["uint64", "DevULong64", 23],
}
arrs["f"] = {
"ScalarFloat": ["float32", "DevFloat", 12.234, 1e-5],
"ScalarDouble": ["float64", "DevDouble", -2.456673e+02, 1e-14],
}
arrs["s"] = {
"ScalarString": ["string", "DevString", "MyTrue"],
# "State":[ "string", "DevState", PyTango._PyTango.DevState.ON],
}
types = {}
types["i"] = ["int", "int8", "int16", "int32", "int64"]
types["u"] = ["uint", "uint8", "uint16", "uint32", "uint64"]
types["f"] = ["float", "float16", "float32", "float64"]
types["s"] = ["string"]
types["b"] = ["bool"]
ca = {
"i": {
"i": True,
"u": True,
"f": True,
"s": False,
"b": True
},
"u": {
"i": True,
"u": True,
"f": True,
"s": False,
"b": True
},
"f": {
"i": True,
"u": True,
"f": True,
"s": False,
"b": True
},
"s": {
"i": True,
"u": True,
"f": True,
"s": True,
"b": True
},
"b": {
"i": True,
"u": True,
"f": True,
"s": True,
"b": True
}
}
for k in arrs:
arr = arrs[k]
for a in arr:
value = arr[a][2]
for c in ca:
if ca[c][k] is True:
for it in types[c]:
res = NTP().createArray(value, NTP.convert[it])
self.assertEqual(NTP.convert[it](value), res)
res = NTP().createArray(value)
self.assertEqual(value, res)
def test_arrayRankShape_np(self):
fun = sys._getframe().f_code.co_name
print("Run: %s.%s() " % (self.__class__.__name__, fun))
mlen = [
self.__rnd.randint(2, 100),
self.__rnd.randint(2, 50),
self.__rnd.randint(2, 20),
self.__rnd.randint(2, 10)
]
arr = [
[12, 0, [], "int64"],
[[], 1, [0], None],
[[[]], 2, [1, 0], None],
[[[[]]], 3, [1, 1, 0], None],
[[[[[]]]], 4, [1, 1, 1, 0], None],
[[0], 1, [1], "int64"],
[[[1.0]], 2, [1, 1], "float64"],
[[[["str"]]], 3, [1, 1, 1], "str"],
[[[[[True]]]], 4, [1, 1, 1, 1], "bool"],
[[False], 1, [1], "bool"],
[[1] * mlen[0], 1, [mlen[0]], "int64"],
[["sdf"] * mlen[1], 1, [mlen[1]], "str"],
[[-2.1233 * self.__rnd.randint(2, 100) for c in range(mlen[2])], 1,
[mlen[2]], "float64"],
[[[123] * mlen[0]], 2, [1, mlen[0]], "int64"],
[[["text"]] * mlen[1], 2, [mlen[1], 1], "str"],
[[[13.12 * self.__rnd.randint(2, 100) for c in range(mlen[2])]], 2,
[1, mlen[2]], "float64"],
[[[13 * self.__rnd.randint(2, 100)] for c in range(mlen[2])], 2,
[mlen[2], 1], "int64"],
[[["a" * self.__rnd.randint(2, 100) for c in range(mlen[1])]
for cc in range(mlen[2])], 2, [mlen[2], mlen[1]], "str"],
[[[[True] * mlen[0]]], 3, [1, 1, mlen[0]], "bool"],
[[[[123.123]] * mlen[0]], 3, [1, mlen[0], 1], "float64"],
[[[["as"]]] * mlen[1], 3, [mlen[1], 1, 1], "str"],
[[[[13 * self.__rnd.randint(2, 100) for c in range(mlen[2])]]], 3,
[1, 1, mlen[2]], "int64"],
[[[[13.123 * self.__rnd.randint(2, 100)] for c in range(mlen[2])]],
3, [1, mlen[2], 1], "float64"],
[[[["ta" * self.__rnd.randint(1, 100)]] for c in range(mlen[2])],
3, [mlen[2], 1, 1], "str"],
[[[[13.123 * self.__rnd.randint(2, 100)
for c in range(mlen[1])] for cc in range(mlen[2])]], 3,
[1, mlen[2], mlen[1]], "float64"],
[[[[13 * self.__rnd.randint(2, 100) for c in range(mlen[1])]]
for cc in range(mlen[2])], 3, [mlen[2], 1, mlen[1]], "int64"],
[[[["w" * self.__rnd.randint(2, 100) for c in range(mlen[1])]
for cc in range(mlen[2])] for ccC in range(mlen[3])], 3,
[mlen[3], mlen[2], mlen[1]], "str"],
[[[[[False] * mlen[0]]]], 4, [1, 1, 1, mlen[0]], "bool"],
[[[[[123.123]] * mlen[0]]], 4, [1, 1, mlen[0], 1], "float64"],
[[[[[123]]] * mlen[0]], 4, [1, mlen[0], 1, 1], "int64"],
[[[[["bleble"]]]] * mlen[1], 4, [mlen[1], 1, 1, 1], "str"],
[[[[[13.123 * self.__rnd.randint(2, 100)
for c in range(mlen[2])]]]], 4, [1, 1, 1, mlen[2]],
"float64"],
[[[[[13 * self.__rnd.randint(2, 100)] for c in range(mlen[2])]]],
4, [1, 1, mlen[2], 1], "int64"],
[[[[["1" * self.__rnd.randint(2, 100)]] for c in range(mlen[2])]],
4, [1, mlen[2], 1, 1], "str"],
[[[[[13.123 * self.__rnd.randint(2, 100)]]]
for c in range(mlen[2])], 4, [mlen[2], 1, 1, 1], "float64"],
[[[[[13 * self.__rnd.randint(2, 100)
for c in range(mlen[1])] for cc in range(mlen[2])]]], 4,
[1, 1, mlen[2], mlen[1]], "int64"],
[[[[["t" * self.__rnd.randint(2, 100) for c in range(mlen[1])]]
for cc in range(mlen[2])]], 4, [1, mlen[2], 1, mlen[1]], "str"],
[[[[[13.123 * self.__rnd.randint(2, 100)]
for c in range(mlen[1])]] for cc in range(mlen[2])], 4,
[mlen[2], 1, mlen[1], 1], "float64"],
[[[[[13 * self.__rnd.randint(2, 100) for c in range(mlen[1])]
for cc in range(mlen[2])] for ccc in range(mlen[3])]], 4,
[1, mlen[3], mlen[2], mlen[1]], "int64"],
[[[[["13" * self.__rnd.randint(2, 100) for c in range(mlen[1])]
for cc in range(mlen[2])]] for ccc in range(mlen[3])], 4,
[mlen[3], 1, mlen[2], mlen[1]], "str"],
[[[[[13.00 * self.__rnd.randint(2, 100) for c in range(mlen[1])]]
for cc in range(mlen[2])] for ccc in range(mlen[3])], 4,
[mlen[3], mlen[2], 1, mlen[1]], "float64"],
[[[[[13 * self.__rnd.randint(2, 100)] for c in range(mlen[1])]
for cc in range(mlen[2])] for ccc in range(mlen[3])], 4,
[mlen[3], mlen[2], mlen[1], 1], "int64"],
[[[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[0])]
for cc in range(mlen[1])] for ccc in range(mlen[2])]
for cccc in range(mlen[3])], 4,
[mlen[3], mlen[2], mlen[1], mlen[0]], "float64"],
]
el = NTP()
for a in arr:
self.assertEqual(el.arrayRankShape(numpy.array(a[0]))[0], a[1])
self.assertEqual(el.arrayRankShape(numpy.array(a[0]))[1], a[2])
if a[3] is None:
self.assertEqual(el.arrayRankShape(numpy.array(a[0]))[2], a[3])
else:
self.assertEqual(el.arrayRankShape(numpy.array(a[0]))[2], a[3])
def test_arrayRank(self):
fun = sys._getframe().f_code.co_name
print("Run: %s.%s() " % (self.__class__.__name__, fun))
mlen = [
self.__rnd.randint(1, 100),
self.__rnd.randint(1, 50),
self.__rnd.randint(1, 20),
self.__rnd.randint(2, 10)
]
arr = [
[12, 0],
[[], 1],
[[[]], 2],
[[[[]]], 3],
[[[[[]]]], 4],
[[0], 1],
[[[0]], 2],
[[[[0]]], 3],
[[[[[0]]]], 4],
[[-0.243], 1],
[[1] * mlen[0], 1],
[[-2.1233] * mlen[1], 1],
[[-2.1233 * self.__rnd.randint(2, 100) for c in range(mlen[2])],
1],
[[[123.123] * mlen[0]], 2],
[[[13.123]] * mlen[1], 2],
[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[2])]],
2],
[[[13.123 * self.__rnd.randint(2, 100)] for c in range(mlen[2])],
2],
[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[1])]
for cc in range(mlen[2])], 2],
[[[[123.123] * mlen[0]]], 3],
[[[[123.123]] * mlen[0]], 3],
[[[[13.123]]] * mlen[1], 3],
[[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[2])]]],
3],
[[[[13.123 * self.__rnd.randint(2, 100)] for c in range(mlen[2])]],
3],
[[[[13.123 * self.__rnd.randint(2, 100)]] for c in range(mlen[2])],
3],
[[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[1])]
for cc in range(mlen[2])]], 3],
[[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[1])]]
for cc in range(mlen[2])], 3],
[[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[1])]
for cc in range(mlen[2])] for ccC in range(mlen[2])], 3],
[[[[[123.123] * mlen[0]]]], 4],
[[[[[123.123]] * mlen[0]]], 4],
[[[[[123.123]]] * mlen[0]], 4],
[[[[[13.123]]]] * mlen[1], 4],
[[[[[13.123 * self.__rnd.randint(2, 100)
for c in range(mlen[2])]]]], 4],
[[[[[13.123 * self.__rnd.randint(2, 100)]
for c in range(mlen[2])]]], 4],
[[[[[13.123 * self.__rnd.randint(2, 100)]]
for c in range(mlen[2])]], 4],
[[[[[13.123 * self.__rnd.randint(2, 100)]]]
for c in range(mlen[2])], 4],
[[[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[1])]
for cc in range(mlen[2])]]], 4],
[[[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[1])]]
for cc in range(mlen[2])]], 4],
[[[[[13.123 * self.__rnd.randint(2, 100)] for c in range(mlen[1])]]
for cc in range(mlen[2])], 4],
[[[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[1])]
for cc in range(mlen[2])] for ccc in range(mlen[3])]], 4],
[[[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[1])]
for cc in range(mlen[2])]] for ccc in range(mlen[3])], 4],
[[[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[1])]]
for cc in range(mlen[2])] for ccc in range(mlen[3])], 4],
[[[[[13.123 * self.__rnd.randint(2, 100) for c in range(mlen[1])]
for cc in range(mlen[2])] for ccc in range(mlen[3])]
for cccc in range(mlen[0])], 4],
]
el = NTP()
for a in arr:
self.assertEqual(el.arrayRank(a[0]), a[1])
self.assertEqual(el.arrayRank(numpy.array(a[0])), a[1])