1
=== modified file 'debian/rules'
2
--- debian/rules	2013-02-18 14:06:27 +0000
3
+++ debian/rules	2013-04-26 03:37:26 +0000
4
@@ -58,6 +58,9 @@
5
58
	# remove .a files
58
	# remove .a files
6
59
	rm -f debian/tmp/usr/lib/*.a
59
	rm -f debian/tmp/usr/lib/*.a
7
60
60
8
61
        # remove acceptance test binary
9
62
	rm -f debian/tmp/usr/bin/compiz_autopilot_acceptance_tests
10
63
11
61
	# remove gconf schema files
64
	# remove gconf schema files
12
62
	#rm -rf debian/tmp/usr/share/gconf/schemas/
65
	#rm -rf debian/tmp/usr/share/gconf/schemas/
13
63
66
14
64
67
15
=== modified file 'tests/acceptance-tests/CMakeLists.txt'
16
--- tests/acceptance-tests/CMakeLists.txt	2012-12-05 03:35:37 +0000
17
+++ tests/acceptance-tests/CMakeLists.txt	2013-04-26 03:37:26 +0000
18
@@ -1,1 +1,2 @@
19
1
add_subdirectory (xorg-gtest)
1
add_subdirectory (xorg-gtest)
20
2
add_subdirectory (autopilot)
21
2
3
22
=== added directory 'tests/acceptance-tests/autopilot'
23
=== added file 'tests/acceptance-tests/autopilot/CMakeLists.txt'
24
--- tests/acceptance-tests/autopilot/CMakeLists.txt	1970-01-01 00:00:00 +0000
25
+++ tests/acceptance-tests/autopilot/CMakeLists.txt	2013-04-26 03:37:26 +0000
26
@@ -0,0 +1,12 @@
27
1
add_executable (compiz_autopilot_acceptance_tests
28
2
                ${CMAKE_CURRENT_SOURCE_DIR}/compiz_autopilot_acceptance_tests.cpp)
29
3
30
4
set (COMPIZ_AUTOPILOT_ACCEPTANCE_TEST_LIBRARIES
31
5
     ${GTEST_BOTH_LIBRARIES}
32
6
     ${CMAKE_THREAD_LIBS_INIT})
33
7
34
8
target_link_libraries (compiz_autopilot_acceptance_tests
35
9
                       ${COMPIZ_AUTOPILOT_ACCEPTANCE_TEST_LIBRARIES})
36
10
37
11
install (TARGETS compiz_autopilot_acceptance_tests
38
12
         RUNTIME DESTINATION ${exec_prefix})
39
0
13
40
=== added file 'tests/acceptance-tests/autopilot/README'
41
--- tests/acceptance-tests/autopilot/README	1970-01-01 00:00:00 +0000
42
+++ tests/acceptance-tests/autopilot/README	2013-04-26 03:37:26 +0000
43
@@ -0,0 +1,23 @@
44
1
COMPIZ AUTOPILOT ACCEPTANCE TESTS
45
2
=================================
46
3
47
4
compiz_autopilot_acceptance_tests is a simple Google Test wrapper around
48
5
a suite of Unity Autopilot tests which effectively validate window manager
49
6
functionality by actually interacting with a running instance.
50
7
51
8
Note: These tests are very sensitive. There's a high chance of false-positives
52
9
unless your session is set up exactly as indicated below:
53
10
54
11
  1. Use a session with a completely default configuration. This might
55
12
     include an Ubuntu guest session, or a new user.
56
13
  2. Do not have any external monitors plugged in, even in mirror mode.
57
14
     Gdk will detect any plugged in monitors and report them as
58
15
     part of the monitors available - autopilot assumes that the monitors
59
16
     are always in xinerama mode, which may cause tests to fail in very
60
17
     non-obvious ways.
61
18
  3. Do not have any other windows open at the time the test binary is
62
19
     launched. It is suggested to launch the test binary from another
63
20
     session with the same environment variables present in the
64
21
     guest session.
65
22
66
23
Do not add this binary to the auto-test discovery.
67
0
24
68
=== added file 'tests/acceptance-tests/autopilot/compiz_autopilot_acceptance_tests.cpp'
69
--- tests/acceptance-tests/autopilot/compiz_autopilot_acceptance_tests.cpp	1970-01-01 00:00:00 +0000
70
+++ tests/acceptance-tests/autopilot/compiz_autopilot_acceptance_tests.cpp	2013-04-26 03:37:26 +0000
71
@@ -0,0 +1,461 @@
72
1
/*
73
2
 * Compiz Autopilot GTest Acceptance Tests
74
3
 *
75
4
 * Copyright (C) 2013 Canonical Ltd.
76
5
 *
77
6
 * This library is free software; you can redistribute it and/or
78
7
 * modify it under the terms of the GNU Lesser General Public
79
8
 * License as published by the Free Software Foundation; either
80
9
 * version 2.1 of the License, or (at your option) any later version.
81
10
82
11
 * This library is distributed in the hope that it will be useful,
83
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
84
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
85
14
 * Lesser General Public License for more details.
86
15
87
16
 * You should have received a copy of the GNU Lesser General Public
88
17
 * License along with this library; if not, write to the Free Software
89
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
90
19
 *
91
20
 * Authored By:
92
21
 * Sam Spilsbury <smspillaz@gmail.com>
93
22
 */
94
23
95
24
#include <stdexcept>
96
25
#include <boost/noncopyable.hpp>
97
26
98
27
#ifndef _GNU_SOURCE
99
28
#define _GNU_SOURCE
100
29
#endif
101
30
102
31
#include <unistd.h>
103
32
#include <sys/poll.h>
104
33
#include <fcntl.h>
105
34
#include <errno.h>
106
35
107
36
#include <gtest/gtest.h>
108
37
109
38
using ::testing::ValuesIn;
110
39
using ::testing::WithParamInterface;
111
40
112
41
namespace
113
42
{
114
43
    class Pipe :
115
44
	boost::noncopyable
116
45
    {
117
46
	public:
118
47
119
48
	    Pipe ()
120
49
	    {
121
50
		if (pipe2 (mPipe, O_CLOEXEC) == -1)
122
51
		    throw std::runtime_error (strerror (errno));
123
52
	    }
124
53
125
54
	    ~Pipe ()
126
55
	    {
127
56
		if (mPipe[0] &&
128
57
		    close (mPipe[0]) == -1)
129
58
		    std::cerr << "mPipe[0] " << strerror (errno) << std::endl;
130
59
131
60
		if (mPipe[1] &&
132
61
		    close (mPipe[1]) == -1)
133
62
		    std::cerr << "mPipe[0] " << strerror (errno) << std::endl;
134
63
	    }
135
64
136
65
	    /* Read end descriptor is read-only */
137
66
	    int ReadEnd ()
138
67
	    {
139
68
		return mPipe[0];
140
69
	    }
141
70
142
71
	    /* Write end descriptor is writable, we need to close it
143
72
	     * from other objects */
144
73
	    int & WriteEnd ()
145
74
	    {
146
75
		return mPipe[1];
147
76
	    }
148
77
149
78
	private:
150
79
151
80
	    int mPipe[2];
152
81
    };
153
82
154
83
    class FileDescriptorBackup :
155
84
	boost::noncopyable
156
85
    {
157
86
	public:
158
87
159
88
	    FileDescriptorBackup (int fd) :
160
89
		mOriginalFd (fd),
161
90
		mBackupFd (0)
162
91
	    {
163
92
		mBackupFd = dup (mOriginalFd);
164
93
165
94
		/* Save original */
166
95
		if (mBackupFd == -1)
167
96
		    throw std::runtime_error (strerror (errno));
168
97
	    }
169
98
170
99
	    ~FileDescriptorBackup ()
171
100
	    {
172
101
		/* Redirect backed up fd to old fd location */
173
102
		if (mBackupFd &&
174
103
		    dup2 (mBackupFd, mOriginalFd) == -1)
175
104
		    std::cerr << "Failed to restore file descriptor "
176
105
			      << strerror (errno) << std::endl;
177
106
	    }
178
107
179
108
	private:
180
109
181
110
	    int mOriginalFd;
182
111
	    int mBackupFd;
183
112
    };
184
113
185
114
    class RedirectedFileDescriptor :
186
115
	boost::noncopyable
187
116
    {
188
117
	public:
189
118
190
119
	    RedirectedFileDescriptor (int from,
191
120
				      int &to) :
192
121
		mFromFd (from),
193
122
		mToFd (to)
194
123
	    {
195
124
		/* Make 'to' take the old file descriptor's place */
196
125
		if (dup2 (to, from) == -1)
197
126
		    throw std::runtime_error (strerror (errno));
198
127
	    }
199
128
200
129
	    ~RedirectedFileDescriptor ()
201
130
	    {
202
131
		if (mToFd &&
203
132
		    close (mToFd) == -1)
204
133
		    std::cerr << "Failed to close redirect-to file descriptor "
205
134
			      << strerror (errno) << std::endl;
206
135
207
136
		mToFd = 0;
208
137
	    }
209
138
210
139
	private:
211
140
212
141
	    int mFromFd;
213
142
	    int &mToFd;
214
143
    };
215
144
216
145
    pid_t launchBinary (const std::string &executable,
217
146
			const char        **argv,
218
147
			int               &stderrWriteEnd,
219
148
			int               &stdoutWriteEnd)
220
149
    {
221
150
	FileDescriptorBackup stderr (STDERR_FILENO);
222
151
	FileDescriptorBackup stdout (STDOUT_FILENO);
223
152
224
153
	/* Close the originals once they have been backed up
225
154
	 * We have to do this here and not in the FileDescriptorBackup
226
155
	 * constructors because of an order-of-operations issue -
227
156
	 * namely if we close an original file descriptor name
228
157
	 * before duplicating another one, then there's a possibility
229
158
	 * that the duplicated other one will get the same name as
230
159
	 * the one we just closed, making us unable to restore
231
160
	 * the closed one properly */
232
161
	if (close (STDERR_FILENO) == -1)
233
162
	    throw std::runtime_error (strerror (errno));
234
163
235
164
	if (close (STDOUT_FILENO) == -1)
236
165
	    throw std::runtime_error (strerror (errno));
237
166
238
167
	/* Replace the current process stderr and stdout with the write end
239
168
	 * of the pipes. Now when someone tries to write to stderr or stdout
240
169
	 * they'll write to our pipes instead */
241
170
	RedirectedFileDescriptor pipedStderr (STDERR_FILENO, stderrWriteEnd);
242
171
	RedirectedFileDescriptor pipedStdout (STDOUT_FILENO, stdoutWriteEnd);
243
172
244
173
	/* Fork process, child gets a copy of the pipe write ends
245
174
	 * - the original pipe write ends will be closed on exec
246
175
	 * but the duplicated write ends now taking the place of
247
176
	 * stderr and stdout will not be */
248
177
	pid_t child = fork ();
249
178
250
179
	/* Child process */
251
180
	if (child == 0)
252
181
	{
253
182
	    if (execvpe (executable.c_str (),
254
183
			 const_cast <char * const *> (argv),
255
184
			 environ) == -1)
256
185
	    {
257
186
		std::cerr << "execvpe failed with error "
258
187
			  << errno
259
188
			  << std::endl
260
189
			  << " - binary "
261
190
			  << executable
262
191
			  << std::endl;
263
192
		abort ();
264
193
	    }
265
194
	}
266
195
	/* Parent process - error */
267
196
	else if (child == -1)
268
197
	    throw std::runtime_error (strerror (errno));
269
198
270
199
	/* The old file descriptors for the stderr and stdout
271
200
	 * are put back in place, and pipe write ends closed
272
201
	 * as the child is using them at return */
273
202
274
203
	return child;
275
204
    }
276
205
277
206
    int launchBinaryAndWaitForReturn (const std::string &executable,
278
207
				      const char        **argv,
279
208
				      int               &stderrWriteEnd,
280
209
				      int               &stdoutWriteEnd)
281
210
    {
282
211
	int status = 0;
283
212
	pid_t child = launchBinary (executable,
284
213
				    argv,
285
214
				    stderrWriteEnd,
286
215
				    stdoutWriteEnd);
287
216
288
217
	do
289
218
	{
290
219
	    /* Wait around for the child to get a signal */
291
220
	    pid_t waitChild = waitpid (child, &status, 0);
292
221
	    if (waitChild == child)
293
222
	    {
294
223
		/* If it died unexpectedly, say so */
295
224
		if (WIFSIGNALED (status))
296
225
		{
297
226
		    std::stringstream ss;
298
227
		    ss << "child killed by signal "
299
228
		       << WTERMSIG (status);
300
229
		    throw std::runtime_error (ss.str ());
301
230
		}
302
231
	    }
303
232
	    else
304
233
	    {
305
234
		/* waitpid () failed */
306
235
		throw std::runtime_error (strerror (errno));
307
236
	    }
308
237
309
238
	    /* Keep going until it exited */
310
239
	} while (!WIFEXITED (status) && !WIFSIGNALED (status));
311
240
312
241
	/* Return the exit code */
313
242
	return WEXITSTATUS (status);
314
243
    }
315
244
316
245
    const char *autopilot = "/usr/bin/autopilot";
317
246
    const char *runOpt = "run";
318
247
    const char *dashV = "-v";
319
248
}
320
249
321
250
class CompizAutopilotAcceptanceTest :
322
251
    public ::testing::Test,
323
252
    public ::testing::WithParamInterface <const char *>
324
253
{
325
254
    public:
326
255
327
256
	CompizAutopilotAcceptanceTest ();
328
257
	const char ** GetAutopilotArgv ();
329
258
	void PrintChildStderr ();
330
259
	void PrintChildStdout ();
331
260
332
261
    protected:
333
262
334
263
	std::vector <const char *> autopilotArgv;
335
264
	Pipe                       childStdoutPipe;
336
265
	Pipe			   childStderrPipe;
337
266
};
338
267
339
268
CompizAutopilotAcceptanceTest::CompizAutopilotAcceptanceTest ()
340
269
{
341
270
    autopilotArgv.push_back (autopilot);
342
271
    autopilotArgv.push_back (runOpt);
343
272
    autopilotArgv.push_back (dashV);
344
273
    autopilotArgv.push_back (GetParam ());
345
274
    autopilotArgv.push_back (NULL);
346
275
}
347
276
348
277
const char **
349
278
CompizAutopilotAcceptanceTest::GetAutopilotArgv ()
350
279
{
351
280
    return &autopilotArgv[0];
352
281
}
353
282
354
283
namespace
355
284
{
356
285
    std::string FdToString (int fd)
357
286
    {
358
287
	std::string output;
359
288
360
289
	int bufferSize = 4096;
361
290
	char buffer[bufferSize];
362
291
363
292
	ssize_t count = 0;
364
293
365
294
	do
366
295
	{
367
296
	    struct pollfd pfd;
368
297
	    pfd.events = POLLIN | POLLERR | POLLHUP;
369
298
	    pfd.revents = 0;
370
299
	    pfd.fd = fd;
371
300
372
301
	    /* Check for 10ms if there's anything waiting to be read */
373
302
	    int nfds = poll (&pfd, 1, 10);
374
303
375
304
	    if (nfds == -1)
376
305
		throw std::runtime_error (strerror (errno));
377
306
378
307
	    if (nfds)
379
308
	    {
380
309
		/* Read as much as we have allocated for */
381
310
		count = read (fd, (void *) buffer, bufferSize - 1);
382
311
383
312
		/* Something failed, bail */
384
313
		if (count == -1)
385
314
		    throw std::runtime_error (strerror (errno));
386
315
387
316
		/* Always null-terminate */
388
317
		buffer[count] = '\0';
389
318
390
319
		/* Add it to the output */
391
320
		output += buffer;
392
321
	    }
393
322
	    else
394
323
	    {
395
324
		/* There's nothing on the pipe, assume EOF */
396
325
		count = 0;
397
326
	    }
398
327
399
328
	    /* Keep going until there's nothing left */
400
329
	} while (count != 0);
401
330
402
331
	return output;
403
332
    }
404
333
}
405
334
406
335
void
407
336
CompizAutopilotAcceptanceTest::PrintChildStderr ()
408
337
{
409
338
    std::string output = FdToString (childStderrPipe.ReadEnd ());
410
339
411
340
    std::cout << "[== TEST ERRORS ==]" << std::endl
412
341
	      << output
413
342
	      << std::endl;
414
343
}
415
344
416
345
void
417
346
CompizAutopilotAcceptanceTest::PrintChildStdout ()
418
347
{
419
348
    std::string output = FdToString (childStdoutPipe.ReadEnd ());
420
349
421
350
    std::cout << "[== TEST MESSAGES ==]" << std::endl
422
351
	      << output
423
352
	      << std::endl;
424
353
}
425
354
426
355
TEST_P (CompizAutopilotAcceptanceTest, AutopilotTest)
427
356
{
428
357
    std::string scopedTraceMsg ("Running Autopilot Test");
429
358
    scopedTraceMsg += GetParam ();
430
359
431
360
    int status = launchBinaryAndWaitForReturn (std::string (autopilot),
432
361
					       GetAutopilotArgv (),
433
362
					       childStderrPipe.WriteEnd (),
434
363
					       childStdoutPipe.WriteEnd ());
435
364
436
365
    EXPECT_EQ (status, 0) << "expected exit status of 0";
437
366
438
367
    if (status)
439
368
    {
440
369
	PrintChildStdout ();
441
370
	PrintChildStderr ();
442
371
    }
443
372
    else
444
373
    {
445
374
	/* Extra space here to align with gtest output */
446
375
	std::cout << "[AUTOPILOT ] Pass test " << GetParam () << std::endl;
447
376
    }
448
377
}
449
378
450
379
namespace
451
380
{
452
381
const char *AutopilotTests[] =
453
382
{
454
383
    "unity.tests.launcher.test_icon_behavior.LauncherIconsTests.test_clicking_icon_twice_initiates_spread",
455
384
    "unity.tests.launcher.test_icon_behavior.LauncherIconsTests.test_expo_launcher_icon_initiates_expo",
456
385
    "unity.tests.launcher.test_icon_behavior.LauncherIconsTests.test_expo_launcher_icon_terminates_expo",
457
386
    "unity.tests.launcher.test_icon_behavior.LauncherIconsTests.test_launcher_activate_last_focused_window",
458
387
    "unity.tests.launcher.test_icon_behavior.LauncherIconsTests.test_unminimize_initially_minimized_windows",
459
388
    "unity.tests.launcher.test_icon_behavior.LauncherIconsTests.test_unminimize_minimized_immediately_after_show_windows",
460
389
    "unity.tests.launcher.test_icon_behavior.LauncherIconsTests.test_while_in_scale_mode_the_dash_will_still_open",
461
390
    "unity.tests.test_dash.DashRevealWithSpreadTests.test_command_lens_opens_when_in_spread",
462
391
    "unity.tests.test_dash.DashRevealWithSpreadTests.test_dash_closes_on_spread",
463
392
    "unity.tests.test_dash.DashRevealWithSpreadTests.test_dash_opens_when_in_spread",
464
393
    "unity.tests.test_dash.DashRevealWithSpreadTests.test_lens_opens_when_in_spread",
465
394
    "unity.tests.test_hud.HudBehaviorTests.test_alt_arrow_keys_not_eaten",
466
395
    "unity.tests.test_panel.PanelCrossMonitorsTests.test_panel_title_updates_moving_window",
467
396
    "unity.tests.test_panel.PanelCrossMonitorsTests.test_window_buttons_close_inactive_when_clicked_in_another_monitor",
468
397
    "unity.tests.test_panel.PanelCrossMonitorsTests.test_window_buttons_dont_show_for_maximized_window_on_mouse_in",
469
398
    "unity.tests.test_panel.PanelCrossMonitorsTests.test_window_buttons_dont_show_in_other_monitors_when_dash_is_open",
470
399
    "unity.tests.test_panel.PanelCrossMonitorsTests.test_window_buttons_dont_show_in_other_monitors_when_hud_is_open",
471
400
    "unity.tests.test_panel.PanelCrossMonitorsTests.test_window_buttons_minimize_inactive_when_clicked_in_another_monitor",
472
401
    "unity.tests.test_panel.PanelCrossMonitorsTests.test_window_buttons_unmaximize_inactive_when_clicked_in_another_monitor",
473
402
    "unity.tests.test_panel.PanelGrabAreaTests.test_focus_the_maximized_window_works",
474
403
    "unity.tests.test_panel.PanelGrabAreaTests.test_lower_the_maximized_window_works",
475
404
    "unity.tests.test_panel.PanelGrabAreaTests.test_panels_dont_steal_keynav_foucs_from_hud",
476
405
    "unity.tests.test_panel.PanelGrabAreaTests.test_unmaximize_from_grab_area_works",
477
406
    "unity.tests.test_panel.PanelHoverTests.test_menus_show_for_maximized_window_on_mouse_in_btn_area",
478
407
    "unity.tests.test_panel.PanelHoverTests.test_menus_show_for_maximized_window_on_mouse_in_grab_area",
479
408
    "unity.tests.test_panel.PanelHoverTests.test_menus_show_for_maximized_window_on_mouse_in_menu_area",
480
409
    "unity.tests.test_panel.PanelHoverTests.test_only_menus_show_for_restored_window_on_mouse_in_grab_area",
481
410
    "unity.tests.test_panel.PanelHoverTests.test_only_menus_show_for_restored_window_on_mouse_in_menu_area",
482
411
    "unity.tests.test_panel.PanelHoverTests.test_only_menus_show_for_restored_window_on_mouse_in_window_btn_area",
483
412
    "unity.tests.test_panel.PanelMenuTests.test_menus_dont_show_for_maximized_window_on_mouse_out",
484
413
    "unity.tests.test_panel.PanelMenuTests.test_menus_dont_show_for_restored_window_on_mouse_out",
485
414
    "unity.tests.test_panel.PanelMenuTests.test_menus_dont_show_if_a_new_application_window_is_opened",
486
415
    "unity.tests.test_panel.PanelMenuTests.test_menus_show_for_maximized_window_on_mouse_in",
487
416
    "unity.tests.test_panel.PanelMenuTests.test_menus_show_for_restored_window_on_mouse_in",
488
417
    "unity.tests.test_panel.PanelMenuTests.test_menus_shows_when_new_application_is_opened",
489
418
    "unity.tests.test_panel.PanelTitleTests.test_panel_shows_app_title_with_maximised_app",
490
419
    "unity.tests.test_panel.PanelTitleTests.test_panel_title_doesnt_change_with_switcher",
491
420
    "unity.tests.test_panel.PanelTitleTests.test_panel_title_on_empty_desktop",
492
421
    "unity.tests.test_panel.PanelTitleTests.test_panel_title_updates_on_maximized_window_title_changes",
493
422
    "unity.tests.test_panel.PanelTitleTests.test_panel_title_updates_when_switching_to_maximized_app",
494
423
    "unity.tests.test_panel.PanelTitleTests.test_panel_title_with_maximized_application",
495
424
    "unity.tests.test_panel.PanelTitleTests.test_panel_title_with_maximized_window_restored_child",
496
425
    "unity.tests.test_panel.PanelTitleTests.test_panel_title_with_restored_application",
497
426
    "unity.tests.test_panel.PanelWindowButtonsTests.test_double_click_unmaximize_window",
498
427
    "unity.tests.test_panel.PanelWindowButtonsTests.test_minimize_button_disabled_for_non_minimizable_windows",
499
428
    "unity.tests.test_panel.PanelWindowButtonsTests.test_window_buttons_dont_show_for_maximized_window_on_mouse_out",
500
429
    "unity.tests.test_panel.PanelWindowButtonsTests.test_window_buttons_dont_show_for_restored_window",
501
430
    "unity.tests.test_panel.PanelWindowButtonsTests.test_window_buttons_dont_show_for_restored_window_with_mouse_in_panel",
502
431
    "unity.tests.test_panel.PanelWindowButtonsTests.test_window_buttons_dont_show_on_empty_desktop",
503
432
    "unity.tests.test_panel.PanelWindowButtonsTests.test_window_buttons_minimize_button_works_for_window",
504
433
    "unity.tests.test_panel.PanelWindowButtonsTests.test_window_buttons_show_for_maximized_window_on_mouse_in",
505
434
    "unity.tests.test_panel.PanelWindowButtonsTests.test_window_buttons_unmaximize_button_works_for_window",
506
435
    "unity.tests.test_panel.PanelWindowButtonsTests.test_window_buttons_unmaximize_follows_fitts_law",
507
436
    "unity.tests.test_showdesktop.ShowDesktopTests.test_showdesktop_hides_apps",
508
437
    "unity.tests.test_showdesktop.ShowDesktopTests.test_showdesktop_switcher",
509
438
    "unity.tests.test_showdesktop.ShowDesktopTests.test_showdesktop_unhides_apps",
510
439
    "unity.tests.test_showdesktop.ShowDesktopTests.test_unhide_single_app",
511
440
    "unity.tests.test_spread.SpreadTests.test_scale_application_windows",
512
441
    "unity.tests.test_spread.SpreadTests.test_scaled_window_closes_on_close_button_click",
513
442
    "unity.tests.test_spread.SpreadTests.test_scaled_window_closes_on_middle_click",
514
443
    "unity.tests.test_spread.SpreadTests.test_scaled_window_is_focused_on_click",
515
444
    "unity.tests.test_switcher.SwitcherDetailsModeTests.test_detail_mode_selects_last_active_window",
516
445
    "unity.tests.test_switcher.SwitcherDetailsModeTests.test_detail_mode_selects_third_window",
517
446
    "unity.tests.test_switcher.SwitcherDetailsTests.test_no_details_for_apps_on_different_workspace",
518
447
    "unity.tests.test_switcher.SwitcherTests.test_application_window_is_fake_decorated",
519
448
    "unity.tests.test_switcher.SwitcherTests.test_application_window_is_fake_decorated_in_detail_mode",
520
449
    "unity.tests.test_switcher.SwitcherWindowsManagementTests.test_switcher_raises_only_last_focused_window",
521
450
    "unity.tests.test_switcher.SwitcherWindowsManagementTests.test_switcher_rises_next_window_of_same_application",
522
451
    "unity.tests.test_switcher.SwitcherWindowsManagementTests.test_switcher_rises_other_application",
523
452
    "unity.tests.test_switcher.SwitcherWorkspaceTests.test_switcher_all_mode_shows_all_apps",
524
453
    "unity.tests.test_switcher.SwitcherWorkspaceTests.test_switcher_can_switch_to_minimised_window",
525
454
    "unity.tests.test_switcher.SwitcherWorkspaceTests.test_switcher_is_disabled_when_wall_plugin_active",
526
455
    "unity.tests.test_switcher.SwitcherWorkspaceTests.test_switcher_shows_current_workspace_only"
527
456
};
528
457
}
529
458
530
459
531
460
INSTANTIATE_TEST_CASE_P (UnityIntegrationAutopilotTests, CompizAutopilotAcceptanceTest,
532
461
			 ValuesIn (AutopilotTests));
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Needs Fixing on 2013-04-26
Compiz Maintainers		2013-04-17	Pending
Review via email: mp+159422@code.launchpad.net