[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	);
221
222	}
223
224	/**
225	* Test findPage: changepasswd page output.
226	* Invalid: page shouldn't be return.
227	*
228	* @return void
229	*/
230	public function testFindPageChangepasswdInvalid()
231	{
232	$this->assertNotEquals(
233	Router::$PAGE_CHANGEPASSWORD,
234	Router::findPage('do=changepasswd', array(), 1)
235	);
236
237	$this->assertNotEquals(
238	Router::$PAGE_CHANGEPASSWORD,
239	Router::findPage('do=changepasswd', array(), false)
240	);
241
242	$this->assertNotEquals(
243	Router::$PAGE_CHANGEPASSWORD,
244	Router::findPage('do=other', array(), true)
245	);
246	}
247	/**
248	* Test findPage: configure page output.
249	* Valid: page should be return.
250	*
251	* @return void
252	*/
253	public function testFindPageConfigureValid()
254	{
255	$this->assertEquals(
256	Router::$PAGE_CONFIGURE,
257	Router::findPage('do=configure', array(), true)
258	);
259
260	$this->assertEquals(
261	Router::$PAGE_CONFIGURE,
262	Router::findPage('do=configure&stuff', array(), true)
263	);
264	}
265
266	/**
267	* Test findPage: configure page output.
268	* Invalid: page shouldn't be return.
269	*
270	* @return void
271	*/
272	public function testFindPageConfigureInvalid()
273	{
274	$this->assertNotEquals(
275	Router::$PAGE_CONFIGURE,
276	Router::findPage('do=configure', array(), 1)
277	);
278
279	$this->assertNotEquals(
280	Router::$PAGE_CONFIGURE,
281	Router::findPage('do=configure', array(), false)
282	);
283
284	$this->assertNotEquals(
285	Router::$PAGE_CONFIGURE,
286	Router::findPage('do=other', array(), true)
287	);
288	}
289
290	/**
291	* Test findPage: changetag page output.
292	* Valid: page should be return.
293	*
294	* @return void
295	*/
296	public function testFindPageChangetagValid()
297	{
298	$this->assertEquals(
299	Router::$PAGE_CHANGETAG,
300	Router::findPage('do=changetag', array(), true)
301	);
302
303	$this->assertEquals(
304	Router::$PAGE_CHANGETAG,
305	Router::findPage('do=changetag&stuff', array(), true)
306	);
307	}
308
309	/**
310	* Test findPage: changetag page output.
311	* Invalid: page shouldn't be return.
312	*
313	* @return void
314	*/
315	public function testFindPageChangetagInvalid()
316	{
317	$this->assertNotEquals(
318	Router::$PAGE_CHANGETAG,
319	Router::findPage('do=changetag', array(), 1)
320	);
321
322	$this->assertNotEquals(
323	Router::$PAGE_CHANGETAG,
324	Router::findPage('do=changetag', array(), false)
325	);
326
327	$this->assertNotEquals(
328	Router::$PAGE_CHANGETAG,
329	Router::findPage('do=other', array(), true)
330	);
331	}
332
333	/**
334	* Test findPage: addlink page output.
335	* Valid: page should be return.
336	*
337	* @return void
338	*/
339	public function testFindPageAddlinkValid()
340	{
341	$this->assertEquals(
342	Router::$PAGE_ADDLINK,
343	Router::findPage('do=addlink', array(), true)
344	);
345
346	$this->assertEquals(
347	Router::$PAGE_ADDLINK,
348	Router::findPage('do=addlink&stuff', array(), true)
349	);
350	}
351
352	/**
353	* Test findPage: addlink page output.
354	* Invalid: page shouldn't be return.
355	*
356	* @return void
357	*/
358	public function testFindPageAddlinkInvalid()
359	{
360	$this->assertNotEquals(
361	Router::$PAGE_ADDLINK,
362	Router::findPage('do=addlink', array(), 1)
363	);
364
365	$this->assertNotEquals(
366	Router::$PAGE_ADDLINK,
367	Router::findPage('do=addlink', array(), false)
368	);
369
370	$this->assertNotEquals(
371	Router::$PAGE_ADDLINK,
372	Router::findPage('do=other', array(), true)
373	);
374	}
375
376	/**
377	* Test findPage: export page output.
378	* Valid: page should be return.
379	*
380	* @return void
381	*/
382	public function testFindPageExportValid()
383	{
384	$this->assertEquals(
385	Router::$PAGE_EXPORT,
386	Router::findPage('do=export', array(), true)
387	);
388
389	$this->assertEquals(
390	Router::$PAGE_EXPORT,
391	Router::findPage('do=export&stuff', array(), true)
392	);
393	}
394
395	/**
396	* Test findPage: export page output.
397	* Invalid: page shouldn't be return.
398	*
399	* @return void
400	*/
401	public function testFindPageExportInvalid()
402	{
403	$this->assertNotEquals(
404	Router::$PAGE_EXPORT,
405	Router::findPage('do=export', array(), 1)
406	);
407
408	$this->assertNotEquals(
409	Router::$PAGE_EXPORT,
410	Router::findPage('do=export', array(), false)
411	);
412
413	$this->assertNotEquals(
414	Router::$PAGE_EXPORT,
415	Router::findPage('do=other', array(), true)
416	);
417	}
418
419	/**
420	* Test findPage: import page output.
421	* Valid: page should be return.
422	*
423	* @return void
424	*/
425	public function testFindPageImportValid()
426	{
427	$this->assertEquals(
428	Router::$PAGE_IMPORT,
429	Router::findPage('do=import', array(), true)
430	);
431
432	$this->assertEquals(
433	Router::$PAGE_IMPORT,
434	Router::findPage('do=import&stuff', array(), true)
435	);
436	}
437
438	/**
439	* Test findPage: import page output.
440	* Invalid: page shouldn't be return.
441	*
442	* @return void
443	*/
444	public function testFindPageImportInvalid()
445	{
446	$this->assertNotEquals(
447	Router::$PAGE_IMPORT,
448	Router::findPage('do=import', array(), 1)
449	);
450
451	$this->assertNotEquals(
452	Router::$PAGE_IMPORT,
453	Router::findPage('do=import', array(), false)
454	);
455
456	$this->assertNotEquals(
457	Router::$PAGE_IMPORT,
458	Router::findPage('do=other', array(), true)
459	);
460	}
461
462	/**
463	* Test findPage: editlink page output.
464	* Valid: page should be return.
465	*
466	* @return void
467	*/
468	public function testFindPageEditlinkValid()
469	{
470	$this->assertEquals(
471	Router::$PAGE_EDITLINK,
472	Router::findPage('whatever', array('edit_link' => 1), true)
473	);
474
475	$this->assertEquals(
476	Router::$PAGE_EDITLINK,
477	Router::findPage('', array('edit_link' => 1), true)
478	);
479
480
481	$this->assertEquals(
482	Router::$PAGE_EDITLINK,
483	Router::findPage('whatever', array('post' => 1), true)
484	);
485
486	$this->assertEquals(
487	Router::$PAGE_EDITLINK,
488	Router::findPage('whatever', array('post' => 1, 'edit_link' => 1), true)
489	);
490	}
491
492	/**
493	* Test findPage: editlink page output.
494	* Invalid: page shouldn't be return.
495	*
496	* @return void
497	*/
498	public function testFindPageEditlinkInvalid()
499	{
500	$this->assertNotEquals(
501	Router::$PAGE_EDITLINK,
502	Router::findPage('whatever', array('edit_link' => 1), false)
503	);
504
505	$this->assertNotEquals(
506	Router::$PAGE_EDITLINK,
507	Router::findPage('whatever', array('edit_link' => 1), 1)
508	);
509
510	$this->assertNotEquals(
511	Router::$PAGE_EDITLINK,
512	Router::findPage('whatever', array(), true)
513	);
514	}
d06265fb	515	}