TermListTest::testGivenInvalidLanguageCode_hasTermForLanguageThrowsException() - Code Metrics - Inspection of "Remove non-critical type checks from AliasGroupLis..." - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — langAssertions ( 0e6369...680829 )

by no

created 2016-03-08 10:16 UTC

testGivenInvalidLanguageCode_hasTermForLanguageThrowsException() A

↳ Parent: TermListTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	4
rs	10
cc	1
eloc	3
nc	1
nop	1

<?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
	 */
	public function testGivenInvalidLanguageCode_getByLanguageThrowsException( $languageCode ) {
		$list = new TermList();
		$this->setExpectedException( 'OutOfBoundsException' );

		$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
	 */
	public function testGivenInvalidLanguageCode_hasTermForLanguageReturnsFalse( $languageCode ) {
		$list = new TermList();
		$this->assertFalse( $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
	 */
	public function testGivenInvalidLanguageCode_removeByLanguageDoesNoOp( $languageCode ) {
		$list = new TermList( array( new Term( 'en', 'foo' ) ) );
		$list->removeByLanguage( $languageCode );
		$this->assertFalse( $list->isEmpty() );
	}

	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
		);
	}

}


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			*/
122			public function testGivenInvalidLanguageCode_getByLanguageThrowsException( $languageCode ) {
123			$list = new TermList();
124			$this->setExpectedException( 'OutOfBoundsException' );
			0 ignored issues – show Deprecated Code introduced 2016-03-08 10:44 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...
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			*/
154			public function testGivenInvalidLanguageCode_hasTermForLanguageReturnsFalse( $languageCode ) {
155			$list = new TermList();
156			$this->assertFalse( $list->hasTermForLanguage( $languageCode ) );
157			}
158
159			public function invalidLanguageCodeProvider() {
160			return array(
161			array( null ),
162			array( 21 ),
163			array( '' ),
164			);
165			}
166
167			public function testGivenNotSetLanguageCode_removeByLanguageDoesNoOp() {
168			$list = new TermList( array(
169			new Term( 'en', 'foo' ),
170			new Term( 'de', 'bar' ),
171			) );
172
173			$list->removeByLanguage( 'nl' );
174
175			$this->assertCount( 2, $list );
176			}
177
178			public function testGivenSetLanguageCode_removeByLanguageRemovesIt() {
179			$deTerm = new Term( 'de', 'bar' );
180
181			$list = new TermList( array(
182			new Term( 'en', 'foo' ),
183			$deTerm,
184			) );
185
186			$list->removeByLanguage( 'en' );
187
188			$this->assertEquals(
189			array( 'de' => $deTerm ),
190			iterator_to_array( $list )
191			);
192			}
193
194			/**
195			* @dataProvider invalidLanguageCodeProvider
196			*/
197			public function testGivenInvalidLanguageCode_removeByLanguageDoesNoOp( $languageCode ) {
198			$list = new TermList( array( new Term( 'en', 'foo' ) ) );
199			$list->removeByLanguage( $languageCode );
200			$this->assertFalse( $list->isEmpty() );
201			}
202
203			public function testGivenTermForNewLanguage_setTermAddsTerm() {
204			$enTerm = new Term( 'en', 'foo' );
205			$deTerm = new Term( 'de', 'bar' );
206
207			$list = new TermList( array( $enTerm ) );
208			$expectedList = new TermList( array( $enTerm, $deTerm ) );
209
210			$list->setTerm( $deTerm );
211
212			$this->assertEquals( $expectedList, $list );
213			}
214
215			public function testGivenTermForExistingLanguage_setTermReplacesTerm() {
216			$enTerm = new Term( 'en', 'foo' );
217			$newEnTerm = new Term( 'en', 'bar' );
218
219			$list = new TermList( array( $enTerm ) );
220			$expectedList = new TermList( array( $newEnTerm ) );
221
222			$list->setTerm( $newEnTerm );
223			$this->assertEquals( $expectedList, $list );
224			}
225
226			public function testEmptyListEqualsEmptyList() {
227			$list = new TermList();
228			$this->assertTrue( $list->equals( new TermList() ) );
229			}
230
231			public function testFilledListEqualsItself() {
232			$list = new TermList( array(
233			new Term( 'en', 'foo' ),
234			new Term( 'de', 'bar' ),
235			) );
236
237			$this->assertTrue( $list->equals( $list ) );
238			$this->assertTrue( $list->equals( clone $list ) );
239			}
240
241			public function testDifferentListsDoNotEqual() {
242			$list = new TermList( array(
243			new Term( 'en', 'foo' ),
244			new Term( 'de', 'bar' ),
245			) );
246
247			$this->assertFalse( $list->equals( new TermList() ) );
248
249			$this->assertFalse( $list->equals(
250			new TermList( array(
251			new Term( 'en', 'foo' ),
252			) )
253			) );
254
255			$this->assertFalse( $list->equals(
256			new TermList( array(
257			new Term( 'en', 'foo' ),
258			new Term( 'de', 'HAX' ),
259			) )
260			) );
261
262			$this->assertFalse( $list->equals(
263			new TermList( array(
264			new Term( 'en', 'foo' ),
265			new Term( 'de', 'bar' ),
266			new Term( 'nl', 'baz' ),
267			) )
268			) );
269			}
270
271			public function testGivenNonTermList_equalsReturnsFalse() {
272			$list = new TermList();
273			$this->assertFalse( $list->equals( null ) );
274			$this->assertFalse( $list->equals( new \stdClass() ) );
275			}
276
277			public function testGivenListsThatOnlyDifferInOrder_equalsReturnsTrue() {
278			$list = new TermList( array(
279			new Term( 'en', 'foo' ),
280			new Term( 'de', 'bar' ),
281			) );
282
283			$this->assertTrue( $list->equals(
284			new TermList( array(
285			new Term( 'de', 'bar' ),
286			new Term( 'en', 'foo' ),
287			) )
288			) );
289			}
290
291			public function testGivenNonSetLanguageTerm_hasTermReturnsFalse() {
292			$list = new TermList();
293			$this->assertFalse( $list->hasTerm( new Term( 'en', 'kittens' ) ) );
294			}
295
296			public function testGivenMismatchingTerm_hasTermReturnsFalse() {
297			$list = new TermList( array( new Term( 'en', 'cats' ) ) );
298			$this->assertFalse( $list->hasTerm( new Term( 'en', 'kittens' ) ) );
299			}
300
301			public function testGivenMatchingTerm_hasTermReturnsTrue() {
302			$list = new TermList( array( new Term( 'en', 'kittens' ) ) );
303			$this->assertTrue( $list->hasTerm( new Term( 'en', 'kittens' ) ) );
304			}
305
306			public function testGivenValidArgs_setTermTextSetsTerm() {
307			$list = new TermList();
308
309			$list->setTextForLanguage( 'en', 'kittens' );
310
311			$this->assertTrue( $list->getByLanguage( 'en' )->equals( new Term( 'en', 'kittens' ) ) );
312			}
313
314			public function testGivenInvalidLanguageCode_setTermTextThrowsException() {
315			$list = new TermList();
316
317			$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...
318			$list->setTextForLanguage( null, 'kittens' );
319			}
320
321			public function testGivenInvalidTermText_setTermTextThrowsException() {
322			$list = new TermList();
323
324			$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...
325			$list->setTextForLanguage( 'en', null );
326			}
327
328			public function testGivenEmptyList_getWithLanguagesReturnsEmptyList() {
329			$list = new TermList();
330			$this->assertEquals( new TermList(), $list->getWithLanguages( array() ) );
331			$this->assertEquals( new TermList(), $list->getWithLanguages( array( 'en', 'de' ) ) );
332			}
333
334			public function testGivenNoLanguages_getWithLanguagesReturnsEmptyList() {
335			$list = new TermList();
336			$list->setTextForLanguage( 'en', 'foo' );
337			$list->setTextForLanguage( 'de', 'bar' );
338
339			$this->assertEquals( new TermList(), $list->getWithLanguages( array() ) );
340			}
341
342			public function testGivenAllLanguages_getWithLanguagesReturnsFullList() {
343			$list = new TermList();
344			$list->setTextForLanguage( 'en', 'foo' );
345			$list->setTextForLanguage( 'de', 'bar' );
346
347			$this->assertEquals( $list, $list->getWithLanguages( array( 'en', 'de' ) ) );
348			}
349
350			public function testGivenSomeLanguages_getWithLanguagesReturnsPartialList() {
351			$list = new TermList();
352			$list->setTextForLanguage( 'en', 'foo' );
353			$list->setTextForLanguage( 'de', 'bar' );
354			$list->setTextForLanguage( 'nl', 'baz' );
355			$list->setTextForLanguage( 'fr', 'hax' );
356
357			$expectedList = new TermList();
358			$expectedList->setTextForLanguage( 'en', 'foo' );
359			$expectedList->setTextForLanguage( 'nl', 'baz' );
360
361			$this->assertEquals( $expectedList, $list->getWithLanguages( array( 'en', 'nl' ) ) );
362			}
363
364			public function testGivenEmptyTerms_constructorOnlyAddsNonEmptyTerms() {
365			$list = new TermList( array(
366			new Term( 'en', 'foo' ),
367			new Term( 'de', '' ),
368			new Term( 'nl', 'baz' ),
369			new Term( 'fr', '' ),
370			) );
371
372			$this->assertEquals(
373			array(
374			'en' => new Term( 'en', 'foo' ),
375			'nl' => new Term( 'nl', 'baz' ),
376			),
377			iterator_to_array( $list )
378			);
379			}
380
381			public function testGivenEmptyTerm_setTermDoesNotAddIt() {
382			$list = new TermList();
383			$list->setTerm( new Term( 'en', '' ) );
384
385			$this->assertEquals( new TermList(), $list );
386			}
387
388			public function testGivenEmptyTerm_setTermRemovesExistingOne() {
389			$list = new TermList();
390			$list->setTerm( new Term( 'en', 'foo' ) );
391			$list->setTerm( new Term( 'de', 'bar' ) );
392			$list->setTerm( new Term( 'en', '' ) );
393
394			$this->assertEquals(
395			new TermList( array( new Term( 'de', 'bar' ) ) ),
396			$list
397			);
398			}
399
400			}
401

wmde / WikibaseDataModel

Push — langAssertions ( 0e6369...680829 )

testGivenInvalidLanguageCode_hasTermForLanguageThrowsException() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like