def test(dest, connection, identifynode, n, verbose) :
    marks = set()
    if identifynode :
        import getUnderTestAlias
        dest, otherNodeId = getUnderTestAlias.get(0x123, None, verbose)

    if n == 0 :
        while dest >= 0 : 
            dest = once(dest, connection, identifynode, verbose, marks)
    else :
        for i in range(n) :
            dest = once(dest, connection, identifynode, verbose, marks)
            if dest < 0 : return -dest
    
    if verbose : 
        print "covered", len(marks), "of 4095 in",n,"attempts"
    return 0
def test(dest, connection, identifynode, n, verbose):
    marks = set()
    if identifynode:
        import getUnderTestAlias
        dest, otherNodeId = getUnderTestAlias.get(0x123, None, verbose)

    if n == 0:
        while dest >= 0:
            dest = once(dest, connection, identifynode, verbose, marks)
    else:
        for i in range(n):
            dest = once(dest, connection, identifynode, verbose, marks)
            if dest < 0: return -dest

    if verbose:
        print "covered", len(marks), "of 4095 in", n, "attempts"
    return 0
예제 #3
0
    for opt, arg in opts:
        if opt == "-v":
            verbose = True
        elif opt == "-V" :
            connection.network.verbose = True
            verbose = True
        elif opt in ("-a", "--alias"):  # needs hex processing
            alias = int(arg)
        elif opt in ("-d", "--dest"):  # needs hex processing
            dest = int(arg)
        elif opt in ("-c", "--content"):
            content = canolcbutils.splitSequence(arg)
        elif opt == "-t":
            identifynode = True
        else:
            assert False, "unhandled option"

    if identifynode :
        import getUnderTestAlias
        dest, nodeID = getUnderTestAlias.get(alias, None, verbose)
    
    retval = test(alias, dest, content, connection, verbose)
    connection.network.close()
    exit(retval)
    
def test(alias, dest, content, connection, verbose) :    
    return sendOneDatagram(alias, dest, content, connection, verbose)

if __name__ == '__main__':
    main()
예제 #4
0
            connection.network.verbose = True
            verbose = True
        elif opt in ("-a", "--alias"):  # needs hex processing
            alias = int(arg)
        elif opt in ("-d", "--dest"):  # needs hex processing
            dest = int(arg)
        elif opt in ("-n", "--node"):
            nodeID = canolcbutils.splitSequence(arg)
        elif opt == "-t":
            identifynode = True
        else:
            assert False, "unhandled option"

    if identifynode:
        import getUnderTestAlias
        dest, otherNodeId = getUnderTestAlias.get(alias, None, verbose)
        if nodeID == None: nodeID = otherNodeId

    retval = test(alias, dest, nodeID, connection, verbose)
    connection.network.close()
    exit(retval)


def test(alias, dest, nodeID, connection, verbose):
    # send correct address, correct node ID in body
    connection.network.send(makeframe(alias, dest, nodeID))
    reply = connection.network.receive()
    if (reply == None):
        print "Expected reply to correct alias & correct ID not received"
        return 2
    elif not reply.startswith(":X19170"):
예제 #5
0
            connection.network.verbose = True
            verbose = True
        elif opt in ("-a", "--alias"): # needs hex processing
            alias = int(arg)
        elif opt in ("-d", "--dest"): # needs hex processing
            dest = int(arg)
        elif opt in ("-n", "--node"):
            nodeID = canolcbutils.splitSequence(arg)
        elif opt == "-t":
            identifynode = True
        else:
            assert False, "unhandled option"

    if identifynode :
        import getUnderTestAlias
        dest, otherNodeId = getUnderTestAlias.get(alias, None, verbose)
        if nodeID == None : nodeID = otherNodeId

    retval = test(alias, dest, nodeID, connection, verbose)
    connection.network.close()
    exit(retval)
    
def test(alias, dest, nodeID, connection, verbose) :
    # send correct address, correct node ID in body
    connection.network.send(makeframe(alias, dest, nodeID))
    reply = connection.network.receive()
    if (reply == None ) : 
        print "Expected reply to correct alias & correct ID not received"
        return 2
    elif not reply.startswith(":X19170") :
        print "Unexpected reply received ", reply
예제 #6
0
파일: allTest.py 프로젝트: kphannan/OpenLCB
def test(alias, dest, nodeID, event, connection, verbose, complete, repeat, identifynode, bufnum):

    result = 0;
    
    while True :

        if identifynode :
            import getUnderTestAlias
            dest, nodeID = getUnderTestAlias.get(alias, None, verbose)

        import aliasMapEnquiry
        if verbose : print "aliasMapEnquiry"
        retval = aliasMapEnquiry.test(alias, nodeID, connection, verbose)
        if retval != 0 :
            print "Error in aliasMapEnquiry"
            if not complete : done(retval)
            result |= retval
    
        import verifyNodeGlobal
        if verbose : print "verifyNodeGlobal w no NodeID"
        retval = verifyNodeGlobal.test(alias, None, connection)
        if retval != 0 :
            print "Error in verifyNodeGlobal w no NodeID"
            if not complete : done(retval)
            result |= retval
        if verbose : print "verifyNodeGlobal with NodeID"
        retval = verifyNodeGlobal.test(alias, nodeID, connection)
        if retval != 0 :
            print "Error in verifyNodeGlobal w NodeID"
            if not complete : done(retval)
            result |= retval
    
        import verifyNodeAddressed
        if verbose : print "verifyNodeAddressed"
        retval = verifyNodeAddressed.test(alias, dest, nodeID, connection, verbose)
        if retval != 0 :
            print "Error in verifyNodeAddressed"
            if not complete : done(retval)
            result |= retval
    
        import protocolIdentProtocol
        if verbose : print "protocolIdentProtocol"
        retval = protocolIdentProtocol.test(alias, dest, connection, verbose)
        if retval != 0 :
            print "Error in protocolIdentProtocol"
            if not complete : done(retval)
            result |= retval
    
        import identifyEventsGlobal
        if verbose : print "identifyEventsGlobal"
        retval = identifyEventsGlobal.test(alias, connection, verbose)
        if retval != 0 :
            print "Error in identifyEventsGlobal"
            if not complete : done(retval)
            result |= retval
    
        import identifyEventsAddressed
        if verbose : print "identifyEventsAddressed"
        retval = identifyEventsAddressed.test(alias, dest, connection, verbose)
        if retval != 0 :
            print "Error in identifyEventsAddressed"
            if not complete : done(retval)
            result |= retval
    
        import identifyConsumers
        if verbose : print "identifyConsumers"
        retval = identifyConsumers.test(alias, event, connection, verbose)
        if retval != 0 :
            print "Error in identifyConsumers"
            if not complete : done(retval)
            result |= retval
    
        import identifyProducers
        if verbose : print "identifyProducers"
        retval = identifyProducers.test(alias, event, connection, verbose)
        if retval != 0 :
            print "Error in identifyProducers"
            if not complete : done(retval)
            result |= retval
    
        import testProducerConsumerNotification
        if verbose : print "testProducerConsumerNotification"
        retval = testProducerConsumerNotification.test(alias, dest, connection, verbose)
        if retval != 0 :
            print "Error in testProducerConsumerNotification"
            if not complete : done(retval)
            result |= retval
    
        import testConfigurationProtocol
        if verbose : print "testConfigurationProtocol"
        retval = testConfigurationProtocol.test(alias, dest, connection, verbose)
        if retval != 0 :
            print "Error in testConfigurationProtocol", retval
            if not complete : done(retval)
            result |= retval
    
        import testDatagram
        if verbose : print "testDatagram"
        retval = testDatagram.test(alias, dest, connection, bufnum, verbose)
        if retval != 0 :
            print "Error in testDatagram", retval
            if not complete : done(retval)
            result |= retval
        
        import testOverlappingDatagrams
        if verbose : print "testOverlappingDatagrams"
        retval = testOverlappingDatagrams.test(alias, dest, bufnum, connection, verbose)
        if retval != 0 :
            print "Error in testOverlappingDatagrams", retval
            if not complete : done(retval)
            result |= retval

        import simpleNodeIdentificationInformation
        if verbose : print "simpleNodeIdentificationInformation"
        retval = simpleNodeIdentificationInformation.test(alias, dest, connection, verbose)
        if retval != 0 :
            print "Error in simpleNodeIdentificationInformation"
            if not complete : done(retval)
            result |= retval
        
        import testCDI
        if verbose : print "testCDI"
        retval = testCDI.test(alias, dest, connection, verbose)
        if retval != 0 :
            print "Error in testCDI"
            if not complete : done(retval)
            result |= retval
        
        import testReservedBits
        if verbose : print "testReservedBits"
        retval = testReservedBits.test(alias, nodeID, dest, connection, verbose)
        if retval != 0 :
            print "Error in testReservedBits"
            if not complete : done(retval)
            result |= retval        
        
        import unknownDatagramType
        if verbose : print "unknownDatagramType"
        retval = unknownDatagramType.test(alias, dest, connection, verbose)
        if retval != 0 :
            print "Error in unknownDatagramType"
            if not complete : done(retval)
            result |= retval
        
        import unknownMtiAddressed
        if verbose : print "unknownMtiAddressed"
        retval = unknownMtiAddressed.test(alias, dest, connection, verbose)
        if retval != 0 :
            print "Error in unknownMtiAddressed"
            if not complete : done(retval)
            result |= retval
        
        import testStandardFrame
        import time
        if verbose : print "testStandardFrame"
        retval = testStandardFrame.test(connection, verbose)
        if retval != 0 :
            print "Error in testStandardFrame"
            if not complete : done(retval)
            result |= retval
        time.sleep(3)
 
        # done last, as changes alias in use
        import testAliasConflict
        if verbose : print "testAliasConflict"
        retval = testAliasConflict.test(alias, dest, connection, verbose)
        if retval != 0 :
            print "Error in testAliasConflict"
            if not complete : done(retval)
            result |= retval

        if not repeat : break
        if verbose : print "End of pass, repeat"
        if verbose : print ""
        
    if verbose : print "Note: Did not perform testStartup, which is manual"
    if verbose : print "Note: Did not perform testForZeroAlias.py, which is slow"
    if verbose :
        if result != 0 : print "Encountered errors"
        else : print "Normal end"
예제 #7
0
def test(alias, dest, nodeID, event, connection, verbose, complete, repeat,
         identifynode, bufnum):

    result = 0

    while True:

        if identifynode:
            import getUnderTestAlias
            dest, nodeID = getUnderTestAlias.get(alias, None, verbose)

        import aliasMapEnquiry
        if verbose: print "aliasMapEnquiry"
        retval = aliasMapEnquiry.test(alias, nodeID, connection, verbose)
        if retval != 0:
            print "Error in aliasMapEnquiry"
            if not complete: done(retval)
            result |= retval

        import verifyNodeGlobal
        if verbose: print "verifyNodeGlobal w no NodeID"
        retval = verifyNodeGlobal.test(alias, None, connection)
        if retval != 0:
            print "Error in verifyNodeGlobal w no NodeID"
            if not complete: done(retval)
            result |= retval
        if verbose: print "verifyNodeGlobal with NodeID"
        retval = verifyNodeGlobal.test(alias, nodeID, connection)
        if retval != 0:
            print "Error in verifyNodeGlobal w NodeID"
            if not complete: done(retval)
            result |= retval

        import verifyNodeAddressed
        if verbose: print "verifyNodeAddressed"
        retval = verifyNodeAddressed.test(alias, dest, nodeID, connection,
                                          verbose)
        if retval != 0:
            print "Error in verifyNodeAddressed"
            if not complete: done(retval)
            result |= retval

        import protocolIdentProtocol
        if verbose: print "protocolIdentProtocol"
        retval = protocolIdentProtocol.test(alias, dest, connection, verbose)
        if retval != 0:
            print "Error in protocolIdentProtocol"
            if not complete: done(retval)
            result |= retval

        import identifyEventsGlobal
        if verbose: print "identifyEventsGlobal"
        retval = identifyEventsGlobal.test(alias, connection, verbose)
        if retval != 0:
            print "Error in identifyEventsGlobal"
            if not complete: done(retval)
            result |= retval

        import identifyEventsAddressed
        if verbose: print "identifyEventsAddressed"
        retval = identifyEventsAddressed.test(alias, dest, connection, verbose)
        if retval != 0:
            print "Error in identifyEventsAddressed"
            if not complete: done(retval)
            result |= retval

        import identifyConsumers
        if verbose: print "identifyConsumers"
        retval = identifyConsumers.test(alias, event, connection, verbose)
        if retval != 0:
            print "Error in identifyConsumers"
            if not complete: done(retval)
            result |= retval

        import identifyProducers
        if verbose: print "identifyProducers"
        retval = identifyProducers.test(alias, event, connection, verbose)
        if retval != 0:
            print "Error in identifyProducers"
            if not complete: done(retval)
            result |= retval

        import testProducerConsumerNotification
        if verbose: print "testProducerConsumerNotification"
        retval = testProducerConsumerNotification.test(alias, dest, connection,
                                                       verbose)
        if retval != 0:
            print "Error in testProducerConsumerNotification"
            if not complete: done(retval)
            result |= retval

        import testConfigurationProtocol
        if verbose: print "testConfigurationProtocol"
        retval = testConfigurationProtocol.test(alias, dest, connection,
                                                verbose)
        if retval != 0:
            print "Error in testConfigurationProtocol", retval
            if not complete: done(retval)
            result |= retval

        import testDatagram
        if verbose: print "testDatagram"
        retval = testDatagram.test(alias, dest, connection, bufnum, verbose)
        if retval != 0:
            print "Error in testDatagram", retval
            if not complete: done(retval)
            result |= retval

        import testOverlappingDatagrams
        if verbose: print "testOverlappingDatagrams"
        retval = testOverlappingDatagrams.test(alias, dest, bufnum, connection,
                                               verbose)
        if retval != 0:
            print "Error in testOverlappingDatagrams", retval
            if not complete: done(retval)
            result |= retval

        import simpleNodeIdentificationInformation
        if verbose: print "simpleNodeIdentificationInformation"
        retval = simpleNodeIdentificationInformation.test(
            alias, dest, connection, verbose)
        if retval != 0:
            print "Error in simpleNodeIdentificationInformation"
            if not complete: done(retval)
            result |= retval

        import testCDI
        if verbose: print "testCDI"
        retval = testCDI.test(alias, dest, connection, verbose)
        if retval != 0:
            print "Error in testCDI"
            if not complete: done(retval)
            result |= retval

        import testReservedBits
        if verbose: print "testReservedBits"
        retval = testReservedBits.test(alias, nodeID, dest, connection,
                                       verbose)
        if retval != 0:
            print "Error in testReservedBits"
            if not complete: done(retval)
            result |= retval

        import unknownDatagramType
        if verbose: print "unknownDatagramType"
        retval = unknownDatagramType.test(alias, dest, connection, verbose)
        if retval != 0:
            print "Error in unknownDatagramType"
            if not complete: done(retval)
            result |= retval

        import unknownMtiAddressed
        if verbose: print "unknownMtiAddressed"
        retval = unknownMtiAddressed.test(alias, dest, connection, verbose)
        if retval != 0:
            print "Error in unknownMtiAddressed"
            if not complete: done(retval)
            result |= retval

        import testStandardFrame
        import time
        if verbose: print "testStandardFrame"
        retval = testStandardFrame.test(connection, verbose)
        if retval != 0:
            print "Error in testStandardFrame"
            if not complete: done(retval)
            result |= retval
        time.sleep(3)

        # done last, as changes alias in use
        import testAliasConflict
        if verbose: print "testAliasConflict"
        retval = testAliasConflict.test(alias, dest, connection, verbose)
        if retval != 0:
            print "Error in testAliasConflict"
            if not complete: done(retval)
            result |= retval

        if not repeat: break
        if verbose: print "End of pass, repeat"
        if verbose: print ""

    if verbose: print "Note: Did not perform testStartup, which is manual"
    if verbose:
        print "Note: Did not perform testForZeroAlias.py, which is slow"
    if verbose:
        if result != 0: print "Encountered errors"
        else: print "Normal end"