← Back to branch summary

~ubuntu-branches/ubuntu/hardy/gallery2/hardy-security

« back to all changes in this revision

Viewing changes to modules/core/test/phpunit/ToolkitTest.class

  • Committer: Bazaar Package Importer
  • Author(s): Michael C. Schultheiss
  • Date: 2006-04-16 16:42:35 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20060416164235-8uy0u4bfjdxpge2o
Tags: 2.1.1-1
http://bugs.debian.org/362936
http://bugs.debian.org/359000
http://bugs.debian.org/362152
* New upstream release (Closes: #362936)
  + Bugfixes for Postgres7 (Closes: #359000, #362152)

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/core/test/phpunit/ToolkitTest.class
3
3
 * $RCSfile: ToolkitTest.class,v $
4
4
 *
5
5
 * Gallery - a web based photo album viewer and editor
6
 
 * Copyright (C) 2000-2005 Bharat Mediratta
 
6
 * Copyright (C) 2000-2006 Bharat Mediratta
7
7
 *
8
8
 * This program is free software; you can redistribute it and/or modify
9
9
 * it under the terms of the GNU General Public License as published by
20
20
 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA  02110-1301, USA.
21
21
 */
22
22
/**
23
 
 * @version $Revision: 1.29 $ $Date: 2005/08/23 03:49:33 $
 
23
 * @version $Revision: 1.32 $ $Date: 2006/01/18 20:38:28 $
24
24
 * @package GalleryCore
25
25
 * @subpackage PHPUnit
26
26
 * @author Bharat Mediratta <bharat@menalto.com>
27
27
 */
28
28
 
 
29
GalleryCoreApi::requireOnce('modules/core/classes/GalleryToolkit.class');
 
30
 
29
31
/**
30
32
 * Test Toolkit functionality
31
33
 *
46
48
        $ret = GalleryCoreApi::registerFactoryImplementation(
47
49
            'GalleryToolkit', 'TestToolkit', 'TestToolkit',
48
50
            $path, 'coreTest', null);
49
 
        if ($ret->isError()) {
 
51
        if ($ret) {
50
52
            print $ret->getAsHtml();
51
53
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
52
54
        }
54
56
        $ret = GalleryCoreApi::registerFactoryImplementation(
55
57
            'GalleryToolkit', 'TestToolkit2', 'TestToolkit2',
56
58
            $path, 'coreTest', null);
57
 
        if ($ret->isError()) {
 
59
        if ($ret) {
58
60
            print $ret->getAsHtml();
59
61
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
60
62
        }
75
77
                                                       $params,
76
78
                                                       'test-description',
77
79
                                                       'test/outputType');
78
 
        if ($ret->isError()) {
 
80
        if ($ret) {
79
81
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
80
82
        }
81
83
 
82
84
        /* Get the operation */
83
85
        list ($ret, $operations) = GalleryCoreApi::getToolkitOperations('test/type');
84
 
        if ($ret->isError()) {
 
86
        if ($ret) {
85
87
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
86
88
        }
87
89
 
94
96
        /* Get the toolkit */
95
97
        list ($ret, $toolkit, $outputMimeType) =
96
98
            GalleryCoreApi::getToolkitByOperation('test/type', 'test-operation');
97
 
        if ($ret->isError()) {
 
99
        if ($ret) {
98
100
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
99
101
        }
100
102
 
108
110
                                                       $params,
109
111
                                                       'test-description2',
110
112
                                                       'test/outputType', 3);
111
 
        if ($ret->isError()) {
 
113
        if ($ret) {
112
114
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
113
115
        }
114
116
 
115
117
        /* Get the toolkit */
116
118
        list ($ret, $toolkit, $outputMimeType) =
117
119
            GalleryCoreApi::getToolkitByOperation('test/type', 'test-operation');
118
 
        if ($ret->isError()) {
 
120
        if ($ret) {
119
121
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
120
122
        }
121
123
 
124
126
 
125
127
        /* Unregister */
126
128
        $ret = GalleryCoreApi::unregisterToolkit('TestToolkit');
127
 
        if ($ret->isError()) {
 
129
        if ($ret) {
128
130
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
129
131
        }
130
132
        $ret = GalleryCoreApi::unregisterToolkit('TestToolkit2');
131
 
        if ($ret->isError()) {
 
133
        if ($ret) {
132
134
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
133
135
        }
134
136
 
135
137
        /* Get the toolkit */
136
138
        list ($ret, $toolkit, $outputMimeType) =
137
139
            GalleryCoreApi::getToolkitByOperation('test/type', 'test-operation');
138
 
        if ($ret->isError()) {
 
140
        if ($ret) {
139
141
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
140
142
        }
141
143
 
148
150
                                                      'test-property',
149
151
                                                      'int',
150
152
                                                      'test-description');
151
 
        if ($ret->isError()) {
 
153
        if ($ret) {
152
154
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
153
155
        }
154
156
 
155
157
        /* Get the operation */
156
158
        list ($ret, $properties) = GalleryCoreApi::getToolkitProperties('test/type');
157
 
        if ($ret->isError()) {
 
159
        if ($ret) {
158
160
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
159
161
        }
160
162
 
166
168
        /* Get the toolkit */
167
169
        list ($ret, $toolkit) =
168
170
            GalleryCoreApi::getToolkitByProperty('test/type', 'test-property');
169
 
        if ($ret->isError()) {
 
171
        if ($ret) {
170
172
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
171
173
        }
172
174
 
174
176
 
175
177
        /* Unregister */
176
178
        $ret = GalleryCoreApi::unregisterToolkit('TestToolkit');
177
 
        if ($ret->isError()) {
 
179
        if ($ret) {
178
180
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
179
181
        }
180
182
 
181
183
        /* Get the toolkit */
182
184
        list ($ret, $toolkit) =
183
185
            GalleryCoreApi::getToolkitByProperty('test/type', 'test-property');
184
 
        if ($ret->isError()) {
 
186
        if ($ret) {
185
187
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
186
188
        }
187
189
 
194
196
                                                      'test-property',
195
197
                                                      'int',
196
198
                                                      'test-description');
197
 
        if ($ret->isError()) {
 
199
        if ($ret) {
198
200
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
199
201
        }
200
202
        $ret = GalleryCoreApi::registerToolkitProperty('TestToolkit2',
202
204
                                                      'test-property',
203
205
                                                      'int',
204
206
                                                      'test-description');
205
 
        if ($ret->isError()) {
 
207
        if ($ret) {
206
208
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
207
209
        }
208
210
 
209
211
        /* Get the toolkits */
210
212
        list ($ret, $toolkits) =
211
213
            GalleryCoreApi::getToolkitsByProperty('test/type', 'test-property');
212
 
        if ($ret->isError()) {
 
214
        if ($ret) {
213
215
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
214
216
        }
215
217
 
222
224
 
223
225
        /* Unregister */
224
226
        $ret = GalleryCoreApi::unregisterToolkit('TestToolkit2');
225
 
        if ($ret->isError()) {
 
227
        if ($ret) {
226
228
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
227
229
        }
228
230
        $ret = GalleryCoreApi::unregisterToolkit('TestToolkit');
229
 
        if ($ret->isError()) {
 
231
        if ($ret) {
230
232
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
231
233
        }
232
234
 
233
235
        /* Get the toolkits */
234
236
        list ($ret, $toolkitIds) =
235
237
            GalleryCoreApi::getToolkitByProperty('test/type', 'test-property');
236
 
        if ($ret->isError()) {
 
238
        if ($ret) {
237
239
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
238
240
        }
239
241
 
252
254
                                                       $params,
253
255
                                                       'test-description',
254
256
                                                       'test/type2');
255
 
        if ($ret->isError()) {
 
257
        if ($ret) {
256
258
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
257
259
        }
258
260
 
262
264
                                                       $params,
263
265
                                                       'test-description',
264
266
                                                       'test/type3');
265
 
        if ($ret->isError()) {
 
267
        if ($ret) {
266
268
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
267
269
        }
268
270
 
269
271
        list ($ret, $isSupported, $outputMimeType) =
270
272
            GalleryCoreApi::isSupportedOperationSequence('test/type1',
271
273
                                                         'test-operation1|1,2;test-operation2|1,2');
272
 
        if ($ret->isError()) {
 
274
        if ($ret) {
273
275
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
274
276
        }
275
277
 
279
281
        /* Unregister operation for single mime-type */
280
282
        $ret = GalleryCoreApi::unregisterToolkitOperation('TestToolkit', 'test-operation1',
281
283
                                         array('test/unused', 'test/nonexist'));
282
 
        if ($ret->isError()) {
 
284
        if ($ret) {
283
285
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
284
286
        }
285
287
 
286
288
        list ($ret, $isSupported, $outputMimeType) =
287
289
            GalleryCoreApi::isSupportedOperationSequence('test/type1',
288
290
                                                         'test-operation1|1,2;test-operation2|1,2');
289
 
        if ($ret->isError()) {
 
291
        if ($ret) {
290
292
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
291
293
        }
292
294
 
295
297
 
296
298
        /* Unregister single operation */
297
299
        $ret = GalleryCoreApi::unregisterToolkitOperation('TestToolkit', 'test-operation2');
298
 
        if ($ret->isError()) {
 
300
        if ($ret) {
299
301
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
300
302
        }
301
303
 
302
304
        list ($ret, $isSupported, $outputMimeType) =
303
305
            GalleryCoreApi::isSupportedOperationSequence('test/type1',
304
306
                                                         'test-operation1|1,2;test-operation2|1,2');
305
 
        if ($ret->isError()) {
 
307
        if ($ret) {
306
308
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
307
309
        }
308
310
 
310
312
 
311
313
        /* Unregister toolkit */
312
314
        $ret = GalleryCoreApi::unregisterToolkit('TestToolkit');
313
 
        if ($ret->isError()) {
 
315
        if ($ret) {
314
316
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
315
317
        }
316
318
 
317
319
        list ($ret, $isSupported, $outputMimeType) =
318
320
            GalleryCoreApi::isSupportedOperationSequence('test/type1',
319
321
                                                         'test-operation1|1,2;test-operation2|1,2');
320
 
        if ($ret->isError()) {
 
322
        if ($ret) {
321
323
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
322
324
        }
323
325
 
337
339
                                                       $params,
338
340
                                                       'test-description',
339
341
                                                       'test/outputType');
340
 
        if ($ret->isError()) {
 
342
        if ($ret) {
341
343
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
342
344
        }
343
345
 
344
346
        list ($ret, $data) = GalleryCoreApi::getToolkitOperationMimeTypes('test-operation');
345
 
        if ($ret->isError()) {
 
347
        if ($ret) {
346
348
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
347
349
        }
348
350
        $this->assert(isset($data['test/type']) && in_array('TestToolkit', $data['test/type']),
351
353
 
352
354
    function testEstimateDerivativeDimensions() {
353
355
        list ($ret, $source) = GalleryCoreApi::newItemByMimeType('image/jpeg');
354
 
        if ($ret->isError()) {
 
356
        if ($ret) {
355
357
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
356
358
        }
357
359
        $this->assert(GalleryUtilities::isA($source, 'GalleryPhotoItem'));
361
363
 
362
364
        list ($ret, $derivative) =
363
365
            GalleryCoreApi::newFactoryInstanceByHint('GalleryDerivative', $source->getEntityType());
364
 
        if ($ret->isError()) {
 
366
        if ($ret) {
365
367
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
366
368
        }
367
369
        $this->assert(GalleryUtilities::isA($derivative, 'GalleryDerivativeImage'));
371
373
        $derivative->setHeight(0);
372
374
 
373
375
        $ret = GalleryCoreApi::estimateDerivativeDimensions($derivative, $source);
374
 
        if ($ret->isError()) {
 
376
        if ($ret) {
375
377
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
376
378
        }
377
379
 
381
383
 
382
384
    function testEstimateDerivativeDimensions2() {
383
385
        list ($ret, $source) = GalleryCoreApi::newItemByMimeType('image/jpeg');
384
 
        if ($ret->isError()) {
 
386
        if ($ret) {
385
387
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
386
388
        }
387
389
        $this->assert(GalleryUtilities::isA($source, 'GalleryPhotoItem'));
391
393
 
392
394
        list ($ret, $derivative) =
393
395
            GalleryCoreApi::newFactoryInstanceByHint('GalleryDerivative', $source->getEntityType());
394
 
        if ($ret->isError()) {
 
396
        if ($ret) {
395
397
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
396
398
        }
397
399
        $this->assert(GalleryUtilities::isA($derivative, 'GalleryDerivativeImage'));
401
403
        $derivative->setHeight(0);
402
404
 
403
405
        $ret = GalleryCoreApi::estimateDerivativeDimensions($derivative, $source);
404
 
        if ($ret->isError()) {
 
406
        if ($ret) {
405
407
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
406
408
        }
407
409
 
411
413
 
412
414
    function testEstimateDerivativeDimensions3() {
413
415
        list ($ret, $source) = GalleryCoreApi::newItemByMimeType('image/jpeg');
414
 
        if ($ret->isError()) {
 
416
        if ($ret) {
415
417
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
416
418
        }
417
419
        $this->assert(GalleryUtilities::isA($source, 'GalleryPhotoItem'));
421
423
 
422
424
        list ($ret, $derivative) =
423
425
            GalleryCoreApi::newFactoryInstanceByHint('GalleryDerivative', $source->getEntityType());
424
 
        if ($ret->isError()) {
 
426
        if ($ret) {
425
427
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
426
428
        }
427
429
        $this->assert(GalleryUtilities::isA($derivative, 'GalleryDerivativeImage'));
431
433
        $derivative->setHeight(0);
432
434
 
433
435
        $ret = GalleryCoreApi::estimateDerivativeDimensions($derivative, $source);
434
 
        if ($ret->isError()) {
 
436
        if ($ret) {
435
437
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
436
438
        }
437
439
 
447
449
         * than the desired size, but it will be corrected once the derivative is built.
448
450
         */
449
451
        list ($ret, $orig) = GalleryCoreApi::newItemByMimeType('image/jpeg');
450
 
        if ($ret->isError()) {
 
452
        if ($ret) {
451
453
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
452
454
        }
453
455
        $this->assert(GalleryUtilities::isA($orig, 'GalleryPhotoItem'), 'photo item');
457
459
 
458
460
        list ($ret, $source) =
459
461
            GalleryCoreApi::newFactoryInstanceByHint('GalleryDerivative', $orig->getEntityType());
460
 
        if ($ret->isError()) {
 
462
        if ($ret) {
461
463
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
462
464
        }
463
465
        $this->assert(GalleryUtilities::isA($source, 'GalleryDerivativeImage'), 'source deriv');
468
470
 
469
471
        list ($ret, $derivative) =
470
472
            GalleryCoreApi::newFactoryInstanceByHint('GalleryDerivative', $orig->getEntityType());
471
 
        if ($ret->isError()) {
 
473
        if ($ret) {
472
474
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
473
475
        }
474
476
        $this->assert(GalleryUtilities::isA($derivative, 'GalleryDerivativeImage'), 'target deriv');
478
480
        $derivative->setHeight(0);
479
481
 
480
482
        $ret = GalleryCoreApi::estimateDerivativeDimensions($derivative, $source);
481
 
        if ($ret->isError()) {
 
483
        if ($ret) {
482
484
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
483
485
        }
484
486
 
493
495
        $orig->setHeight(66);
494
496
 
495
497
        $ret = GalleryCoreApi::estimateDerivativeDimensions($derivative, $orig);
496
 
        if ($ret->isError()) {
 
498
        if ($ret) {
497
499
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
498
500
        }
499
501
 
557
559
        $ret = GalleryCoreApi::registerToolkitOperation('TestToolkit',
558
560
                array('test/type'), 'test-operation', array(),
559
561
                'test-description', 'test/outputType', 40);
560
 
        if ($ret->isError()) {
 
562
        if ($ret) {
561
563
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
562
564
        }
563
565
 
564
566
        list ($ret, $priority) = GalleryCoreApi::getMaximumManagedToolkitPriority();
565
 
        if ($ret->isError()) {
 
567
        if ($ret) {
566
568
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
567
569
        }
568
570
 
569
 
        $this->assertEquals('40', $priority);
 
571
        $this->assertEquals(40, $priority);
570
572
    }
571
573
 
572
574
    function testGetRedundantPriorities() {
573
575
        $ret = GalleryCoreApi::registerToolkitOperation('TestToolkit',
574
576
                array('test/type'), 'test-operation', array(),
575
577
                'test-description', 'test/outputType', 30);
576
 
        if ($ret->isError()) {
 
578
        if ($ret) {
577
579
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
578
580
        }
579
581
 
580
582
        $ret = GalleryCoreApi::registerToolkitOperation('TestToolkit2',
581
583
                array('test/type'), 'test-operation', array(),
582
584
                'test-description', 'test/outputType', 27);
583
 
        if ($ret->isError()) {
 
585
        if ($ret) {
584
586
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
585
587
        }
586
588
 
587
589
        list ($ret, $list) = GalleryCoreApi::getRedundantToolkitPriorities();
588
 
        if ($ret->isError()) {
 
590
        if ($ret) {
589
591
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
590
592
        }
591
593
 
598
600
        $ret = GalleryCoreApi::registerToolkitOperation('TestToolkit',
599
601
                array('test/type'), 'test-operation', array(),
600
602
                'test-description', 'test/outputType', 30);
601
 
        if ($ret->isError()) {
 
603
        if ($ret) {
602
604
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
603
605
        }
604
606
 
605
607
        /* Validate that toolkit priority is returned correctly */
606
608
        list ($ret, $priority) = GalleryCoreApi::getToolkitPriorityById('TestToolkit');
607
 
        if ($ret->isError()) {
 
609
        if ($ret) {
608
610
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
609
611
        }
610
612
        $this->assertEquals(30, $priority, 'Toolkit Priority Doesn\'t Match');
611
 
        
 
613
 
612
614
        /* Test return for an undefined toolkit */
613
615
        list ($ret, $priority) = GalleryCoreApi::getToolkitPriorityById('TestToolkit2');
614
 
        if ($ret->isError()) {
 
616
        if ($ret) {
615
617
            return $this->failWithStatus($ret->wrap(__FILE__, __LINE__));
616
618
        }
617
619
        $this->assertEquals(null, $priority, 'Returned value for undefined toolkit');
618
620
    }
 
621
 
 
622
    function testMergeOperations() {
 
623
        $toolkit = new TestToolkit();
 
624
        $this->assertEquals(array(true, 'thumbnail', array(150)),
 
625
            $toolkit->mergeOperations('thumbnail', array(100), 'thumbnail', array(150)),
 
626
            'thumbnail');
 
627
        $this->assertEquals(array(true, 'scale', array(800)),
 
628
            $toolkit->mergeOperations('scale', array(600, 500), 'scale', array(800)),
 
629
            'scale');
 
630
        $this->assertEquals(array(true, 'resize', array(640, 480)),
 
631
            $toolkit->mergeOperations('resize', array(800, 600), 'resize', array(640, 480)),
 
632
            'resize');
 
633
        $this->assertEquals(array(true, 'scale', array(800, 600)),
 
634
            $toolkit->mergeOperations('thumbnail', array(200), 'scale', array(800, 600)),
 
635
            'thumbnail scale');
 
636
        $this->assertEquals(array(true, 'resize', array(640, 480)),
 
637
            $toolkit->mergeOperations('scale', array(800, 600), 'resize', array(640, 480)),
 
638
            'scale resize');
 
639
        $this->assertEquals(array(true, 'thumbnail', array(150)),
 
640
            $toolkit->mergeOperations('resize', array(900, 700), 'thumbnail', array(150)),
 
641
            'resize thumbnail');
 
642
        $this->assertEquals(array(true, 'crop', array(20, 20, 60, 60)),
 
643
            $toolkit->mergeOperations('crop', array(40, 40, 20, 20), 'crop', array(20, 20, 60, 60)),
 
644
            'crop');
 
645
        $this->assertEquals(array(false, null, null), $toolkit->mergeOperations(
 
646
                'composite', array('img', 'image/png', 30, 20, 'top-left', 0, 0),
 
647
                'composite', array('myimage', 'image/gif', 60, 60, 'center', 0, 0)),
 
648
            'composite should not merge');
 
649
        $this->assertEquals(array(true, 'rotate', array(180)),
 
650
            $toolkit->mergeOperations('rotate', array(90), 'rotate', array(90)),
 
651
            'rotate 90 90');
 
652
        $this->assertEquals(array(true, 'rotate', array(180)),
 
653
            $toolkit->mergeOperations('rotate', array(-90), 'rotate', array(-90)),
 
654
            'rotate -90 -90');
 
655
        $this->assertEquals(array(true, 'rotate', array(-90)),
 
656
            $toolkit->mergeOperations('rotate', array(180), 'rotate', array(90)),
 
657
            'rotate 180 90');
 
658
        $this->assertEquals(array(true, null, null),
 
659
            $toolkit->mergeOperations('rotate', array(180), 'rotate', array(180)),
 
660
            'rotate 180 180');
 
661
    }
619
662
}
620
663
 
621
664
/**
624
667
 * @package GalleryCore
625
668
 * @subpackage PHPUnit
626
669
 */
627
 
class TestToolkit { }
 
670
class TestToolkit extends GalleryToolkit { }
628
671
class TestToolkit2 { }
629
672
?>