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

<?php

require_once 'application/LinkFilter.php';

/**
 * Class LinkFilterTest.
 */
class LinkFilterTest extends PHPUnit_Framework_TestCase
{
    /**
     * @var LinkFilter instance.
     */
    protected static $linkFilter;

    /**
     * @var ReferenceLinkDB instance
     */
    protected static $refDB;

    /**
     * Instanciate linkFilter with ReferenceLinkDB data.
     */
    public static function setUpBeforeClass()
    {
        self::$refDB = new ReferenceLinkDB();
        self::$linkFilter = new LinkFilter(self::$refDB->getLinks());
    }

    /**
     * Blank filter.
     */
    public function testFilter()
    {
        $this->assertEquals(
            self::$refDB->countLinks(),
            count(self::$linkFilter->filter('', ''))
        );

        $this->assertEquals(
            self::$refDB->countLinks(),
            count(self::$linkFilter->filter('', '', 'all'))
        );

        $this->assertEquals(
            self::$refDB->countLinks(),
            count(self::$linkFilter->filter('', '', 'randomstr'))
        );

        // Private only.
        $this->assertEquals(
            self::$refDB->countPrivateLinks(),
            count(self::$linkFilter->filter('', '', false, 'private'))
        );

        // Public only.
        $this->assertEquals(
            self::$refDB->countPublicLinks(),
            count(self::$linkFilter->filter('', '', false, 'public'))
        );

        $this->assertEquals(
            ReferenceLinkDB::$NB_LINKS_TOTAL,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, ''))
        );

        $this->assertEquals(
            ReferenceLinkDB::$NB_LINKS_TOTAL,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, ''))
        );
    }

    /**
     * Filter links using a tag
     */
    public function testFilterOneTag()
    {
        $this->assertEquals(
            4,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false))
        );

        $this->assertEquals(
            4,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'all'))
        );

        $this->assertEquals(
            4,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'default-blabla'))
        );

        // Private only.
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'private'))
        );

        // Public only.
        $this->assertEquals(
            3,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'public'))
        );
    }

    /**
     * Filter links using a tag - case-sensitive
     */
    public function testFilterCaseSensitiveTag()
    {
        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'mercurial', true))
        );

        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'Mercurial', true))
        );
    }

    /**
     * Filter links using a tag combination
     */
    public function testFilterMultipleTags()
    {
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'dev cartoon', false))
        );
    }

    /**
     * Filter links using a non-existent tag
     */
    public function testFilterUnknownTag()
    {
        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'null', false))
        );
    }

    /**
     * Return links for a given day
     */
    public function testFilterDay()
    {
        $this->assertEquals(
            3,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '20121206'))
        );
    }

    /**
     * 404 - day not found
     */
    public function testFilterUnknownDay()
    {
        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '19700101'))
        );
    }

    /**
     * Use an invalid date format
     * @expectedException              Exception
     * @expectedExceptionMessageRegExp /Invalid date format/
     */
    public function testFilterInvalidDayWithChars()
    {
        self::$linkFilter->filter(LinkFilter::$FILTER_DAY, 'Rainy day, dream away');
    }

    /**
     * Use an invalid date format
     * @expectedException              Exception
     * @expectedExceptionMessageRegExp /Invalid date format/
     */
    public function testFilterInvalidDayDigits()
    {
        self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '20');
    }

    /**
     * Retrieve a link entry with its hash
     */
    public function testFilterSmallHash()
    {
        $links = self::$linkFilter->filter(LinkFilter::$FILTER_HASH, 'IuWvgA');

        $this->assertEquals(
            1,
            count($links)
        );

        $this->assertEquals(
            'MediaGoblin',
            $links[7]['title']
        );
    }

    /**
     * No link for this hash
     *
     * @expectedException LinkNotFoundException
     */
    public function testFilterUnknownSmallHash()
    {
        self::$linkFilter->filter(LinkFilter::$FILTER_HASH, 'Iblaah');
    }

    /**
     * Full-text search - no result found.
     */
    public function testFilterFullTextNoResult()
    {
        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'azertyuiop'))
        );
    }

    /**
     * Full-text search - result from a link's URL
     */
    public function testFilterFullTextURL()
    {
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'ars.userfriendly.org'))
        );
        
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'ars org'))
        );
    }

    /**
     * Full-text search - result from a link's title only
     */
    public function testFilterFullTextTitle()
    {
        // use miscellaneous cases
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'userfriendly -'))
        );
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'UserFriendly -'))
        );
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'uSeRFrIendlY -'))
        );

        // use miscellaneous case and offset
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'RFrIendL'))
        );
    }

    /**
     * Full-text search - result from the link's description only
     */
    public function testFilterFullTextDescription()
    {
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'publishing media'))
        );
        
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'mercurial w3c'))
        );
        
        $this->assertEquals(
            3,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, '"free software"'))
        );        
    }

    /**
     * Full-text search - result from the link's tags only
     */
    public function testFilterFullTextTags()
    {
        $this->assertEquals(
            6,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web'))
        );

        $this->assertEquals(
            6,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', 'all'))
        );

        $this->assertEquals(
            6,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', 'bla'))
        );

        // Private only.
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', false, 'private'))
        );

        // Public only.
        $this->assertEquals(
            5,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', false, 'public'))
        );
    }

    /**
     * Full-text search - result set from mixed sources
     */
    public function testFilterFullTextMixed()
    {
        $this->assertEquals(
            3,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'free software'))
        );
    }

    /**
     * Full-text search - test exclusion with '-'.
     */
    public function testExcludeSearch()
    {
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'free -gnu'))
        );

        $this->assertEquals(
            7,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, '-revolution'))
        );
    }

    /**
     * Full-text search - test AND, exact terms and exclusion combined, across fields.
     */
    public function testMultiSearch()
    {
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TEXT,
                '"Free Software " stallman "read this" @website stuff'
            ))
        );

        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TEXT,
                '"free software " stallman "read this" -beard @website stuff'
            ))
        );
    }

    /**
     * Full-text search - make sure that exact search won't work across fields.
     */
    public function testSearchExactTermMultiFieldsKo()
    {
        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TEXT,
                '"designer naming"'
            ))
        );

        $this->assertEquals(
            0,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TEXT,
                '"designernaming"'
            ))
        );
    }

    /**
     * Tag search with exclusion.
     */
    public function testTagFilterWithExclusion()
    {
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'gnu -free'))
        );

        $this->assertEquals(
            7,
            count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, '-free'))
        );
    }

    /**
     * Test crossed search (terms + tags).
     */
    public function testFilterCrossedSearch()
    {
        $terms = '"Free Software " stallman "read this" @website stuff';
        $tags = 'free';
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
                array($tags, $terms)
            ))
        );
        $this->assertEquals(
            2,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
                array('', $terms)
            ))
        );
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
                array($tags, '')
            ))
        );
        $this->assertEquals(
            ReferenceLinkDB::$NB_LINKS_TOTAL,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG | LinkFilter::$FILTER_TEXT,
                ''
            ))
        );
    }

    /**
     * Filter links by #hashtag.
     */
    public function testFilterByHashtag()
    {
        $hashtag = 'hashtag';
        $this->assertEquals(
            3,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG,
                $hashtag
            ))
        );

        $hashtag = 'private';
        $this->assertEquals(
            1,
            count(self::$linkFilter->filter(
                LinkFilter::$FILTER_TAG,
                $hashtag,
                false,
                'private'
            ))
        );
    }
}
Commit	Line	Data
822bffce A	1	<?php
	2
	3	require_once 'application/LinkFilter.php';
	4
	5	/**
	6	* Class LinkFilterTest.
	7	*/
	8	class LinkFilterTest extends PHPUnit_Framework_TestCase
	9	{
	10	/**
	11	* @var LinkFilter instance.
	12	*/
	13	protected static $linkFilter;
	14
7f96d9ec A	15	/**
	16	* @var ReferenceLinkDB instance
	17	*/
	18	protected static $refDB;
	19
822bffce A	20	/**
	21	* Instanciate linkFilter with ReferenceLinkDB data.
	22	*/
	23	public static function setUpBeforeClass()
	24	{
7f96d9ec A	25	self::$refDB = new ReferenceLinkDB();
7f96d9ec A	26	self::$linkFilter = new LinkFilter(self::$refDB->getLinks());
822bffce A	27	}
	28
	29	/**
	30	* Blank filter.
	31	*/
	32	public function testFilter()
	33	{
	34	$this->assertEquals(
7f96d9ec	35	self::$refDB->countLinks(),
822bffce A	36	count(self::$linkFilter->filter('', ''))
	37	);
	38
7f96d9ec A	39	$this->assertEquals(
	40	self::$refDB->countLinks(),
	41	count(self::$linkFilter->filter('', '', 'all'))
	42	);
	43
	44	$this->assertEquals(
	45	self::$refDB->countLinks(),
	46	count(self::$linkFilter->filter('', '', 'randomstr'))
	47	);
	48
822bffce A	49	// Private only.
822bffce A	50	$this->assertEquals(
7f96d9ec A	51	self::$refDB->countPrivateLinks(),
	52	count(self::$linkFilter->filter('', '', false, 'private'))
	53	);
	54
	55	// Public only.
	56	$this->assertEquals(
	57	self::$refDB->countPublicLinks(),
	58	count(self::$linkFilter->filter('', '', false, 'public'))
822bffce	59	);
c51fae92 A	60
c51fae92 A	61	$this->assertEquals(
89baf23d	62	ReferenceLinkDB::$NB_LINKS_TOTAL,
c51fae92 A	63	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, ''))
	64	);
	65
	66	$this->assertEquals(
89baf23d	67	ReferenceLinkDB::$NB_LINKS_TOTAL,
c51fae92 A	68	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, ''))
c51fae92 A	69	);
822bffce A	70	}
	71
	72	/**
	73	* Filter links using a tag
	74	*/
	75	public function testFilterOneTag()
	76	{
	77	$this->assertEquals(
	78	4,
	79	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false))
	80	);
	81
7f96d9ec A	82	$this->assertEquals(
	83	4,
	84	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'all'))
	85	);
	86
	87	$this->assertEquals(
	88	4,
	89	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'default-blabla'))
	90	);
	91
822bffce A	92	// Private only.
	93	$this->assertEquals(
	94	1,
7f96d9ec A	95	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'private'))
	96	);
	97
	98	// Public only.
	99	$this->assertEquals(
	100	3,
	101	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'web', false, 'public'))
822bffce A	102	);
	103	}
	104
	105	/**
	106	* Filter links using a tag - case-sensitive
	107	*/
	108	public function testFilterCaseSensitiveTag()
	109	{
	110	$this->assertEquals(
	111	0,
	112	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'mercurial', true))
	113	);
	114
	115	$this->assertEquals(
	116	1,
	117	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'Mercurial', true))
	118	);
	119	}
	120
	121	/**
	122	* Filter links using a tag combination
	123	*/
	124	public function testFilterMultipleTags()
	125	{
	126	$this->assertEquals(
	127	2,
	128	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'dev cartoon', false))
	129	);
	130	}
	131
	132	/**
	133	* Filter links using a non-existent tag
	134	*/
	135	public function testFilterUnknownTag()
	136	{
	137	$this->assertEquals(
	138	0,
	139	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'null', false))
	140	);
	141	}
	142
	143	/**
	144	* Return links for a given day
	145	*/
	146	public function testFilterDay()
	147	{
	148	$this->assertEquals(
	149	3,
	150	count(self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '20121206'))
	151	);
	152	}
	153
	154	/**
	155	* 404 - day not found
	156	*/
	157	public function testFilterUnknownDay()
	158	{
	159	$this->assertEquals(
	160	0,
	161	count(self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '19700101'))
	162	);
	163	}
	164
	165	/**
166	* Use an invalid date format
167	* @expectedException Exception
168	* @expectedExceptionMessageRegExp /Invalid date format/
169	*/
170	public function testFilterInvalidDayWithChars()
171	{
172	self::$linkFilter->filter(LinkFilter::$FILTER_DAY, 'Rainy day, dream away');
173	}
174
175	/**
176	* Use an invalid date format
177	* @expectedException Exception
178	* @expectedExceptionMessageRegExp /Invalid date format/
179	*/
180	public function testFilterInvalidDayDigits()
181	{
182	self::$linkFilter->filter(LinkFilter::$FILTER_DAY, '20');
183	}
184
185	/**
186	* Retrieve a link entry with its hash
187	*/
188	public function testFilterSmallHash()
189	{
190	$links = self::$linkFilter->filter(LinkFilter::$FILTER_HASH, 'IuWvgA');
191
192	$this->assertEquals(
193	1,
194	count($links)
195	);
196
197	$this->assertEquals(
198	'MediaGoblin',
c3dfd899	199	$links[7]['title']
822bffce A	200	);
	201	}
	202
	203	/**
	204	* No link for this hash
528a6f8a A	205	*
528a6f8a A	206	* @expectedException LinkNotFoundException
822bffce A	207	*/
	208	public function testFilterUnknownSmallHash()
	209	{
528a6f8a	210	self::$linkFilter->filter(LinkFilter::$FILTER_HASH, 'Iblaah');
822bffce A	211	}
822bffce A	212
522b278b A	213	/**
	214	* Full-text search - no result found.
	215	*/
	216	public function testFilterFullTextNoResult()
	217	{
	218	$this->assertEquals(
	219	0,
	220	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'azertyuiop'))
	221	);
	222	}
	223
822bffce A	224	/**
	225	* Full-text search - result from a link's URL
	226	*/
	227	public function testFilterFullTextURL()
	228	{
	229	$this->assertEquals(
	230	2,
	231	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'ars.userfriendly.org'))
	232	);
ebd8075a FV	233
	234	$this->assertEquals(
	235	2,
	236	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'ars org'))
	237	);
822bffce A	238	}
	239
	240	/**
	241	* Full-text search - result from a link's title only
	242	*/
	243	public function testFilterFullTextTitle()
	244	{
	245	// use miscellaneous cases
	246	$this->assertEquals(
	247	2,
	248	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'userfriendly -'))
	249	);
	250	$this->assertEquals(
	251	2,
	252	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'UserFriendly -'))
	253	);
	254	$this->assertEquals(
	255	2,
	256	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'uSeRFrIendlY -'))
	257	);
	258
	259	// use miscellaneous case and offset
	260	$this->assertEquals(
	261	2,
	262	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'RFrIendL'))
	263	);
	264	}
	265
	266	/**
	267	* Full-text search - result from the link's description only
	268	*/
	269	public function testFilterFullTextDescription()
	270	{
	271	$this->assertEquals(
	272	1,
ebd8075a FV	273	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'publishing media'))
	274	);
	275
	276	$this->assertEquals(
	277	1,
	278	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'mercurial w3c'))
822bffce	279	);
ebd8075a FV	280
ebd8075a FV	281	$this->assertEquals(
bedd176a	282	3,
ebd8075a FV	283	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, '"free software"'))
ebd8075a FV	284	);
822bffce A	285	}
	286
	287	/**
	288	* Full-text search - result from the link's tags only
	289	*/
	290	public function testFilterFullTextTags()
	291	{
	292	$this->assertEquals(
7f96d9ec A	293	6,
	294	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web'))
	295	);
	296
	297	$this->assertEquals(
	298	6,
	299	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', 'all'))
	300	);
	301
	302	$this->assertEquals(
	303	6,
	304	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', 'bla'))
822bffce A	305	);
	306
	307	// Private only.
	308	$this->assertEquals(
	309	1,
7f96d9ec A	310	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', false, 'private'))
	311	);
	312
	313	// Public only.
	314	$this->assertEquals(
	315	5,
	316	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'web', false, 'public'))
822bffce A	317	);
	318	}
	319
	320	/**
	321	* Full-text search - result set from mixed sources
	322	*/
	323	public function testFilterFullTextMixed()
	324	{
	325	$this->assertEquals(
bedd176a	326	3,
822bffce A	327	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'free software'))
	328	);
	329	}
21979ff1	330
bedd176a A	331	/**
	332	* Full-text search - test exclusion with '-'.
	333	*/
	334	public function testExcludeSearch()
	335	{
	336	$this->assertEquals(
	337	1,
522b278b	338	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, 'free -gnu'))
bedd176a A	339	);
	340
	341	$this->assertEquals(
c3dfd899	342	7,
522b278b	343	count(self::$linkFilter->filter(LinkFilter::$FILTER_TEXT, '-revolution'))
bedd176a A	344	);
	345	}
	346
	347	/**
522b278b	348	* Full-text search - test AND, exact terms and exclusion combined, across fields.
bedd176a A	349	*/
	350	public function testMultiSearch()
	351	{
	352	$this->assertEquals(
	353	2,
522b278b A	354	count(self::$linkFilter->filter(
	355	LinkFilter::$FILTER_TEXT,
	356	'"Free Software " stallman "read this" @website stuff'
	357	))
bedd176a A	358	);
	359
	360	$this->assertEquals(
	361	1,
522b278b A	362	count(self::$linkFilter->filter(
	363	LinkFilter::$FILTER_TEXT,
	364	'"free software " stallman "read this" -beard @website stuff'
	365	))
	366	);
	367	}
	368
	369	/**
	370	* Full-text search - make sure that exact search won't work across fields.
	371	*/
	372	public function testSearchExactTermMultiFieldsKo()
	373	{
	374	$this->assertEquals(
	375	0,
	376	count(self::$linkFilter->filter(
	377	LinkFilter::$FILTER_TEXT,
	378	'"designer naming"'
	379	))
	380	);
	381
	382	$this->assertEquals(
	383	0,
	384	count(self::$linkFilter->filter(
	385	LinkFilter::$FILTER_TEXT,
	386	'"designernaming"'
	387	))
bedd176a A	388	);
	389	}
	390
21979ff1 A	391	/**
	392	* Tag search with exclusion.
	393	*/
	394	public function testTagFilterWithExclusion()
	395	{
	396	$this->assertEquals(
	397	1,
	398	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, 'gnu -free'))
	399	);
	400
	401	$this->assertEquals(
c3dfd899	402	7,
21979ff1 A	403	count(self::$linkFilter->filter(LinkFilter::$FILTER_TAG, '-free'))
	404	);
	405	}
c51fae92 A	406
	407	/**
	408	* Test crossed search (terms + tags).
	409	*/
	410	public function testFilterCrossedSearch()
	411	{
	412	$terms = '"Free Software " stallman "read this" @website stuff';
	413	$tags = 'free';
	414	$this->assertEquals(
	415	1,
	416	count(self::$linkFilter->filter(
	417	LinkFilter::$FILTER_TAG \| LinkFilter::$FILTER_TEXT,
	418	array($tags, $terms)
	419	))
	420	);
	421	$this->assertEquals(
	422	2,
	423	count(self::$linkFilter->filter(
	424	LinkFilter::$FILTER_TAG \| LinkFilter::$FILTER_TEXT,
	425	array('', $terms)
	426	))
	427	);
	428	$this->assertEquals(
	429	1,
	430	count(self::$linkFilter->filter(
	431	LinkFilter::$FILTER_TAG \| LinkFilter::$FILTER_TEXT,
	432	array($tags, '')
	433	))
	434	);
	435	$this->assertEquals(
89baf23d	436	ReferenceLinkDB::$NB_LINKS_TOTAL,
c51fae92 A	437	count(self::$linkFilter->filter(
	438	LinkFilter::$FILTER_TAG \| LinkFilter::$FILTER_TEXT,
	439	''
	440	))
	441	);
	442	}
9ccca401 A	443
	444	/**
	445	* Filter links by #hashtag.
	446	*/
	447	public function testFilterByHashtag()
	448	{
	449	$hashtag = 'hashtag';
	450	$this->assertEquals(
	451	3,
	452	count(self::$linkFilter->filter(
	453	LinkFilter::$FILTER_TAG,
	454	$hashtag
	455	))
	456	);
	457
	458	$hashtag = 'private';
	459	$this->assertEquals(
	460	1,
	461	count(self::$linkFilter->filter(
	462	LinkFilter::$FILTER_TAG,
	463	$hashtag,
	464	false,
7f96d9ec	465	'private'
9ccca401 A	466	))
	467	);
	468	}
822bffce	469	}