def run(self):
"""
@brief Consulta el proceso de ejecución de los testcases y obtiene
el log, actualizando la gui con el progreso de la misma.
"""
log.debug('Entrando en check analisis')
# Obtenemos el buffer de la interfaz
buffer = self.ui.gtk.get_object('proy_anl_log_text_buffer')
view = self.ui.gtk.get_object('proy_anl_log_text')
# Obtenemos la barra de la interfaz y su label
self.bar = self.ui.gtk.get_object('proy_anl_control_bar')
## Subproceso a comprobar
sproc = self.proy.anl_subproc
# Controlar el fin del subproceso
# poll es None si el proceso no ha terminado aún
end = sproc is None or sproc.poll() is not None
timer = \
Clock(label=self.ui.gtk.get_object('proy_anl_control_time_label'),
padre=sproc)
timer.start()
while not end:
# Dormir
time.sleep(self.t)
log.debug('Checking Analisis')
# ¿Ha terminado?
end = sproc.poll() is not None
# Leer de la tubería del proceso
while 1:
line = sproc.stdout.readline()
if not line :
break
# Filtrar la línea y actualizar la gui
self.filtrar(line)
# Añadimos la línea al buffer
try:
gtk.gdk.threads_enter()
iter = buffer.get_end_iter()
buffer.insert(iter, line)
view.scroll_to_mark(buffer.get_insert(), 0.1)
finally:
gtk.gdk.threads_leave()
# Al terminar el bucle, parar el reloj
timer.cancel()
# Tras el análisis copiar los invariantes a la carpeta de invariantes.
self.proy.anl_copiar_inv()
# Movernos a la siguiente pestaña y mostrarlos
try:
gtk.gdk.threads_enter()
self.ui.proyecto_notebook.next_page()
self.ui.inv_load_lastone()
# Cargar el tiempo que ha llevado
self.ui.inv_data_time.set_text(timer.stime())
finally:
gtk.gdk.threads_leave()
def run(self):
"""
@brief Consulta el proceso de ejecución de los testcases y obtiene
el log, actualizando la gui con el progreso de la misma.
"""
# Obtenemos el buffer de la interfaz
buffer = self.ui.ejec_log_buffer
view = self.ui.ejec_log_text
# self.ui.ejec_log_text.set_buffer(buffer)
#buffer = gtk.TextBuffer()
# Obtenemos el subproceso instanciado en el proyecto
subproc = self.proy.ejec_subproc
# Control para el término del proceso
# poll es None si el proceso no ha terminado aún.
end = subproc is None or subproc.poll() is not None
# Tiempo desde el comienzo de ejecución
# Ejecuta cada segundo la función time en un thread aparte
# Le pasamos el label que tiene que actualizar y lo arrancamos.
# también le pasamos el thread de ejecución para que quede ligado.
thread_timer = Clock(label=self.ui.ejec_control_tiempo_label, padre=subproc)
thread_timer.start()
# El subproceso debe existir y no haber terminado
while not end:
# Mandar a dormir para esperar
time.sleep(self.t)
log.debug("Comprobando Tests")
# Saber si el proceso ha terminado
end = subproc.poll() is not None
# Leer lo que haya en la tubería
while 1 :
line = subproc.stdout.readline()
if not line:
break
# Filtramos la linea y la procesamos
line = self.filtrar(line)
try:
gtk.gdk.threads_enter()
# La añadimos al final del buffer de texto
iter = buffer.get_end_iter()
buffer.place_cursor(iter)
buffer.insert(iter, line)
view.scroll_to_mark(buffer.get_insert(), 0.1)
#buffer.insert_at_cursor(line)
finally:
gtk.gdk.threads_leave()
# Parar el reloj
thread_timer.cancel()
# Asegurarnos de que se termina la ejecución
# y actualizar la gui en consecuencia.
gtk.gdk.threads_enter()
self.ui.ejec_terminar()
gtk.gdk.threads_leave()
