TermListTest::testClear() - Code Metrics - Inspection of "Add clear to list classes" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — clear ( 11b8fa )

by Bene

created 2016-02-29 15:26 UTC

TermListTest::testClear() A

↳ Parent: TermListTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	9
rs	9.6666
cc	1
eloc	6
nc	1
nop	0

<?php

namespace Wikibase\DataModel\Tests\Term;

use InvalidArgumentException;
use Wikibase\DataModel\Term\Term;
use Wikibase\DataModel\Term\TermList;

/**
 * @covers Wikibase\DataModel\Term\TermList
 * @uses Wikibase\DataModel\Term\Term
 *
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < [email protected] >
 */
class TermListTest extends \PHPUnit_Framework_TestCase {

	public function testIsEmpty() {
		$list = new TermList();
		$this->assertTrue( $list->isEmpty() );

		$list = new TermList( array( new Term( 'en', 'foo' ) ) );
		$this->assertFalse( $list->isEmpty() );
	}

	public function testGivenNoTerms_sizeIsZero() {
		$list = new TermList();
		$this->assertCount( 0, $list );
	}

	public function testGivenTwoTerms_countReturnsTwo() {
		$list = new TermList( $this->getTwoTerms() );

		$this->assertCount( 2, $list );
	}

	private function getTwoTerms() {
		return array(
			'en' => new Term( 'en', 'foo' ),
			'de' => new Term( 'de', 'bar' ),
		);
	}

	public function testGivenTwoTerms_listContainsThem() {
		$array = $this->getTwoTerms();

		$list = new TermList( $array );

		$this->assertEquals( $array, iterator_to_array( $list ) );
	}

	public function testGivenTermsWithTheSameLanguage_onlyTheLastOnesAreRetained() {
		$array = array(
			new Term( 'en', 'foo' ),
			new Term( 'en', 'bar' ),

			new Term( 'de', 'baz' ),

			new Term( 'nl', 'bah' ),
			new Term( 'nl', 'blah' ),
			new Term( 'nl', 'spam' ),
		);

		$list = new TermList( $array );

		$this->assertEquals(
			array(
				'en' => new Term( 'en', 'bar' ),
				'de' => new Term( 'de', 'baz' ),
				'nl' => new Term( 'nl', 'spam' ),
			),
			iterator_to_array( $list )
		);
	}

	public function testGivenNoTerms_toTextArrayReturnsEmptyArray() {
		$list = new TermList();
		$this->assertEquals( array(), $list->toTextArray() );
	}

	public function testGivenTerms_toTextArrayReturnsTermsInFormat() {
		$list = new TermList( array(
			new Term( 'en', 'foo' ),
			new Term( 'de', 'bar' ),
		) );

		$this->assertEquals(
			array(
				'en' => 'foo',
				'de' => 'bar',
			),
			$list->toTextArray()
		);
	}

	public function testCanIterateOverList() {
		$list = new TermList( array(
			new Term( 'en', 'foo' ),
		) );

		foreach ( $list as $key => $term ) {
			$this->assertEquals( 'en', $key );
			$this->assertEquals( new Term( 'en', 'foo' ), $term );
		}
	}

	public function testGivenSetLanguageCode_getByLanguageReturnsGroup() {
		$enTerm = new Term( 'en', 'a' );

		$list = new TermList( array(
			new Term( 'de', 'b' ),
			$enTerm,
			new Term( 'nl', 'c' ),
		) );

		$this->assertEquals( $enTerm, $list->getByLanguage( 'en' ) );
	}

	/**
	 * @dataProvider invalidLanguageCodeProvider
	 * @expectedException InvalidArgumentException
	 */
	public function testGivenInvalidLanguageCode_getByLanguageThrowsException( $languageCode ) {
		$list = new TermList();
		$list->getByLanguage( $languageCode );
	}

	public function testGivenNonSetLanguageCode_getByLanguageThrowsException() {
		$list = new TermList();

		$this->setExpectedException( 'OutOfBoundsException' );

		$list->getByLanguage( 'en' );
	}

	public function testHasTermForLanguage() {
		$list = new TermList( array(
			new Term( 'en', 'foo' ),
			new Term( 'de', 'bar' ),
		) );

		$this->assertTrue( $list->hasTermForLanguage( 'en' ) );
		$this->assertTrue( $list->hasTermForLanguage( 'de' ) );

		$this->assertFalse( $list->hasTermForLanguage( 'nl' ) );
		$this->assertFalse( $list->hasTermForLanguage( 'fr' ) );

		$this->assertFalse( $list->hasTermForLanguage( 'EN' ) );
		$this->assertFalse( $list->hasTermForLanguage( ' de ' ) );
	}

	/**
	 * @dataProvider invalidLanguageCodeProvider
	 * @expectedException InvalidArgumentException
	 */
	public function testGivenInvalidLanguageCode_hasTermForLanguageThrowsException( $languageCode ) {
		$list = new TermList();
		$list->hasTermForLanguage( $languageCode );
	}

	public function invalidLanguageCodeProvider() {
		return array(
			array( null ),
			array( 21 ),
			array( '' ),
		);
	}

	public function testGivenNotSetLanguageCode_removeByLanguageDoesNoOp() {
		$list = new TermList( array(
			new Term( 'en', 'foo' ),
			new Term( 'de', 'bar' ),
		) );

		$list->removeByLanguage( 'nl' );

		$this->assertCount( 2, $list );
	}

	public function testGivenSetLanguageCode_removeByLanguageRemovesIt() {
		$deTerm = new Term( 'de', 'bar' );

		$list = new TermList( array(
			new Term( 'en', 'foo' ),
			$deTerm,
		) );

		$list->removeByLanguage( 'en' );

		$this->assertEquals(
			array( 'de' => $deTerm ),
			iterator_to_array( $list )
		);
	}

	/**
	 * @dataProvider invalidLanguageCodeProvider
	 * @expectedException InvalidArgumentException
	 */
	public function testGivenInvalidLanguageCode_removeByLanguageThrowsException( $languageCode ) {
		$list = new TermList();
		$list->removeByLanguage( $languageCode );
	}

	public function testGivenTermForNewLanguage_setTermAddsTerm() {
		$enTerm = new Term( 'en', 'foo' );
		$deTerm = new Term( 'de', 'bar' );

		$list = new TermList( array( $enTerm ) );
		$expectedList = new TermList( array( $enTerm, $deTerm ) );

		$list->setTerm( $deTerm );

		$this->assertEquals( $expectedList, $list );
	}

	public function testGivenTermForExistingLanguage_setTermReplacesTerm() {
		$enTerm = new Term( 'en', 'foo' );
		$newEnTerm = new Term( 'en', 'bar' );

		$list = new TermList( array( $enTerm ) );
		$expectedList = new TermList( array( $newEnTerm ) );

		$list->setTerm( $newEnTerm );
		$this->assertEquals( $expectedList, $list );
	}

	public function testEmptyListEqualsEmptyList() {
		$list = new TermList();
		$this->assertTrue( $list->equals( new TermList() ) );
	}

	public function testFilledListEqualsItself() {
		$list = new TermList( array(
			new Term( 'en', 'foo' ),
			new Term( 'de', 'bar' ),
		) );

		$this->assertTrue( $list->equals( $list ) );
		$this->assertTrue( $list->equals( clone $list ) );
	}

	public function testDifferentListsDoNotEqual() {
		$list = new TermList( array(
			new Term( 'en', 'foo' ),
			new Term( 'de', 'bar' ),
		) );

		$this->assertFalse( $list->equals( new TermList() ) );

		$this->assertFalse( $list->equals(
			new TermList( array(
				new Term( 'en', 'foo' ),
			) )
		) );

		$this->assertFalse( $list->equals(
			new TermList( array(
				new Term( 'en', 'foo' ),
				new Term( 'de', 'HAX' ),
			) )
		) );

		$this->assertFalse( $list->equals(
			new TermList( array(
				new Term( 'en', 'foo' ),
				new Term( 'de', 'bar' ),
				new Term( 'nl', 'baz' ),
			) )
		) );
	}

	public function testGivenNonTermList_equalsReturnsFalse() {
		$list = new TermList();
		$this->assertFalse( $list->equals( null ) );
		$this->assertFalse( $list->equals( new \stdClass() ) );
	}

	public function testGivenListsThatOnlyDifferInOrder_equalsReturnsTrue() {
		$list = new TermList( array(
			new Term( 'en', 'foo' ),
			new Term( 'de', 'bar' ),
		) );

		$this->assertTrue( $list->equals(
			new TermList( array(
				new Term( 'de', 'bar' ),
				new Term( 'en', 'foo' ),
			) )
		) );
	}

	public function testGivenNonSetLanguageTerm_hasTermReturnsFalse() {
		$list = new TermList();
		$this->assertFalse( $list->hasTerm( new Term( 'en', 'kittens' ) ) );
	}

	public function testGivenMismatchingTerm_hasTermReturnsFalse() {
		$list = new TermList( array( new Term( 'en', 'cats' ) ) );
		$this->assertFalse( $list->hasTerm( new Term( 'en', 'kittens' ) ) );
	}

	public function testGivenMatchingTerm_hasTermReturnsTrue() {
		$list = new TermList( array( new Term( 'en', 'kittens' ) ) );
		$this->assertTrue( $list->hasTerm( new Term( 'en', 'kittens' ) ) );
	}

	public function testGivenValidArgs_setTermTextSetsTerm() {
		$list = new TermList();

		$list->setTextForLanguage( 'en', 'kittens' );

		$this->assertTrue( $list->getByLanguage( 'en' )->equals( new Term( 'en', 'kittens' ) ) );
	}

	public function testGivenInvalidLanguageCode_setTermTextThrowsException() {
		$list = new TermList();

		$this->setExpectedException( 'InvalidArgumentException' );

		$list->setTextForLanguage( null, 'kittens' );
	}

	public function testGivenInvalidTermText_setTermTextThrowsException() {
		$list = new TermList();

		$this->setExpectedException( 'InvalidArgumentException' );

		$list->setTextForLanguage( 'en', null );
	}

	public function testGivenEmptyList_getWithLanguagesReturnsEmptyList() {
		$list = new TermList();
		$this->assertEquals( new TermList(), $list->getWithLanguages( array() ) );
		$this->assertEquals( new TermList(), $list->getWithLanguages( array( 'en', 'de' ) ) );
	}

	public function testGivenNoLanguages_getWithLanguagesReturnsEmptyList() {
		$list = new TermList();
		$list->setTextForLanguage( 'en', 'foo' );
		$list->setTextForLanguage( 'de', 'bar' );

		$this->assertEquals( new TermList(), $list->getWithLanguages( array() ) );
	}

	public function testGivenAllLanguages_getWithLanguagesReturnsFullList() {
		$list = new TermList();
		$list->setTextForLanguage( 'en', 'foo' );
		$list->setTextForLanguage( 'de', 'bar' );

		$this->assertEquals( $list, $list->getWithLanguages( array( 'en', 'de' ) ) );
	}

	public function testGivenSomeLanguages_getWithLanguagesReturnsPartialList() {
		$list = new TermList();
		$list->setTextForLanguage( 'en', 'foo' );
		$list->setTextForLanguage( 'de', 'bar' );
		$list->setTextForLanguage( 'nl', 'baz' );
		$list->setTextForLanguage( 'fr', 'hax' );

		$expectedList = new TermList();
		$expectedList->setTextForLanguage( 'en', 'foo' );
		$expectedList->setTextForLanguage( 'nl', 'baz' );

		$this->assertEquals( $expectedList, $list->getWithLanguages( array( 'en', 'nl' ) ) );
	}

	public function testGivenEmptyTerms_constructorOnlyAddsNonEmptyTerms() {
		$list = new TermList( array(
			new Term( 'en', 'foo' ),
			new Term( 'de', '' ),
			new Term( 'nl', 'baz' ),
			new Term( 'fr', '' ),
		) );

		$this->assertEquals(
			array(
				'en' => new Term( 'en', 'foo' ),
				'nl' => new Term( 'nl', 'baz' ),
			),
			iterator_to_array( $list )
		);
	}

	public function testGivenEmptyTerm_setTermDoesNotAddIt() {
		$list = new TermList();
		$list->setTerm( new Term( 'en', '' ) );

		$this->assertEquals( new TermList(), $list );
	}

	public function testGivenEmptyTerm_setTermRemovesExistingOne() {
		$list = new TermList();
		$list->setTerm( new Term( 'en', 'foo' ) );
		$list->setTerm( new Term( 'de', 'bar' ) );
		$list->setTerm( new Term( 'en', '' ) );

		$this->assertEquals(
			new TermList( array( new Term( 'de', 'bar' ) ) ),
			$list
		);
	}

	public function testClear() {
		$list = new TermList();
		$list->setTextForLanguage( 'en', 'foo' );
		$list->setTextForLanguage( 'de', 'bar' );

		$list->clear();

		$this->assertEquals( new TermList(), $list );
	}

}


1			<?php
2
3			namespace Wikibase\DataModel\Tests\Term;
4
5			use InvalidArgumentException;
6			use Wikibase\DataModel\Term\Term;
7			use Wikibase\DataModel\Term\TermList;
8
9			/**
10			* @covers Wikibase\DataModel\Term\TermList
11			* @uses Wikibase\DataModel\Term\Term
12			*
13			* @licence GNU GPL v2+
14			* @author Jeroen De Dauw < [email protected] >
15			*/
16			class TermListTest extends \PHPUnit_Framework_TestCase {
17
18			public function testIsEmpty() {
19			$list = new TermList();
20			$this->assertTrue( $list->isEmpty() );
21
22			$list = new TermList( array( new Term( 'en', 'foo' ) ) );
23			$this->assertFalse( $list->isEmpty() );
24			}
25
26			public function testGivenNoTerms_sizeIsZero() {
27			$list = new TermList();
28			$this->assertCount( 0, $list );
29			}
30
31			public function testGivenTwoTerms_countReturnsTwo() {
32			$list = new TermList( $this->getTwoTerms() );
33
34			$this->assertCount( 2, $list );
35			}
36
37			private function getTwoTerms() {
38			return array(
39			'en' => new Term( 'en', 'foo' ),
40			'de' => new Term( 'de', 'bar' ),
41			);
42			}
43
44			public function testGivenTwoTerms_listContainsThem() {
45			$array = $this->getTwoTerms();
46
47			$list = new TermList( $array );
48
49			$this->assertEquals( $array, iterator_to_array( $list ) );
50			}
51
52			public function testGivenTermsWithTheSameLanguage_onlyTheLastOnesAreRetained() {
53			$array = array(
54			new Term( 'en', 'foo' ),
55			new Term( 'en', 'bar' ),
56
57			new Term( 'de', 'baz' ),
58
59			new Term( 'nl', 'bah' ),
60			new Term( 'nl', 'blah' ),
61			new Term( 'nl', 'spam' ),
62			);
63
64			$list = new TermList( $array );
65
66			$this->assertEquals(
67			array(
68			'en' => new Term( 'en', 'bar' ),
69			'de' => new Term( 'de', 'baz' ),
70			'nl' => new Term( 'nl', 'spam' ),
71			),
72			iterator_to_array( $list )
73			);
74			}
75
76			public function testGivenNoTerms_toTextArrayReturnsEmptyArray() {
77			$list = new TermList();
78			$this->assertEquals( array(), $list->toTextArray() );
79			}
80
81			public function testGivenTerms_toTextArrayReturnsTermsInFormat() {
82			$list = new TermList( array(
83			new Term( 'en', 'foo' ),
84			new Term( 'de', 'bar' ),
85			) );
86
87			$this->assertEquals(
88			array(
89			'en' => 'foo',
90			'de' => 'bar',
91			),
92			$list->toTextArray()
93			);
94			}
95
96			public function testCanIterateOverList() {
97			$list = new TermList( array(
98			new Term( 'en', 'foo' ),
99			) );
100
101			foreach ( $list as $key => $term ) {
102			$this->assertEquals( 'en', $key );
103			$this->assertEquals( new Term( 'en', 'foo' ), $term );
104			}
105			}
106
107			public function testGivenSetLanguageCode_getByLanguageReturnsGroup() {
108			$enTerm = new Term( 'en', 'a' );
109
110			$list = new TermList( array(
111			new Term( 'de', 'b' ),
112			$enTerm,
113			new Term( 'nl', 'c' ),
114			) );
115
116			$this->assertEquals( $enTerm, $list->getByLanguage( 'en' ) );
117			}
118
119			/**
120			* @dataProvider invalidLanguageCodeProvider
121			* @expectedException InvalidArgumentException
122			*/
123			public function testGivenInvalidLanguageCode_getByLanguageThrowsException( $languageCode ) {
124			$list = new TermList();
125			$list->getByLanguage( $languageCode );
126			}
127
128			public function testGivenNonSetLanguageCode_getByLanguageThrowsException() {
129			$list = new TermList();
130
131			$this->setExpectedException( 'OutOfBoundsException' );
			0 ignored issues – show Deprecated Code introduced 2016-02-07 08:37 UTC by Report Bug Copy Issue Report The method `PHPUnit_Framework_TestCase::setExpectedException()` has been deprecated with message: Method deprecated since Release 5.2.0 This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
132			$list->getByLanguage( 'en' );
133			}
134
135			public function testHasTermForLanguage() {
136			$list = new TermList( array(
137			new Term( 'en', 'foo' ),
138			new Term( 'de', 'bar' ),
139			) );
140
141			$this->assertTrue( $list->hasTermForLanguage( 'en' ) );
142			$this->assertTrue( $list->hasTermForLanguage( 'de' ) );
143
144			$this->assertFalse( $list->hasTermForLanguage( 'nl' ) );
145			$this->assertFalse( $list->hasTermForLanguage( 'fr' ) );
146
147			$this->assertFalse( $list->hasTermForLanguage( 'EN' ) );
148			$this->assertFalse( $list->hasTermForLanguage( ' de ' ) );
149			}
150
151			/**
152			* @dataProvider invalidLanguageCodeProvider
153			* @expectedException InvalidArgumentException
154			*/
155			public function testGivenInvalidLanguageCode_hasTermForLanguageThrowsException( $languageCode ) {
156			$list = new TermList();
157			$list->hasTermForLanguage( $languageCode );
158			}
159
160			public function invalidLanguageCodeProvider() {
161			return array(
162			array( null ),
163			array( 21 ),
164			array( '' ),
165			);
166			}
167
168			public function testGivenNotSetLanguageCode_removeByLanguageDoesNoOp() {
169			$list = new TermList( array(
170			new Term( 'en', 'foo' ),
171			new Term( 'de', 'bar' ),
172			) );
173
174			$list->removeByLanguage( 'nl' );
175
176			$this->assertCount( 2, $list );
177			}
178
179			public function testGivenSetLanguageCode_removeByLanguageRemovesIt() {
180			$deTerm = new Term( 'de', 'bar' );
181
182			$list = new TermList( array(
183			new Term( 'en', 'foo' ),
184			$deTerm,
185			) );
186
187			$list->removeByLanguage( 'en' );
188
189			$this->assertEquals(
190			array( 'de' => $deTerm ),
191			iterator_to_array( $list )
192			);
193			}
194
195			/**
196			* @dataProvider invalidLanguageCodeProvider
197			* @expectedException InvalidArgumentException
198			*/
199			public function testGivenInvalidLanguageCode_removeByLanguageThrowsException( $languageCode ) {
200			$list = new TermList();
201			$list->removeByLanguage( $languageCode );
202			}
203
204			public function testGivenTermForNewLanguage_setTermAddsTerm() {
205			$enTerm = new Term( 'en', 'foo' );
206			$deTerm = new Term( 'de', 'bar' );
207
208			$list = new TermList( array( $enTerm ) );
209			$expectedList = new TermList( array( $enTerm, $deTerm ) );
210
211			$list->setTerm( $deTerm );
212
213			$this->assertEquals( $expectedList, $list );
214			}
215
216			public function testGivenTermForExistingLanguage_setTermReplacesTerm() {
217			$enTerm = new Term( 'en', 'foo' );
218			$newEnTerm = new Term( 'en', 'bar' );
219
220			$list = new TermList( array( $enTerm ) );
221			$expectedList = new TermList( array( $newEnTerm ) );
222
223			$list->setTerm( $newEnTerm );
224			$this->assertEquals( $expectedList, $list );
225			}
226
227			public function testEmptyListEqualsEmptyList() {
228			$list = new TermList();
229			$this->assertTrue( $list->equals( new TermList() ) );
230			}
231
232			public function testFilledListEqualsItself() {
233			$list = new TermList( array(
234			new Term( 'en', 'foo' ),
235			new Term( 'de', 'bar' ),
236			) );
237
238			$this->assertTrue( $list->equals( $list ) );
239			$this->assertTrue( $list->equals( clone $list ) );
240			}
241
242			public function testDifferentListsDoNotEqual() {
243			$list = new TermList( array(
244			new Term( 'en', 'foo' ),
245			new Term( 'de', 'bar' ),
246			) );
247
248			$this->assertFalse( $list->equals( new TermList() ) );
249
250			$this->assertFalse( $list->equals(
251			new TermList( array(
252			new Term( 'en', 'foo' ),
253			) )
254			) );
255
256			$this->assertFalse( $list->equals(
257			new TermList( array(
258			new Term( 'en', 'foo' ),
259			new Term( 'de', 'HAX' ),
260			) )
261			) );
262
263			$this->assertFalse( $list->equals(
264			new TermList( array(
265			new Term( 'en', 'foo' ),
266			new Term( 'de', 'bar' ),
267			new Term( 'nl', 'baz' ),
268			) )
269			) );
270			}
271
272			public function testGivenNonTermList_equalsReturnsFalse() {
273			$list = new TermList();
274			$this->assertFalse( $list->equals( null ) );
275			$this->assertFalse( $list->equals( new \stdClass() ) );
276			}
277
278			public function testGivenListsThatOnlyDifferInOrder_equalsReturnsTrue() {
279			$list = new TermList( array(
280			new Term( 'en', 'foo' ),
281			new Term( 'de', 'bar' ),
282			) );
283
284			$this->assertTrue( $list->equals(
285			new TermList( array(
286			new Term( 'de', 'bar' ),
287			new Term( 'en', 'foo' ),
288			) )
289			) );
290			}
291
292			public function testGivenNonSetLanguageTerm_hasTermReturnsFalse() {
293			$list = new TermList();
294			$this->assertFalse( $list->hasTerm( new Term( 'en', 'kittens' ) ) );
295			}
296
297			public function testGivenMismatchingTerm_hasTermReturnsFalse() {
298			$list = new TermList( array( new Term( 'en', 'cats' ) ) );
299			$this->assertFalse( $list->hasTerm( new Term( 'en', 'kittens' ) ) );
300			}
301
302			public function testGivenMatchingTerm_hasTermReturnsTrue() {
303			$list = new TermList( array( new Term( 'en', 'kittens' ) ) );
304			$this->assertTrue( $list->hasTerm( new Term( 'en', 'kittens' ) ) );
305			}
306
307			public function testGivenValidArgs_setTermTextSetsTerm() {
308			$list = new TermList();
309
310			$list->setTextForLanguage( 'en', 'kittens' );
311
312			$this->assertTrue( $list->getByLanguage( 'en' )->equals( new Term( 'en', 'kittens' ) ) );
313			}
314
315			public function testGivenInvalidLanguageCode_setTermTextThrowsException() {
316			$list = new TermList();
317
318			$this->setExpectedException( 'InvalidArgumentException' );
			0 ignored issues – show Deprecated Code introduced 2016-02-07 08:37 UTC by Report Bug Copy Issue Report The method `PHPUnit_Framework_TestCase::setExpectedException()` has been deprecated with message: Method deprecated since Release 5.2.0 This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
319			$list->setTextForLanguage( null, 'kittens' );
320			}
321
322			public function testGivenInvalidTermText_setTermTextThrowsException() {
323			$list = new TermList();
324
325			$this->setExpectedException( 'InvalidArgumentException' );
			0 ignored issues – show Deprecated Code introduced 2016-02-07 08:37 UTC by Report Bug Copy Issue Report The method `PHPUnit_Framework_TestCase::setExpectedException()` has been deprecated with message: Method deprecated since Release 5.2.0 This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
326			$list->setTextForLanguage( 'en', null );
327			}
328
329			public function testGivenEmptyList_getWithLanguagesReturnsEmptyList() {
330			$list = new TermList();
331			$this->assertEquals( new TermList(), $list->getWithLanguages( array() ) );
332			$this->assertEquals( new TermList(), $list->getWithLanguages( array( 'en', 'de' ) ) );
333			}
334
335			public function testGivenNoLanguages_getWithLanguagesReturnsEmptyList() {
336			$list = new TermList();
337			$list->setTextForLanguage( 'en', 'foo' );
338			$list->setTextForLanguage( 'de', 'bar' );
339
340			$this->assertEquals( new TermList(), $list->getWithLanguages( array() ) );
341			}
342
343			public function testGivenAllLanguages_getWithLanguagesReturnsFullList() {
344			$list = new TermList();
345			$list->setTextForLanguage( 'en', 'foo' );
346			$list->setTextForLanguage( 'de', 'bar' );
347
348			$this->assertEquals( $list, $list->getWithLanguages( array( 'en', 'de' ) ) );
349			}
350
351			public function testGivenSomeLanguages_getWithLanguagesReturnsPartialList() {
352			$list = new TermList();
353			$list->setTextForLanguage( 'en', 'foo' );
354			$list->setTextForLanguage( 'de', 'bar' );
355			$list->setTextForLanguage( 'nl', 'baz' );
356			$list->setTextForLanguage( 'fr', 'hax' );
357
358			$expectedList = new TermList();
359			$expectedList->setTextForLanguage( 'en', 'foo' );
360			$expectedList->setTextForLanguage( 'nl', 'baz' );
361
362			$this->assertEquals( $expectedList, $list->getWithLanguages( array( 'en', 'nl' ) ) );
363			}
364
365			public function testGivenEmptyTerms_constructorOnlyAddsNonEmptyTerms() {
366			$list = new TermList( array(
367			new Term( 'en', 'foo' ),
368			new Term( 'de', '' ),
369			new Term( 'nl', 'baz' ),
370			new Term( 'fr', '' ),
371			) );
372
373			$this->assertEquals(
374			array(
375			'en' => new Term( 'en', 'foo' ),
376			'nl' => new Term( 'nl', 'baz' ),
377			),
378			iterator_to_array( $list )
379			);
380			}
381
382			public function testGivenEmptyTerm_setTermDoesNotAddIt() {
383			$list = new TermList();
384			$list->setTerm( new Term( 'en', '' ) );
385
386			$this->assertEquals( new TermList(), $list );
387			}
388
389			public function testGivenEmptyTerm_setTermRemovesExistingOne() {
390			$list = new TermList();
391			$list->setTerm( new Term( 'en', 'foo' ) );
392			$list->setTerm( new Term( 'de', 'bar' ) );
393			$list->setTerm( new Term( 'en', '' ) );
394
395			$this->assertEquals(
396			new TermList( array( new Term( 'de', 'bar' ) ) ),
397			$list
398			);
399			}
400
401			public function testClear() {
402			$list = new TermList();
403			$list->setTextForLanguage( 'en', 'foo' );
404			$list->setTextForLanguage( 'de', 'bar' );
405
406			$list->clear();
407
408			$this->assertEquals( new TermList(), $list );
409			}
410
411			}
412

wmde / WikibaseDataModel

Push — clear ( 11b8fa )

TermListTest::testClear() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like