gtress

#! /usr/bin/env python

import sys
import os
import threading
from types import *

try:
	import subprocess
except:
	print "Importing `subprocess' module failed!"
	sys.exit( 1 )

try:
	import csv
except:
	print "Importing `csv' module failed!"
	sys.exit( 1 )

try:
	import pygtk
	pygtk.require( "2.0" )
	import pango
	import gobject
	import gtk
except:
	print "GTK/Pango/Glade not availible!"
	sys.exit( 1 )

class SuiteList:
	def __init__( self, path_ ):
		self._suites = {}
		self._candidates = {}
		self._path = path_
		try:
			csvreader = csv.reader( open( self._path, "rb" ), delimiter = ';' )
			for row in csvreader:
				self._candidates[ row[0] ] = 0 # row[1]
		except:
			pass
	def __del__( self ):
		self.save()
	def save( self ):
		csvwriter = csv.writer( open( self._path, "wb" ), delimiter = ';' )
		csvwriter.writerows( map( lambda e: [ e ], sorted( self._suites.keys() ) ) )
	def set_suite( self, suite_, enabled_, tests_ ):
		if enabled_:
			self._suites[ suite_ ] = tests_
		elif suite_ in self._suites:
			del self._suites[ suite_ ]
	def was_enabled( self, suite_ ):
		return suite_ in self._candidates
	def is_enabled( self, suite_ ):
		return suite_ in self._suites

def run_tests( gtress_, jobs_ ):
	try:
		gtress_._child = subprocess.Popen( [ "./build/debug/tress/1exec", "-j", str( jobs_ ), "-F", gtress_._suiteList._path ], bufsize = 0, stdout = os.open( os.devnull, os.O_RDWR ), stderr = subprocess.PIPE )
		stderr = gtress_._child.stderr
		while True:
			line = stderr.readline()
			if line == "":
				break;
			print line.lstrip( " \t" ).strip( "\n" )
			fields = map( lambda s : s.lstrip( " \t" ).strip( " \t" ), line.split( ": " ) )
			if gtress_._suiteList.is_enabled( fields[0] ):
				passed = fields[1].count( "." ) + fields[1].count( "," )
				failed = fields[1].count( "[" )
				gobject.idle_add( gtress_.update_passed, fields[0], passed, failed )
	finally:
		if gtress_._child != None:
			gtress_._child.wait()
	gtress_._child = None

class GTress:
	def __init__( self, suiteList_ ):
		self._child = None
		self._thread = None
		self._suiteList = suiteList_
		self._currentFilter = ""
		self._suiteMap = {}
		gtk.gdk.threads_init()
		self._gui = gtk.Builder()
		self._gui.add_from_file( "gtress.ui" )
		self._list = self._gui.get_object( "GUI_LIST" )
		self._data = gtk.ListStore( str, int, bool, int, int, gtk.gdk.Color, str )
		self._filter = self._data.filter_new()
		self._filter.set_visible_func( self.apply_filter )
		self._listSuiteNameColumn = gtk.TreeViewColumn( "suite names" )
		self._listSuiteNameCellRenderer = gtk.CellRendererText()
		self._listSuiteNameColumn.pack_start( self._listSuiteNameCellRenderer, True )
		self._listSuiteNameColumn.add_attribute( self._listSuiteNameCellRenderer, "text", 0 )
		self._listSuiteNameColumn.add_attribute( self._listSuiteNameCellRenderer, "background-gdk", 5 )
		self._listSuiteNameColumn.set_sizing( gtk.TREE_VIEW_COLUMN_AUTOSIZE )
		self._listSuiteNameColumn.set_resizable( True )
		self._listSuiteNameColumn.set_expand( True )

		self._listTestCountColumn = gtk.TreeViewColumn( "test count" )
		self._listTestCountCellRenderer = gtk.CellRendererText()
		self._listTestCountCellRenderer.set_property( "xalign", 1 )
		self._listTestCountCellRenderer.set_property( "xpad", 8 )
		self._listTestCountColumn.pack_start( self._listTestCountCellRenderer, True )
		self._listTestCountColumn.add_attribute( self._listTestCountCellRenderer, "text", 1 )
		self._listTestCountColumn.add_attribute( self._listTestCountCellRenderer, "background-gdk", 5 )
		self._listTestCountColumn.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
		self._listTestCountColumn.set_fixed_width( 80 )
		self._listTestCountColumn.set_resizable( False )
		self._listTestCountColumn.set_expand( False )

		self._listSuiteEnabledColumn = gtk.TreeViewColumn( "enabled" )
		self._listSuiteEnabledCellRenderer = gtk.CellRendererToggle()
		self._listSuiteEnabledCellRenderer.set_property( "activatable", True )
		self._listSuiteEnabledCellRenderer.set_property( "xalign", 0.5 )
		self._listSuiteEnabledColumn.pack_start( self._listSuiteEnabledCellRenderer, True )
		self._listSuiteEnabledColumn.add_attribute( self._listSuiteEnabledCellRenderer, "active", 2 )
		self._listSuiteEnabledColumn.add_attribute( self._listSuiteEnabledCellRenderer, "cell-background-gdk", 5 )
		self._listSuiteEnabledCellRenderer.connect( "toggled", self.col2_toggled_cb, self._filter )
		self._listSuiteEnabledColumn.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
		self._listSuiteEnabledColumn.set_fixed_width( 64 )
		self._listSuiteEnabledColumn.set_resizable( False )
		self._listSuiteEnabledColumn.set_expand( False )

		self._listPassedColumn = gtk.TreeViewColumn( "passed" )
		self._listPassedCellRenderer = gtk.CellRendererText()
		self._listPassedCellRenderer.set_property( "xalign", 1 )
		self._listPassedCellRenderer.set_property( "xpad", 8 )
		self._listPassedColumn.pack_start( self._listPassedCellRenderer, True )
		self._listPassedColumn.add_attribute( self._listPassedCellRenderer, "text", 3 )
		self._listPassedColumn.add_attribute( self._listPassedCellRenderer, "background-gdk", 5 )
		self._listPassedColumn.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
		self._listPassedColumn.set_fixed_width( 80 )
		self._listPassedColumn.set_resizable( False )
		self._listPassedColumn.set_expand( False )

		self._listFailedColumn = gtk.TreeViewColumn( "failed" )
		self._listFailedCellRenderer = gtk.CellRendererText()
		self._listFailedCellRenderer.set_property( "xalign", 1 )
		self._listFailedCellRenderer.set_property( "xpad", 8 )
		self._listFailedColumn.pack_start( self._listFailedCellRenderer, True )
		self._listFailedColumn.add_attribute( self._listFailedCellRenderer, "text", 4 )
		self._listFailedColumn.add_attribute( self._listFailedCellRenderer, "background-gdk", 5 )
		self._listFailedColumn.set_sizing( gtk.TREE_VIEW_COLUMN_FIXED )
		self._listFailedColumn.set_fixed_width( 80 )
		self._listFailedColumn.set_resizable( False )
		self._listFailedColumn.set_expand( False )

		self._list.append_column( self._listSuiteNameColumn )
		self._list.append_column( self._listTestCountColumn )
		self._list.append_column( self._listSuiteEnabledColumn )
		self._list.append_column( self._listPassedColumn )
		self._list.append_column( self._listFailedColumn )
		self._list.get_selection().set_mode( gtk.SELECTION_MULTIPLE )
		self._list.set_model( self._filter )
		self._list.set_tooltip_column( 6 )
		self._filterEdit = self._gui.get_object( "GUI_NAME_FILTER" )
		self._gui.get_object( "GUI_QUIT" ).connect( "clicked", self.destroy )
		self._jobs = self._gui.get_object( "GUI_JOBS" )
		self._all = self._gui.get_object( "GUI_ALL" )
		self._gui.connect_signals( self )

		self._child = subprocess.Popen( [ "./build/debug/tress/1exec", "-L", "-v" ], stdout = subprocess.PIPE )
		tests = self._child.stdout
		totalTests = 0
		totalSuites = 0
		suiteNo = 0
		for line in tests.readlines():
			fields = line.lstrip( " \t" ).strip( "\n" ).split()
			if ( fields[0] != "setup._argc" ) and ( fields[0] != "setup._argv[0]" ) and ( fields[0] != "total" ):
				wasEnabled = self._suiteList.was_enabled( fields[0] )
				if wasEnabled:
					totalTests += int( fields[1] )
					totalSuites += 1
				self._data.append( [ fields[0], int( fields[1] ), wasEnabled, 0, 0, gtk.gdk.Color( 65535, 65535, 65535 ), None ] )
				self._suiteList.set_suite( fields[0], wasEnabled, fields[1] )
				self._suiteMap[fields[0]] = suiteNo
				suiteNo += 1
		self._child.wait()
		self._child = None
		self._totalTestCount = self._gui.get_object( "GUI_TOTAL_TEST_COUNT" )
		self._totalEnabledSuites = self._gui.get_object( "GUI_TOTAL_ENABLED_SUITES" )
		self._passed = self._gui.get_object( "GUI_PASSED" )
		self._failed = self._gui.get_object( "GUI_FAILED" )
		self._progress = self._gui.get_object( "GUI_PROGRESS" )
		self._okStyle = self._progress.get_style().copy()
		self._failStyle = self._okStyle.copy()
		self._failColor = gtk.gdk.Color( 65535, 40000, 40000 )
		self._failStyle.bg[gtk.STATE_NORMAL] = self._failColor
		self._totalTestCount.set_text( str( totalTests ) )
		self._totalEnabledSuites.set_text( str( totalSuites ) )

	def update_passed( self, suite_, passed_, failed_ ):
		self._data[self._suiteMap[suite_]][3] += passed_
		self._data[self._suiteMap[suite_]][4] += failed_
		if ( failed_ > 0 ):
			self._data[self._suiteMap[suite_]][5] = self._failColor
			self._progress.set_style( self._failStyle )
		passed = int( self._passed.get_text() ) + passed_
		failed = int( self._failed.get_text() ) + failed_ 
		self._passed.set_text( str( passed ) )
		self._failed.set_text( str( failed ) )
		total = float( self._totalTestCount.get_text() )
		self._progress.set_fraction( passed / total )

	def col2_toggled_cb( self, cell, path_, model ):
		path = self._filter.convert_path_to_child_path( path_ )
		on = self._data[path][2] = not model[path_][2]
		self._all.set_inconsistent( True )
		totalModified = model[path_][1]
		suite = 1
		if ( not on ):
			totalModified = -totalModified
			suite = -suite;
		self._totalTestCount.set_text( str( int( self._totalTestCount.get_text() ) + totalModified ) )
		self._totalEnabledSuites.set_text( str( int( self._totalEnabledSuites.get_text() ) + suite ) )
		return

	def all_toggled( self, toggle_ ):
		toggle_.set_inconsistent( False )
		all = toggle_.get_active()
		i = self._filter.get_iter_first()
		totalModified = 0
		suite = 0
		while i != None:
			if self._data[self._filter.convert_iter_to_child_iter( i )][2] != all:
				totalModified += self._data[self._filter.convert_iter_to_child_iter( i )][1]
				suite += 1
			self._data[self._filter.convert_iter_to_child_iter( i )][2] = all
			i = self._filter.iter_next( i )
		if ( not all ):
			totalModified = -totalModified
			suite = -suite;
		self._totalTestCount.set_text( str( int( self._totalTestCount.get_text() ) + totalModified ) )
		self._totalEnabledSuites.set_text( str( int( self._totalEnabledSuites.get_text() ) + suite ) )

	def apply_filter( self, model_, iter_ ):
		visible = ( type( model_[iter_][0] ) != NoneType ) and ( model_[iter_][0].find( self._currentFilter ) >= 0 )
		return visible

	def filter_changed( self, edit_ ):
		self._currentFilter = edit_.get_text()
		self._filter.refilter()

	def clear_filter( self, button_ ):
		self._all.set_inconsistent( True )
		self._currentFilter = ""
		self._filterEdit.set_text( self._currentFilter )
		self._filter.refilter()

	def update_suite_list( self ):
		for row in self._data:
			self._suiteList.set_suite( row[0], row[2], row[1] )

	def run( self, button_ ):
		self.update_suite_list()
		self._suiteList.save()
		if self._thread != None:
			self._thread.join()
			self._thread = None
		for row in self._data:
			row[3] = 0
			row[4] = 0
			row[5] = gtk.gdk.Color( 65535, 65535, 65535 )
			row[6] = None
		self._progress.set_style( self._okStyle )
		self._passed.set_text( "0" )
		self._failed.set_text( "0" )
		self._thread = threading.Thread( target = run_tests, args = [self, self._jobs.get_value()] )
		self._thread.start()

	def main( self ):
		gtk.main()

	def delete_event( self, widget, data = None ):
		return False

	def destroy( self, widget, data = None ):
		if self._thread != None:
			self._thread.join()
			self._thread = None
		if self._child != None:
			self._child.wait()
		self.update_suite_list()
		gtk.main_quit()
	
	def __del__( self ):
		pass

if __name__ == "__main__":
	suiteList = SuiteList( "tress.suites" )
	gtress = GTress( suiteList )
	gtress.main()
	suiteList.save()