class testRandomModule(unittest.TestCase):
def setUp(self):
self.imp = CImporter("../modules")
def testModule(self):
rand = self.imp.load("random_module")
con1 = rand.connect("integer")
con2 = rand.connect("bool")
con3 = rand.connect("float")
con1.get()
con2.get()
con3.get()
def testParamConnection(self):
rand = self.imp.load("random_module")
con1 = rand.connect("period")
con2 = rand.connect("variance")
self.assertEqual(con1.get(), 0)
self.assertEqual(con2.get(), 0)
con1.set(2.0)
con2.set(0.5)
self.assertEqual(con1.get(), 2)
self.assertEqual(con2.get(), 0.5)
def testEventGeneration(self):
raise NotImplemented # ("This test have to be written...")
class testSequenceConnection (unittest.TestCase):
def setUp(self):
self._d_importer = CImporter("../modules")
def testEventThread(self):
""" CLASS CSequenceConnection events """
root = self._d_importer.load("sequence_reflection", {'timeout':'0.001'})
con1 = root.connect("1")
con2 = Dummy(root,"1")
con1.send("abc")
self.assertEqual(con2.wait(), "abc")
con2.reserve()
con1.send("abc")
con1.send("def")
self.assertEqual(con2.recv(), "abc")
con2.release()
self.assertEqual(con2.wait(), "def")
def testConnectionClose(self):
""" CLASS CSequenceConnection close/count """
root = self._d_importer.load("sequence_reflection", {'timeout':'0.001'})
con1 = root.connect("1")
con2 = root.connect("1")
del con2
con2 = root.connect("1")
self.assertRaises(ItemBusy, root.connect, "1")
def testStreamInterface(self):
""" CLASS CSequenceConnection stream interface """
root = self._d_importer.load("sequence_reflection", {'timeout':'0.001'})
con1 = root.connect("1")
con2 = root.connect("1")
con2.write("abc")
self.assertEqual(con1.read(2), "ab")
con2.write("def")
self.assertEqual(con1.recv(), "c")
self.assertEqual(con1.read(3), "def")
con2.write("ghi")
self.assertEqual(con1.recv(), "ghi")
def testInnerLoad(self):
""" CLASS CAssembly load assembly as inner module """
imp = CImporter()
doc = xml.dom.minidom.parseString(xml_doc3)
meta = CAssemblyMeta(doc, imp)
root = imp.load("stream_reflection")
hexl = meta.instance({}, root, "1")
con1 = hexl.connect("hex:")
con2 = root.connect("1")
con2.write("abc")
self.assertEqual(con1.read(6), "616263")
class testSequenceReflectionModule(unittest.TestCase):
def setUp(self):
self._d_importer = CImporter("../modules")
def testSimpleIO(self):
""" MODULE sequence_reflection simple io """
ref = self._d_importer.load("sequence_reflection",{'timeout':'0.1'})
con1 = ref.connect("1")
con2 = ref.connect("1")
con1.send("abc")
self.assertEqual(con2.recv(), "abc")
con2.send("abc")
self.assertEqual(con1.recv(), "abc")
con1.send("abc")
con1.send("def")
self.assertEqual(con2.recv(), "abc")
con2.send("abc")
self.assertEqual(con1.recv(), "abc")
self.assertEqual(con2.recv(), "def")
class testImporter(unittest.TestCase):
_d_importer = None;
def setUp(self):
self._d_importer = CImporter("../modules");
def testModuleFinding(self):
""" CLASS CImporter module finding """
(path, meta) = self._d_importer.getModuleMeta("stream_reflection");
self.assertRaises(Exception, self._d_importer.getModuleMeta, "DoNotEx");
def testModuleLoading(self):
""" CLASS CImporter module loading """
self._d_importer.load("stream_reflection");
def testInnerModuleLoading(self):
""" CLASS CImporter inner-module loading """
root = self._d_importer.load("stream_reflection")
self._d_importer.load("stream_hexlify", None, root, "1")
def testAssemblyLoading(self):
""" CLASS CImporter simple assembly loading """
root = self._d_importer.load("test_assembly",{'timeout':'0.1'})
con1 = root.connect("refl:1")
con2 = root.connect("refl:1")
con1.write("123")
self.assertEqual(con2.read(3), "123")
def setUp(self):
self._d_importer = CImporter("../modules");
class testAsyncStreamConnection(unittest.TestCase):
_d_importer = None;
def setUp(self):
self._d_importer = CImporter("../modules");
def testTimeout(self):
""" CLASS CAsyncStreamConnection timeout exception """
refl = self._d_importer.load("stream_reflection", {'timeout':'0.0001'});
con1 = refl.connect("aaa");
con2 = refl.connect("aaa");
self.assertRaises(ItemBusy, con1.read, 1);
def testConnectionCount(self):
""" CLASS CAsyncStreamConnection connection count """
refl = self._d_importer.load("stream_reflection", {'timeout':1});
con1 = refl.connect("aaa");
con2 = refl.connect("aaa");
con3 = refl.connect("bbb");
del con3;
self.assertRaises(ItemBusy, refl.connect, "aaa");
del con2;
con2 = refl.connect("aaa");
del con2;
self.assert_(refl.is_busy());
del con1;
self.assert_(not refl.is_busy());
def testDataIntegrity(self):
""" CLASS CAsyncStreamConnection data integrity """
refl = self._d_importer.load("stream_reflection", {'timeout':1});
con1 = refl.connect("aaa");
con2 = refl.connect("aaa");
con1.write("123");
self.assert_( "123" == con2.read(3) );
del con2
dis = DummyDisposable(refl, "aaa");
dis.reserve();
con1.write("1234567890");
self.assert_( dis.read(3) == "123" );
dis.release();
dis.wait();
self.assert_( dis.get_data() == "4567890" );
del con1;
del dis;
self.assert_( not refl.is_busy() );
def setUp(self):
self.imp = CImporter("../modules")
def setUp(self):
self._d_importer = CImporter("../modules");
self._d_root = self._d_importer.load("stream_reflection",{'timeout':'1'})
class testStreamDumpModule( unittest.TestCase ):
def setUp(self):
self._d_importer = CImporter("../modules");
self._d_root = self._d_importer.load("stream_reflection",{'timeout':'1'})
def testConnectionCount(self):
""" MODULE stream_dump connection count """
dump = self._d_importer.load("stream_dump", None, self._d_root, "1")
con1 = dump.connect()
self.assertRaises(ItemBusy, dump.connect)
r_con = dump.connect("read")
self.assertRaises(ItemBusy, dump.connect, "read")
w_con = dump.connect("write")
self.assertRaises(ItemBusy, dump.connect, "write")
e_con = dump.connect("event")
self.assertRaises(ItemBusy, dump.connect, "event")
del e_con
e_con = dump.connect("event")
del e_con
del w_con
del r_con
self.assertEqual(dump.is_busy(), True)
del dump
def testRead(self):
""" MODULE stream_dump test read-channel """
dump = self._d_importer.load("stream_dump", None, self._d_root, "1")
con1 = self._d_root.connect("1")
rcon = dump.connect("read")
con1.write("abc")
con2 = dump.connect()
self.assertEqual(con2.read(3), "abc")
self.assertEqual(rcon.read(3), "abc")
def testEvent(self):
""" MODULE stream_dump test event-channel """
dump = self._d_importer.load("stream_dump", None, self._d_root, "1")
con1 = self._d_root.connect("1")
con2 = dump.connect()
econ = dump.connect("event")
con1.write("abc")
self.assertEqual(con2.read(3), "abc")
self.assertEqual(econ.read(3), "abc")
def testWrite(self):
""" MODULE stream_dump test write-channel """
dump = self._d_importer.load("stream_dump", None, self._d_root, "1")
con1 = self._d_root.connect("1")
con2 = dump.connect()
wcon = dump.connect("write")
con2.write("abc")
self.assertEqual(con1.read(3), "abc")
self.assertEqual(wcon.read(3), "abc")
