[github/shaarli/Shaarli.git] / tests / RouterTest.php

<?php

/**
 * Router tests
 */

require_once 'application/Router.php';

/**
 * Unit tests for Router
 */
class RouterTest extends PHPUnit_Framework_TestCase
{
    /**
     * Test findPage: login page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPageLoginValid()
    {
        $this->assertEquals(
            Router::$PAGE_LOGIN,
            Router::findPage('do=login', array(), false)
        );

        $this->assertEquals(
            Router::$PAGE_LOGIN,
            Router::findPage('do=login', array(), 1)
        );

        $this->assertEquals(
            Router::$PAGE_LOGIN,
            Router::findPage('do=login&stuff', array(), false)
        );
    }

    /**
     * Test findPage: login page output.
     * Invalid: page shouldn't be return.
     *
     * @return void
     */
    public function testFindPageLoginInvalid()
    {
        $this->assertNotEquals(
            Router::$PAGE_LOGIN,
            Router::findPage('do=login', array(), true)
        );

        $this->assertNotEquals(
            Router::$PAGE_LOGIN,
            Router::findPage('do=other', array(), false)
        );
    }

    /**
     * Test findPage: picwall page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPagePicwallValid()
    {
        $this->assertEquals(
            Router::$PAGE_PICWALL,
            Router::findPage('do=picwall', array(), false)
        );

        $this->assertEquals(
            Router::$PAGE_PICWALL,
            Router::findPage('do=picwall', array(), true)
        );
    }

    /**
     * Test findPage: picwall page output.
     * Invalid: page shouldn't be return.
     *
     * @return void
     */
    public function testFindPagePicwallInvalid()
    {
        $this->assertEquals(
            Router::$PAGE_PICWALL,
            Router::findPage('do=picwall&stuff', array(), false)
        );

        $this->assertNotEquals(
            Router::$PAGE_PICWALL,
            Router::findPage('do=other', array(), false)
        );
    }

    /**
     * Test findPage: tagcloud page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPageTagcloudValid()
    {
        $this->assertEquals(
            Router::$PAGE_TAGCLOUD,
            Router::findPage('do=tagcloud', array(), false)
        );

        $this->assertEquals(
            Router::$PAGE_TAGCLOUD,
            Router::findPage('do=tagcloud', array(), true)
        );

        $this->assertEquals(
            Router::$PAGE_TAGCLOUD,
            Router::findPage('do=tagcloud&stuff', array(), false)
        );
    }

    /**
     * Test findPage: tagcloud page output.
     * Invalid: page shouldn't be return.
     *
     * @return void
     */
    public function testFindPageTagcloudInvalid()
    {
        $this->assertNotEquals(
            Router::$PAGE_TAGCLOUD,
            Router::findPage('do=other', array(), false)
        );
    }

    /**
     * Test findPage: linklist page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPageLinklistValid()
    {
        $this->assertEquals(
            Router::$PAGE_LINKLIST,
            Router::findPage('', array(), true)
        );

        $this->assertEquals(
            Router::$PAGE_LINKLIST,
            Router::findPage('whatever', array(), true)
        );

        $this->assertEquals(
            Router::$PAGE_LINKLIST,
            Router::findPage('whatever', array(), false)
        );

        $this->assertEquals(
            Router::$PAGE_LINKLIST,
            Router::findPage('do=tools', array(), false)
        );
    }

    /**
     * Test findPage: tools page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPageToolsValid()
    {
        $this->assertEquals(
            Router::$PAGE_TOOLS,
            Router::findPage('do=tools', array(), true)
        );

        $this->assertEquals(
            Router::$PAGE_TOOLS,
            Router::findPage('do=tools&stuff', array(), true)
        );
    }

    /**
     * Test findPage: tools page output.
     * Invalid: page shouldn't be return.
     *
     * @return void
     */
    public function testFindPageToolsInvalid()
    {
        $this->assertNotEquals(
            Router::$PAGE_TOOLS,
            Router::findPage('do=tools', array(), 1)
        );

        $this->assertNotEquals(
            Router::$PAGE_TOOLS,
            Router::findPage('do=tools', array(), false)
        );

        $this->assertNotEquals(
            Router::$PAGE_TOOLS,
            Router::findPage('do=other', array(), true)
        );
    }

    /**
     * Test findPage: changepasswd page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPageChangepasswdValid()
    {
        $this->assertEquals(
            Router::$PAGE_CHANGEPASSWORD,
            Router::findPage('do=changepasswd', array(), true)
        );
        $this->assertEquals(
            Router::$PAGE_CHANGEPASSWORD,
            Router::findPage('do=changepasswd&stuff', array(), true)
        );
    }

    /**
     * Test findPage: changepasswd page output.
     * Invalid: page shouldn't be return.
     *
     * @return void
     */
    public function testFindPageChangepasswdInvalid()
    {
        $this->assertNotEquals(
            Router::$PAGE_CHANGEPASSWORD,
            Router::findPage('do=changepasswd', array(), 1)
        );

        $this->assertNotEquals(
            Router::$PAGE_CHANGEPASSWORD,
            Router::findPage('do=changepasswd', array(), false)
        );

        $this->assertNotEquals(
            Router::$PAGE_CHANGEPASSWORD,
            Router::findPage('do=other', array(), true)
        );
    }
    /**
     * Test findPage: configure page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPageConfigureValid()
    {
        $this->assertEquals(
            Router::$PAGE_CONFIGURE,
            Router::findPage('do=configure', array(), true)
        );

        $this->assertEquals(
            Router::$PAGE_CONFIGURE,
            Router::findPage('do=configure&stuff', array(), true)
        );
    }

    /**
     * Test findPage: configure page output.
     * Invalid: page shouldn't be return.
     *
     * @return void
     */
    public function testFindPageConfigureInvalid()
    {
        $this->assertNotEquals(
            Router::$PAGE_CONFIGURE,
            Router::findPage('do=configure', array(), 1)
        );

        $this->assertNotEquals(
            Router::$PAGE_CONFIGURE,
            Router::findPage('do=configure', array(), false)
        );

        $this->assertNotEquals(
            Router::$PAGE_CONFIGURE,
            Router::findPage('do=other', array(), true)
        );
    }

    /**
     * Test findPage: changetag page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPageChangetagValid()
    {
        $this->assertEquals(
            Router::$PAGE_CHANGETAG,
            Router::findPage('do=changetag', array(), true)
        );

        $this->assertEquals(
            Router::$PAGE_CHANGETAG,
            Router::findPage('do=changetag&stuff', array(), true)
        );
    }

    /**
     * Test findPage: changetag page output.
     * Invalid: page shouldn't be return.
     *
     * @return void
     */
    public function testFindPageChangetagInvalid()
    {
        $this->assertNotEquals(
            Router::$PAGE_CHANGETAG,
            Router::findPage('do=changetag', array(), 1)
        );

        $this->assertNotEquals(
            Router::$PAGE_CHANGETAG,
            Router::findPage('do=changetag', array(), false)
        );

        $this->assertNotEquals(
            Router::$PAGE_CHANGETAG,
            Router::findPage('do=other', array(), true)
        );
    }

    /**
     * Test findPage: addlink page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPageAddlinkValid()
    {
        $this->assertEquals(
            Router::$PAGE_ADDLINK,
            Router::findPage('do=addlink', array(), true)
        );

        $this->assertEquals(
            Router::$PAGE_ADDLINK,
            Router::findPage('do=addlink&stuff', array(), true)
        );
    }

    /**
     * Test findPage: addlink page output.
     * Invalid: page shouldn't be return.
     *
     * @return void
     */
    public function testFindPageAddlinkInvalid()
    {
        $this->assertNotEquals(
            Router::$PAGE_ADDLINK,
            Router::findPage('do=addlink', array(), 1)
        );

        $this->assertNotEquals(
            Router::$PAGE_ADDLINK,
            Router::findPage('do=addlink', array(), false)
        );

        $this->assertNotEquals(
            Router::$PAGE_ADDLINK,
            Router::findPage('do=other', array(), true)
        );
    }

    /**
     * Test findPage: export page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPageExportValid()
    {
        $this->assertEquals(
            Router::$PAGE_EXPORT,
            Router::findPage('do=export', array(), true)
        );

        $this->assertEquals(
            Router::$PAGE_EXPORT,
            Router::findPage('do=export&stuff', array(), true)
        );
    }

    /**
     * Test findPage: export page output.
     * Invalid: page shouldn't be return.
     *
     * @return void
     */
    public function testFindPageExportInvalid()
    {
        $this->assertNotEquals(
            Router::$PAGE_EXPORT,
            Router::findPage('do=export', array(), 1)
        );

        $this->assertNotEquals(
            Router::$PAGE_EXPORT,
            Router::findPage('do=export', array(), false)
        );

        $this->assertNotEquals(
            Router::$PAGE_EXPORT,
            Router::findPage('do=other', array(), true)
        );
    }

    /**
     * Test findPage: import page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPageImportValid()
    {
        $this->assertEquals(
            Router::$PAGE_IMPORT,
            Router::findPage('do=import', array(), true)
        );

        $this->assertEquals(
            Router::$PAGE_IMPORT,
            Router::findPage('do=import&stuff', array(), true)
        );
    }

    /**
     * Test findPage: import page output.
     * Invalid: page shouldn't be return.
     *
     * @return void
     */
    public function testFindPageImportInvalid()
    {
        $this->assertNotEquals(
            Router::$PAGE_IMPORT,
            Router::findPage('do=import', array(), 1)
        );

        $this->assertNotEquals(
            Router::$PAGE_IMPORT,
            Router::findPage('do=import', array(), false)
        );

        $this->assertNotEquals(
            Router::$PAGE_IMPORT,
            Router::findPage('do=other', array(), true)
        );
    }

    /**
     * Test findPage: editlink page output.
     * Valid: page should be return.
     *
     * @return void
     */
    public function testFindPageEditlinkValid()
    {
        $this->assertEquals(
            Router::$PAGE_EDITLINK,
            Router::findPage('whatever', array('edit_link' => 1), true)
        );

        $this->assertEquals(
            Router::$PAGE_EDITLINK,
            Router::findPage('', array('edit_link' => 1), true)
        );


        $this->assertEquals(
            Router::$PAGE_EDITLINK,
            Router::findPage('whatever', array('post' => 1), true)
        );

        $this->assertEquals(
            Router::$PAGE_EDITLINK,
            Router::findPage('whatever', array('post' => 1, 'edit_link' => 1), true)
        );
    }

    /**
     * Test findPage: editlink page output.
     * Invalid: page shouldn't be return.
     *
     * @return void
     */
    public function testFindPageEditlinkInvalid()
    {
        $this->assertNotEquals(
            Router::$PAGE_EDITLINK,
            Router::findPage('whatever', array('edit_link' => 1), false)
        );

        $this->assertNotEquals(
            Router::$PAGE_EDITLINK,
            Router::findPage('whatever', array('edit_link' => 1), 1)
        );

        $this->assertNotEquals(
            Router::$PAGE_EDITLINK,
            Router::findPage('whatever', array(), true)
        );
    }
}
Commit	Line	Data
6fc14d53 A	1	<?php
	2
	3	/**
	4	* Router tests
	5	*/
	6
	7	require_once 'application/Router.php';
	8
	9	/**
	10	* Unit tests for Router
	11	*/
	12	class RouterTest extends PHPUnit_Framework_TestCase
	13	{
	14	/**
	15	* Test findPage: login page output.
	16	* Valid: page should be return.
	17	*
	18	* @return void
	19	*/
	20	public function testFindPageLoginValid()
	21	{
	22	$this->assertEquals(
	23	Router::$PAGE_LOGIN,
	24	Router::findPage('do=login', array(), false)
	25	);
	26
	27	$this->assertEquals(
	28	Router::$PAGE_LOGIN,
	29	Router::findPage('do=login', array(), 1)
	30	);
	31
	32	$this->assertEquals(
	33	Router::$PAGE_LOGIN,
	34	Router::findPage('do=login&stuff', array(), false)
	35	);
	36	}
	37
	38	/**
	39	* Test findPage: login page output.
	40	* Invalid: page shouldn't be return.
	41	*
	42	* @return void
	43	*/
	44	public function testFindPageLoginInvalid()
	45	{
	46	$this->assertNotEquals(
	47	Router::$PAGE_LOGIN,
	48	Router::findPage('do=login', array(), true)
	49	);
	50
	51	$this->assertNotEquals(
	52	Router::$PAGE_LOGIN,
	53	Router::findPage('do=other', array(), false)
	54	);
	55	}
	56
	57	/**
	58	* Test findPage: picwall page output.
	59	* Valid: page should be return.
	60	*
	61	* @return void
	62	*/
	63	public function testFindPagePicwallValid()
	64	{
65	$this->assertEquals(
66	Router::$PAGE_PICWALL,
67	Router::findPage('do=picwall', array(), false)
68	);
69
70	$this->assertEquals(
71	Router::$PAGE_PICWALL,
72	Router::findPage('do=picwall', array(), true)
73	);
74	}
75
76	/**
77	* Test findPage: picwall page output.
78	* Invalid: page shouldn't be return.
79	*
80	* @return void
81	*/
82	public function testFindPagePicwallInvalid()
83	{
84	$this->assertEquals(
85	Router::$PAGE_PICWALL,
86	Router::findPage('do=picwall&stuff', array(), false)
87	);
88
89	$this->assertNotEquals(
90	Router::$PAGE_PICWALL,
91	Router::findPage('do=other', array(), false)
92	);
93	}
94
95	/**
96	* Test findPage: tagcloud page output.
97	* Valid: page should be return.
98	*
99	* @return void
100	*/
101	public function testFindPageTagcloudValid()
102	{
103	$this->assertEquals(
104	Router::$PAGE_TAGCLOUD,
105	Router::findPage('do=tagcloud', array(), false)
106	);
107
108	$this->assertEquals(
109	Router::$PAGE_TAGCLOUD,
110	Router::findPage('do=tagcloud', array(), true)
111	);
112
113	$this->assertEquals(
114	Router::$PAGE_TAGCLOUD,
115	Router::findPage('do=tagcloud&stuff', array(), false)
116	);
117	}
118
119	/**
120	* Test findPage: tagcloud page output.
121	* Invalid: page shouldn't be return.
122	*
123	* @return void
124	*/
125	public function testFindPageTagcloudInvalid()
126	{
127	$this->assertNotEquals(
128	Router::$PAGE_TAGCLOUD,
129	Router::findPage('do=other', array(), false)
130	);
131	}
132
133	/**
134	* Test findPage: linklist page output.
135	* Valid: page should be return.
136	*
137	* @return void
138	*/
139	public function testFindPageLinklistValid()
140	{
141	$this->assertEquals(
142	Router::$PAGE_LINKLIST,
143	Router::findPage('', array(), true)
144	);
145
146	$this->assertEquals(
147	Router::$PAGE_LINKLIST,
148	Router::findPage('whatever', array(), true)
149	);
150
151	$this->assertEquals(
152	Router::$PAGE_LINKLIST,
153	Router::findPage('whatever', array(), false)
154	);
155
156	$this->assertEquals(
157	Router::$PAGE_LINKLIST,
158	Router::findPage('do=tools', array(), false)
159	);
160	}
161
162	/**
163	* Test findPage: tools page output.
164	* Valid: page should be return.
165	*
166	* @return void
167	*/
168	public function testFindPageToolsValid()
169	{
170	$this->assertEquals(
171	Router::$PAGE_TOOLS,
172	Router::findPage('do=tools', array(), true)
173	);
174
175	$this->assertEquals(
176	Router::$PAGE_TOOLS,
177	Router::findPage('do=tools&stuff', array(), true)
178	);
179	}
180
181	/**
182	* Test findPage: tools page output.
183	* Invalid: page shouldn't be return.
184	*
185	* @return void
186	*/
187	public function testFindPageToolsInvalid()
188	{
189	$this->assertNotEquals(
190	Router::$PAGE_TOOLS,
191	Router::findPage('do=tools', array(), 1)
192	);
193
194	$this->assertNotEquals(
195	Router::$PAGE_TOOLS,
196	Router::findPage('do=tools', array(), false)
197	);
198
199	$this->assertNotEquals(
200	Router::$PAGE_TOOLS,
201	Router::findPage('do=other', array(), true)
202	);
203	}
204
205	/**
206	* Test findPage: changepasswd page output.
207	* Valid: page should be return.
208	*
209	* @return void
210	*/
211	public function testFindPageChangepasswdValid()
212	{
213	$this->assertEquals(
214	Router::$PAGE_CHANGEPASSWORD,
215	Router::findPage('do=changepasswd', array(), true)
216	);
217	$this->assertEquals(
218	Router::$PAGE_CHANGEPASSWORD,
219	Router::findPage('do=changepasswd&stuff', array(), true)
220	);
6fc14d53 A	221	}
	222
	223	/**
	224	* Test findPage: changepasswd page output.
	225	* Invalid: page shouldn't be return.
	226	*
	227	* @return void
	228	*/
	229	public function testFindPageChangepasswdInvalid()
	230	{
	231	$this->assertNotEquals(
	232	Router::$PAGE_CHANGEPASSWORD,
	233	Router::findPage('do=changepasswd', array(), 1)
	234	);
	235
	236	$this->assertNotEquals(
	237	Router::$PAGE_CHANGEPASSWORD,
	238	Router::findPage('do=changepasswd', array(), false)
	239	);
	240
	241	$this->assertNotEquals(
	242	Router::$PAGE_CHANGEPASSWORD,
	243	Router::findPage('do=other', array(), true)
	244	);
	245	}
	246	/**
	247	* Test findPage: configure page output.
	248	* Valid: page should be return.
	249	*
	250	* @return void
	251	*/
	252	public function testFindPageConfigureValid()
	253	{
	254	$this->assertEquals(
	255	Router::$PAGE_CONFIGURE,
	256	Router::findPage('do=configure', array(), true)
	257	);
	258
	259	$this->assertEquals(
	260	Router::$PAGE_CONFIGURE,
	261	Router::findPage('do=configure&stuff', array(), true)
	262	);
	263	}
	264
	265	/**
	266	* Test findPage: configure page output.
	267	* Invalid: page shouldn't be return.
	268	*
	269	* @return void
	270	*/
	271	public function testFindPageConfigureInvalid()
	272	{
	273	$this->assertNotEquals(
	274	Router::$PAGE_CONFIGURE,
	275	Router::findPage('do=configure', array(), 1)
	276	);
	277
	278	$this->assertNotEquals(
	279	Router::$PAGE_CONFIGURE,
	280	Router::findPage('do=configure', array(), false)
	281	);
	282
	283	$this->assertNotEquals(
	284	Router::$PAGE_CONFIGURE,
285	Router::findPage('do=other', array(), true)
286	);
287	}
288
289	/**
290	* Test findPage: changetag page output.
291	* Valid: page should be return.
292	*
293	* @return void
294	*/
295	public function testFindPageChangetagValid()
296	{
297	$this->assertEquals(
298	Router::$PAGE_CHANGETAG,
299	Router::findPage('do=changetag', array(), true)
300	);
301
302	$this->assertEquals(
303	Router::$PAGE_CHANGETAG,
304	Router::findPage('do=changetag&stuff', array(), true)
305	);
306	}
307
308	/**
309	* Test findPage: changetag page output.
310	* Invalid: page shouldn't be return.
311	*
312	* @return void
313	*/
314	public function testFindPageChangetagInvalid()
315	{
316	$this->assertNotEquals(
317	Router::$PAGE_CHANGETAG,
318	Router::findPage('do=changetag', array(), 1)
319	);
320
321	$this->assertNotEquals(
322	Router::$PAGE_CHANGETAG,
323	Router::findPage('do=changetag', array(), false)
324	);
325
326	$this->assertNotEquals(
327	Router::$PAGE_CHANGETAG,
328	Router::findPage('do=other', array(), true)
329	);
330	}
331
332	/**
333	* Test findPage: addlink page output.
334	* Valid: page should be return.
335	*
336	* @return void
337	*/
338	public function testFindPageAddlinkValid()
339	{
340	$this->assertEquals(
341	Router::$PAGE_ADDLINK,
342	Router::findPage('do=addlink', array(), true)
343	);
344
345	$this->assertEquals(
346	Router::$PAGE_ADDLINK,
347	Router::findPage('do=addlink&stuff', array(), true)
348	);
349	}
350
351	/**
352	* Test findPage: addlink page output.
353	* Invalid: page shouldn't be return.
354	*
355	* @return void
356	*/
357	public function testFindPageAddlinkInvalid()
358	{
359	$this->assertNotEquals(
360	Router::$PAGE_ADDLINK,
361	Router::findPage('do=addlink', array(), 1)
362	);
363
364	$this->assertNotEquals(
365	Router::$PAGE_ADDLINK,
366	Router::findPage('do=addlink', array(), false)
367	);
368
369	$this->assertNotEquals(
370	Router::$PAGE_ADDLINK,
371	Router::findPage('do=other', array(), true)
372	);
373	}
374
375	/**
376	* Test findPage: export page output.
377	* Valid: page should be return.
378	*
379	* @return void
380	*/
381	public function testFindPageExportValid()
382	{
383	$this->assertEquals(
384	Router::$PAGE_EXPORT,
385	Router::findPage('do=export', array(), true)
386	);
387
388	$this->assertEquals(
389	Router::$PAGE_EXPORT,
390	Router::findPage('do=export&stuff', array(), true)
391	);
392	}
393
394	/**
395	* Test findPage: export page output.
396	* Invalid: page shouldn't be return.
397	*
398	* @return void
399	*/
400	public function testFindPageExportInvalid()
401	{
402	$this->assertNotEquals(
403	Router::$PAGE_EXPORT,
404	Router::findPage('do=export', array(), 1)
405	);
406
407	$this->assertNotEquals(
408	Router::$PAGE_EXPORT,
409	Router::findPage('do=export', array(), false)
410	);
411
412	$this->assertNotEquals(
413	Router::$PAGE_EXPORT,
414	Router::findPage('do=other', array(), true)
415	);
416	}
417
418	/**
419	* Test findPage: import page output.
420	* Valid: page should be return.
421	*
422	* @return void
423	*/
424	public function testFindPageImportValid()
425	{
426	$this->assertEquals(
427	Router::$PAGE_IMPORT,
428	Router::findPage('do=import', array(), true)
429	);
430
431	$this->assertEquals(
432	Router::$PAGE_IMPORT,
433	Router::findPage('do=import&stuff', array(), true)
434	);
435	}
436
437	/**
438	* Test findPage: import page output.
439	* Invalid: page shouldn't be return.
440	*
441	* @return void
442	*/
443	public function testFindPageImportInvalid()
444	{
445	$this->assertNotEquals(
446	Router::$PAGE_IMPORT,
447	Router::findPage('do=import', array(), 1)
448	);
449
450	$this->assertNotEquals(
451	Router::$PAGE_IMPORT,
452	Router::findPage('do=import', array(), false)
453	);
454
455	$this->assertNotEquals(
456	Router::$PAGE_IMPORT,
457	Router::findPage('do=other', array(), true)
458	);
459	}
460
461	/**
462	* Test findPage: editlink page output.
463	* Valid: page should be return.
464	*
465	* @return void
466	*/
467	public function testFindPageEditlinkValid()
468	{
469	$this->assertEquals(
470	Router::$PAGE_EDITLINK,
471	Router::findPage('whatever', array('edit_link' => 1), true)
472	);
473
474	$this->assertEquals(
475	Router::$PAGE_EDITLINK,
476	Router::findPage('', array('edit_link' => 1), true)
477	);
478
479
480	$this->assertEquals(
481	Router::$PAGE_EDITLINK,
482	Router::findPage('whatever', array('post' => 1), true)
483	);
484
485	$this->assertEquals(
486	Router::$PAGE_EDITLINK,
487	Router::findPage('whatever', array('post' => 1, 'edit_link' => 1), true)
488	);
489	}
490
491	/**
492	* Test findPage: editlink page output.
493	* Invalid: page shouldn't be return.
494	*
495	* @return void
496	*/
497	public function testFindPageEditlinkInvalid()
498	{
499	$this->assertNotEquals(
500	Router::$PAGE_EDITLINK,
501	Router::findPage('whatever', array('edit_link' => 1), false)
502	);
503
504	$this->assertNotEquals(
505	Router::$PAGE_EDITLINK,
506	Router::findPage('whatever', array('edit_link' => 1), 1)
507	);
508
509	$this->assertNotEquals(
510	Router::$PAGE_EDITLINK,
511	Router::findPage('whatever', array(), true)
512	);
513	}
d06265fb	514	}