1

"Commons definitions for sikuli based beremiz IDE GUI tests"

     2

     3

import os

     4

import sys

     5

import subprocess

     6

from threading import Thread, Event

     7

from sikuli import *

     8

     9

home = os.environ["HOME"]

    10

beremiz_path = os.environ["BEREMIZPATH"]

    12

    13

opj = os.path.join

    14

    15

    16

def StartBeremizApp(projectpath=None, exemple=None):

    17

    """

    18

    Starts Beremiz IDE, waits for main window to appear, maximize it.

    19

    20

        Parameters: 

    21

            projectpath (str): path to project to open

    22

            exemple (str): path relative to exemples directory

    23

    24

        Returns:

    25

            Sikuli App class instance

    26

    """

    27

    29

    30

    if exemple is not None:

    31

        command.append(opj(beremiz_path,"exemples",exemple))

    32

    elif projectpath is not None:

    33

        command.append(projectpath)

    34

    35

    # App class is broken in Sikuli 2.0.5: can't start process with arguments.

    36

    # 

    37

    # Workaround : - use subprocess module to spawn IDE process,

    38

    #              - use wmctrl to find IDE window details and maximize it

    39

    #              - pass exact window title to App class constructor

    40

    41

    proc = subprocess.Popen(command, stdout=subprocess.PIPE, bufsize=0)

    42

    43

    # Window are macthed against process' PID

    44

    ppid = proc.pid

    45

    46

    # Timeout 5s

    47

    c = 50

    48

    while c > 0:

    49

        # equiv to "wmctrl -l -p | grep $pid"

    50

        try:

    51

            wlist = filter(lambda l:(len(l)>2 and l[2]==str(ppid)), map(lambda s:s.split(None,4), subprocess.check_output(["wmctrl", "-l", "-p"]).splitlines()))

    52

        except subprocess.CalledProcessError:

    53

            wlist = []

    54

    55

        # window with no title only has 4 fields do describe it

    56

        # beremiz splashcreen has no title

    57

        # wait until main window is visible

    58

        if len(wlist) == 1 and len(wlist[0]) == 5:

    59

            windowID,_zero,wpid,_XID,wtitle = wlist[0] 

    60

            break

    61

    62

        wait(0.1)

    63

        c = c - 1

    64

    65

    if c == 0:

    66

        raise Exception("Couldn't find Beremiz window")

    67

    68

    # Maximize window x and y

    69

    subprocess.check_call(["wmctrl", "-i", "-r", windowID, "-b", "add,maximized_vert,maximized_horz"])

    70

    71

    # switchApp creates an App object by finding window by title, is not supposed to spawn a process

    72

    return proc, switchApp(wtitle)

    73

    74

class KBDShortcut:

    75

    """Send shortut to app by calling corresponding methods:

    76

          Stop   

    77

          Run    

    78

          Transfer

    79

          Connect

    80

          Clean  

    81

          Build  

    82

    83

    example:

    84

        k = KBDShortcut(app)

    85

        k.Clean()

    86

    """

    87

    88

    fkeys = {"Stop":     Key.F4,

    89

             "Run":      Key.F5,

    90

             "Transfer": Key.F6,

    91

             "Connect":  Key.F7,

    92

             "Clean":    Key.F9,

    93

             "Build":    Key.F11}

    94

    95

    def __init__(self, app):

    96

        self.app = app

    97

    98

    def __getattr__(self, name):

    99

        fkey = self.fkeys[name]

   100

        app = self.app

   101

   102

        def PressShortCut():

   103

            app.focus()

   104

            type(fkey)

   105

   106

        return PressShortCut

   107

   108

   109

class IDEIdleObserver:

   110

    "Detects when IDE is idle. This is particularly handy when staring an operation and witing for the en of it."

   111

   112

    def __init__(self, app):

   113

        """

   114

        Parameters: 

   115

            app (class App): Sikuli app given by StartBeremizApp

   116

        """

   117

        self.r = Region(app.window())

   118

   119

        self.idechanged = False

   120

   121

        # 200 was selected because default 50 was still catching cursor blinking in console

   122

        # FIXME : remove blinking cursor in console

   123

        self.r.onChange(200,self._OnIDEWindowChange)

   124

        self.r.observeInBackground()

   125

   126

    def __del__(self):

   127

        self.r.stopObserver()

   128

   129

    def _OnIDEWindowChange(self, event):

   130

        print event

   131

        self.idechanged = True

   132

   133

    def Wait(self, period, timeout):

   134

        """

   135

        Wait for IDE to stop changing

   136

        Parameters: 

   137

            period (int): how many seconds with no change to consider idle

   138

            timeout (int): how long to wait for idle, in seconds

   139

        """

   140

        c = timeout/period

   141

        while c > 0:

   142

            self.idechanged = False

   143

            wait(period)

   144

            if not self.idechanged:

   145

                break

   146

            c = c - 1

   147

   148

        if c == 0:

   149

            raise Exception("Window did not idle before timeout")

   150

   151

   152

class stdoutIdleObserver:

   153

    "Detects when IDE's stdout is idle. Can be more reliable than pixel based version (false changes ?)"

   154

   155

    def __init__(self, proc):

   156

        """

   157

        Parameters: 

   158

            proc (subprocess.Popen): Beremiz process, given by StartBeremizApp

   159

        """

   160

        self.proc = proc

   161

        self.stdoutchanged = False

   162

   163

        self.thread = Thread(target = self._waitStdoutProc).start()

   164

   165

    def _waitStdoutProc():

   166

        while True:

   167

            a = self.proc.stdout.read(1)

   168

            if len(a) == 0 or a is None: 

   169

                break

   170

            sys.stdout.write(a)

   171

            self.idechanged = True

   172

   173

    def Wait(self, period, timeout):

   174

        """

   175

        Wait for IDE'stdout to stop changing

   176

        Parameters: 

   177

            period (int): how many seconds with no change to consider idle

   178

            timeout (int): how long to wait for idle, in seconds

   179

        """

   180

        c = timeout/period

   181

        while c > 0:

   182

            self.idechanged = False

   183

            wait(period)

   184

            if not self.idechanged:

   185

                break

   186

            c = c - 1

   187

   188

        if c == 0:

   189

            raise Exception("Stdout did not idle before timeout")

   190

   191

   192

def waitPatternInStdout(proc, pattern, timeout, count=1):

   193

   194

    success_event = Event()

   195

   196

    def waitPatternInStdoutProc():

   197

        found = 0

   198

        while True:

   199

            a = proc.stdout.readline()

   200

            if len(a) == 0 or a is None: 

   201

                raise Exception("App finished before producing expected stdout pattern")

   202

            sys.stdout.write(a)

   203

            if a.find(pattern) >= 0:

   204

                found = found + 1

   205

                if found >= count:

   206

                    success_event.set()

   207

                    break

   208

   209

   210

    Thread(target = waitPatternInStdoutProc).start()

   211

   212

    if not success_event.wait(timeout):

   213

        # test timed out

   214

        return False

   215

    else:

   216

        return True

   217

   218

   219