def execute( self ):
        " Should return True if the execution completed successfully "
        self.fromScratch()
        jobID1 = self.ns.submitJob(  'TEST', 'bla', '', '222', '', '' )

        ns_client = self.getNetScheduleService( 'TEST', 'scenario1701' )
        ns_client.set_client_identification( 'node', 'session' )
        ns_client.on_warning = self.report_warning

        j1 = self.ns.getJob( 'TEST' )
        self.ns.putJob( 'TEST', j1[ 0 ], j1[ 1 ], 0 )

        output = execAny( ns_client, 'READ2 reader_aff=0 any_aff=1 group=111,333' )
        if output != "no_more_jobs=true":
            raise Exception( "Expected no job, received some: " + output )

        output = execAny( ns_client, 'READ2 reader_aff=0 any_aff=1 group=111,222' )
        if output == "":
            raise Exception( "Expected a job, got nothing" )

        values = parse_qs( output, True, True )
        receivedJobID = values[ 'job_key' ][ 0 ]
        if receivedJobID != jobID1:
            raise Exception( "Expected: " + jobID1 + ", got: " + output )
        return True

    def execute( self ):
        " Should return True if the execution completed successfully "
        self.fromScratch()

        jobID = self.ns.submitJob( 'TEST', 'bla', '', '', '', '' )

        ns_client = self.getNetScheduleService( 'TEST', 'scenario301' )

        output = execAny( ns_client, 'SST2 ' + jobID )
        values = parse_qs( output, True, True )
        if values[ 'job_status' ] != ['Pending'] or \
           values.has_key( 'job_exptime' ) == False:
            raise Exception( "Unexpected SST2 output" )

        time1 = int( values[ 'job_exptime' ][ 0 ] )
        time.sleep( 5 )

        output = execAny( ns_client, 'SST2 ' + jobID )
        values = parse_qs( output, True, True )
        time2 = int( values[ 'job_exptime' ][ 0 ] )

        if time2 - time1 < 3:
            raise Exception( "SST2 does not change the job "
                             "expiration while it must" )

        return True

    def execute( self ):
        " Should return True if the execution completed successfully "
        self.fromScratch( 4 )

        # Client #2 plays a passive role of holding an affinity (a2)
        ns_client2 = self.getNetScheduleService( 'TEST', 'scenario400' )
        ns_client2.set_client_identification( 'node2', 'session2' )
        changeAffinity( ns_client2, [ 'a2' ], [] )
        jobID = self.ns.submitJob( 'TEST', 'bla', 'a2' )


        ns_client1 = self.getNetScheduleService( 'TEST', 'scenario400' )
        ns_client1.set_client_identification( 'node1', 'session1' )
        changeAffinity( ns_client1, [ 'a1' ], [] )

        output = execAny( ns_client1,
                          'GET2 wnode_aff=1 any_aff=0 exclusive_new_aff=1' )
        if output != '':
            raise Exception( "Expected no job, received: '" + output + "'" )

        # 10 seconds till the job becomes obsolete
        time.sleep( 12 )

        output = execAny( ns_client1,
                          'GET2 wnode_aff=1 any_aff=0 exclusive_new_aff=1' )
        if "job_key=" + jobID not in output:
            raise Exception( "Expected a job, received: '" + output + "'" )

        return True

    def execute( self ):
        " Should return True if the execution completed successfully "
        self.fromScratch()

        jobID = self.ns.submitJob( 'TEST', 'bla' )

        # Start listening
        port = self.ns.getPort() + 2 
        sock = socket.socket( socket.AF_INET, # Internet
                              socket.SOCK_DGRAM ) # UDP
        sock.bind( ( "" , port ) )

        ns_client = self.getNetScheduleService( 'TEST', 'scenario502' )
        ns_client.set_client_identification( 'mynode', 'mysession' )
        execAny( ns_client, 'LISTEN ' + jobID + " " + str( port ) + " 30")

        # Main job loop
        jobID, authToken, attrs, jobInput = self.ns.getJob( "TEST", -1, '', '',
                                                           "node1", "session1" )
        self.ns.returnJob( 'TEST', jobID, authToken )
        jobID, authToken, attrs, jobInput = self.ns.getJob( "TEST", -1, '', '',
                                                           "node2", "session2" )
        self.ns.putJob( 'TEST', jobID, authToken, 0, out = "my output" )
        jobID, state, passport = self.ns.getJobsForReading2( 'TEST', -1, "",
                                                           'node3', 'session3' )
        time.sleep( 15 )

        # Receive from the socket
        time.sleep( 3 )
        notifications = ""
        while True:
            try:
                data = sock.recv( 16384, socket.MSG_DONTWAIT )
                if not data:
                    break
                if len( notifications ) != 0:
                    notifications += "\n"
                notifications += data
            except:
                break

        if "job_status=Running&last_event_index=1" not in notifications:
            raise Exception( "Did not receive job_status=Running&last_event_index=1" )
        if "job_status=Pending&last_event_index=2" not in notifications:
            raise Exception( "Did not receive job_status=Pending&last_event_index=2" )
        if "job_status=Running&last_event_index=3" not in notifications:
            raise Exception( "Did not receive job_status=Running&last_event_index=3" )
        if "job_status=Done&last_event_index=4" not in notifications:
            raise Exception( "Did not receive job_status=Done&last_event_index=4" )
        if "job_status=Reading&last_event_index=5" not in notifications:
            raise Exception( "Did not receive job_status=Reading&last_event_index=5" )
        if "job_status=Done&last_event_index=6" not in notifications:
            raise Exception( "Did not receive job_status=Done&last_event_index=6" )

        return True

    def execute( self ):
        " Should return True if the execution completed successfully "
        self.fromScratch()

        jobID = self.ns.submitJob( 'TEST', 'bla', 'a0' )

        # First client holds a0 affinity
        ns_client1 = self.getNetScheduleService( 'TEST', 'scenario308' )
        ns_client1.set_client_identification( 'node1', 'session1' )
        changeAffinity( ns_client1, [ 'a0' ], [] )

        # Second client holds a100 affinity
        ns_client2 = self.getNetScheduleService( 'TEST', 'scenario308' )
        ns_client2.set_client_identification( 'node2', 'session2' )
        changeAffinity( ns_client2, [ 'a100' ], [] )

        # Socket to receive notifications
        notifSocket = socket.socket( socket.AF_INET, socket.SOCK_DGRAM )
        notifSocket.bind( ( "", 9007 ) )

        # Second client tries to get the pending job - should get nothing
        output = execAny( ns_client2,
                          'GET2 wnode_aff=1 any_aff=0 exclusive_new_aff=1 port=9007 timeout=3' )
        if output != "":
            raise Exception( "Expect no jobs, received: " + output )

        time.sleep( 4 )
        try:
            # Exception is expected
            data = notifSocket.recv( 8192, socket.MSG_DONTWAIT )
            raise Exception( "Expected no notifications, received one: " + data )
        except Exception, exc:
            if "Resource temporarily unavailable" not in str( exc ):
                raise

    def execute(self):
        " Should return True if the execution completed successfully "
        self.fromScratch()

        jobID = self.ns.submitJob("TEST", "blah")

        ns_client = self.getNetScheduleService("", "scenario702")
        ns_client.set_client_identification("node1", "session1")

        output = execAny(ns_client, "SST " + jobID)
        if output != "0":
            raise Exception("Unexpected job state")

        # Try to submit a job without the queue
        try:
            output = execAny(ns_client, "SUBMIT blah")
        except Exception, exc:
            if "Job queue is required" in str(exc):
                return True
            raise