TermListTest::testGivenTermForExistingLanguage_setTermReplacesTerm() - Code Metrics - Inspection of "Merge pull request #649 from wmde/clear" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c7b7b3...d0017a )

by Daniel

created 2017-03-07 13:27 UTC

testGivenTermForExistingLanguage_setTermReplacesTerm() A

↳ Parent: TermListTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
c	0
b	0
f	0
rs	9.4285
cc	1
eloc	7
nc	1
nop	0

<?php

namespace Wikibase\DataModel\Tests\Term;

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

/**
 * @covers Wikibase\DataModel\Term\TermList
 * @uses Wikibase\DataModel\Term\Term
 *
 * @license GPL-2.0+
 * @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( [ 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 [
			'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 = [
			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(
			[
				'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( [], $list->toTextArray() );
	}

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

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

	public function testCanIterateOverList() {
		$list = new TermList( [
			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( [
			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( [
			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 [
			[ null ],
			[ 21 ],
			[ '' ],
		];
	}

	public function testGivenNotSetLanguageCode_removeByLanguageDoesNoOp() {
		$list = new TermList( [
			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( [
			new Term( 'en', 'foo' ),
			$deTerm,
		] );

		$list->removeByLanguage( 'en' );

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

	/**
	 * @dataProvider invalidLanguageCodeProvider
	 */
	public function testGivenInvalidLanguageCode_removeByLanguageDoesNoOp( $languageCode ) {
		$list = new TermList( [ 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( [ $enTerm ] );
		$expectedList = new TermList( [ $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( [ $enTerm ] );
		$expectedList = new TermList( [ $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( [
			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( [
			new Term( 'en', 'foo' ),
			new Term( 'de', 'bar' ),
		] );

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

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

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

		$this->assertFalse( $list->equals(
			new TermList( [
				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( [
			new Term( 'en', 'foo' ),
			new Term( 'de', 'bar' ),
		] );

		$this->assertTrue( $list->equals(
			new TermList( [
				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( [ new Term( 'en', 'cats' ) ] );
		$this->assertFalse( $list->hasTerm( new Term( 'en', 'kittens' ) ) );
	}

	public function testGivenMatchingTerm_hasTermReturnsTrue() {
		$list = new TermList( [ 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( [] ) );
		$this->assertEquals( new TermList(), $list->getWithLanguages( [ 'en', 'de' ] ) );
	}

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

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

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

		$this->assertEquals( $list, $list->getWithLanguages( [ '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( [ 'en', 'nl' ] ) );
	}

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

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

wmde / WikibaseDataModel

Push — master ( c7b7b3...d0017a )

testGivenTermForExistingLanguage_setTermReplacesTerm() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like