class SelectTest(RTCBaseTest):
"""Poll the rtc using select"""
PREREQUISITES = [qatest.PreReq("ReadTimeTest")]
def test_method(self):
rtc = self.config.rtc
self.info("Using select(2) on /dev/rtc")
def _rtc_counter():
irqcount = 0
while irqcount < 5:
rd, wr, ex = select.select([rtc], [], [], 5)
if rtc in rd:
count, status = rtc.read() # will not block
irqcount += 1
self.info(" counted %d (rtc count = %d, status = %s)" %
(irqcount, count, status))
return irqcount
rtc.update_interrupt_on()
try:
# should take 5 seconds to run, timeout is 7 seconds
irqcount = self.config.sched.iotimeout(_rtc_counter, timeout=7)
except TimeoutError:
rtc.update_interrupt_off()
return self.failed(
"rtc.read() from select did not finish before timeout")
rtc.update_interrupt_off()
self.assert_equal(irqcount, 5, "wrong count of timer events")
return self.passed("counted %d events" % (irqcount, ))
class getNodeByOID(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
n = SMI.get_node_by_OID("1.3.6.1.4.1.1575.1.7")
self.assert_equal(n.name, "testMIB")
return self.passed("got node by OID")
class BlockingReadTest(RTCBaseTest):
"""Normal blocking read. Use scheduler to force a timeout."""
PREREQUISITES = [qatest.PreReq("ReadTimeTest")]
def test_method(self):
# Turn on update interrupts (one per second) */
self.info("RTC Driver (and Python rtc module) Test.")
self.irqcount = 0
rtc = self.config.rtc
def _rtc_counter():
irqcount = 0
while irqcount < 5:
count, status = rtc.read() # will block
irqcount += 1
self.info(" counted %d (rtc count = %d, status = %s)" %
(irqcount, count, status))
return irqcount
rtc.update_interrupt_on()
self.info("Counting 5 update (1/sec) interrupts from reading /dev/rtc")
try:
# should take 5 seconds to run, timeout is 7 seconds
irqcount = self.config.sched.iotimeout(_rtc_counter, timeout=7)
except TimeoutError:
rtc.update_interrupt_off()
return self.failed("rtc.read() did not finish before timeout")
rtc.update_interrupt_off()
self.assert_equal(irqcount, 5, "wrong count of timer events")
return self.passed("counted %d events" % (irqcount, ))
class BasicFileReadTest(AsyncIOBaseTest):
PREREQUISITES = [qatest.PreReq("BasicFileWriteTest")]
def test_method(self):
fo = asyncio.FileWrapper(file("testwrite.txt", "w"))
fo.write("testing\n")
fo.close()
return self.passed("opened file for write")
class NodeModule(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("NodeChildren")]
def test_method(self):
child = self.config.testchild
mod = child.get_module()
self.assert_equal(mod.name, "TCP-MIB")
return self.passed("got correct module")
class ModuleNode(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = self.config.testModule
n = m.get_node("testMIB")
self.assert_equal("testMIB", n.name)
self.verboseinfo(n)
return self.passed("got testMIB node")
class ModuleMacro(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = SMI.get_module("SNMPv2-SMI")
mac = m.get_macro("NOTIFICATION-TYPE")
self.verboseinfo(mac)
self.assert_equal(mac.name, "NOTIFICATION-TYPE")
return self.passed("Got macro.")
class ModuleImported(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = SMI.get_module(MIBS[0])
m2 = SMI.get_module("SNMPv2-SMI")
self.assert_true(m.is_imported(m2, "Integer32"))
self.assert_false(m.is_imported(m2, "Counter64"))
return self.passed("All is_imported assertions passed.")
class NodeLine(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("NodeChildren")]
def test_method(self):
c = self.config.testchild # last test deletes the node!
l = c.get_line()
self.info("%s defined on line %d in module %s" %
(c.name, l, c.get_module().name))
self.assert_true(l > 0)
return self.passed("got node line number")
class ModuleImports(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = self.config.testModule
self.info("Imports for %s:" % (m.name, ))
imps = m.get_imports()
for imp in imps:
self.info(imp)
return self.passed("got imports")
class ModuleIdentityNode(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = self.config.testModule
idn = m.identityNode
self.verboseinfo(idn)
if idn:
return self.passed("got identity node")
else:
return self.failed("did not get identity node")
class NodeRelated(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("NodeChildren")]
def test_method(self):
mod = SMI.get_module("IF-MIB")
node = mod.get_node("ifXEntry")
rel = node.get_related() # gets AUGMENTS node
if rel and rel.name == "ifEntry":
return self.passed("got correct relation")
else:
return self.failed("failed to get proper augmentation!")
class ModuleRevisions(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = self.config.testModule
revs = m.get_revisions()
self.info("Got revisions list:")
for rev in revs:
self.info(rev)
#self.assert_true(revs)
return self.passed("Got revisions")
class ModuleType(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = SMI.get_module("TUBS-IBR-TEST-MIB")
t = m.get_type("OctalValue")
self.info(t)
if t is None:
return self.abort("The tested module returned no Type")
self.assert_equal(t.name, "OctalValue")
return self.passed("got specified type")
class NodeParent(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("NodeChildren")]
def test_method(self):
# table and child stashed by NodeChildren test
table = self.config.testtable
del self.config.testtable
child = self.config.testchild
parent = child.get_parent()
self.assert_equal(parent.name, table.name)
self.assert_equal(parent.OID, table.OID)
return self.passed("got correct parent")
class ModuleMacros(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
got = 0
m = SMI.get_module("SNMPv2-SMI")
for mac in m.get_macros():
self.info(mac)
got = 1
if got:
return self.passed("got macros")
else:
return self.failed("no macros returned")
class ModuleScalars(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = SMI.get_module("TCP-MIB")
got = 0
for scalar in m.get_scalars():
self.verboseinfo(scalar.name)
got = 1
if got:
return self.passed("got scalars")
else:
return self.failed("no scalars!")
class ModuleRows(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = SMI.get_module("TCP-MIB")
got = 0
for row in m.get_rows():
self.verboseinfo(row.name)
got = 1
if got:
return self.passed("got rows")
else:
return self.failed("no rows!")
class ModuleCapabilities(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = SMI.get_module("XXX ") # XXX what module has capabilities?
got = 0
for cap in m.get_capabilities():
self.verboseinfo(cap)
got = 1
if got:
return self.passed("got capabilities")
else:
return self.failed("no capabilities!")
class ModuleGroups(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = SMI.get_module("IF-MIB")
got = 0
for grp in m.get_groups():
self.verboseinfo(grp)
got = 1
if got:
return self.passed("got groups")
else:
return self.failed("no groups!")
class ModuleCompliances(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = SMI.get_module("IF-MIB")
got = 0
for comp in m.get_compliances():
self.verboseinfo(comp)
got = 1
if got:
return self.passed("got compliances")
else:
return self.failed("no compliances!")
class ModuleColumns(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = SMI.get_module("TCP-MIB")
got = 0
for col in m.get_columns():
self.verboseinfo(col.name)
got = 1
if got:
return self.passed("got columns")
else:
return self.failed("no columns!")
class ModuleTables(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = SMI.get_module("TCP-MIB")
got = 0
for table in m.get_tables():
self.verboseinfo(table.name)
got = 1
if got:
return self.passed("got tables")
else:
return self.failed("no tables!")
class ModuleNotifications(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = SMI.get_module("IF-MIB")
got = 0
for notif in m.get_notifications():
self.verboseinfo(notif)
got = 1
if got:
return self.passed("got notifications")
else:
return self.failed("no notifications!")
class IRQCountTest(RTCBaseTest):
"""Verify that total amount of IRQ firings match what we expect."""
PREREQUISITES = [qatest.PreReq("ReadTimeTest")]
def test_method(self):
self.config.interrupts.update()
irqcount = self.config.interrupts[8][0].count - self.config.irqstart
self.info('%s more events on IRQ 8.' % (irqcount, ))
# previous testing determined that this set of tests will fire IRQ 8
# exactly 131 times. If new tests are added then this number should be
# hand-verified and changed.
self.assert_equal(131, irqcount, "strange IRQ count")
return self.passed("got expected IRQ count")
class ModuleTypes(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = self.config.testModule
got = 0
self.info("Got type list:")
for tp in m.get_types():
self.verboseinfo(tp)
got = 1
if got:
return self.passed("got type list")
else:
return self.failed("failed to get type list!")
class DirectoryNotifyRemoveTest(AsyncIOBaseTest):
PREREQUISITES = [qatest.PreReq("DirectoryNotifyAddTest")]
def test_method(self):
manager = asyncio.get_manager()
os.unlink("newfile.txt")
self.config.sched.sleep(2)
dn = manager.get(self.config.dirhandle)
self.info("removed files: %s" % (dn.removed, ))
manager.unregister(self.config.dirhandle)
assert len(dn.removed) == 1
assert "newfile.txt" == dn.removed[0]
del dn
return self.passed("passed all assertions")
class ModuleNodes(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("ModuleNew")]
def test_method(self):
m = self.config.testModule
got = 0
kind = SMI.SMI_NODEKIND_ANY
nodes = m.get_nodes(kind)
self.info("nodes of kind %d" % (kind, ))
for node in nodes:
self.info(node.name)
got = 1
if got:
return self.passed("got nodes")
else:
return self.failed("no nodes!")
class NodeChildren(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("NodeNew")]
def test_method(self):
got = 0
mod = SMI.get_module("TCP-MIB")
scalars = list(mod.get_scalars())
table = mod.get_tables().next()
for child in table.get_children():
self.verboseinfo(child)
got += 1
if got:
self.config.testtable = table
self.config.testchild = child
return self.passed("got %d children" % (got, ))
else:
return self.failed("no children!")
class NodeType(SMIBaseTest):
PREREQUISITES = [qatest.PreReq("NodeChildren")]
def test_method(self):
child = self.config.testchild.get_children().next()
del self.config.testchild # last test deletes the node!
t = child.get_type()
self.verboseinfo(t)
self.info("NamedNumbers:")
got = 0
for nn in t.get_named_numbers():
self.info(nn)
got += 1
if got:
return self.passed("got %d named numbers" % (got, ))
else:
return self.failed("did not get any named numbers")
