Revert "BAEL-4134"
This commit is contained in:
Loredana Crusoveanu
committed by
GitHub
GitHub
parent
dffa1f64e6
commit
485b4e3e99
@@ -11,3 +11,4 @@ This module contains articles about core Kotlin collections.
|
||||
- [Collection Transformations in Kotlin](https://www.baeldung.com/kotlin-collection-transformations)
|
||||
- [Difference between fold and reduce in Kotlin](https://www.baeldung.com/kotlin/fold-vs-reduce)
|
||||
- [Guide to Sorting in Kotlin](https://www.baeldung.com/kotlin-sort)
|
||||
- [Working With Lists in Kotlin](https://www.baeldung.com/kotlin/lists)
|
||||
|
||||
@@ -0,0 +1,204 @@
|
||||
package com.baeldung.kotlin.collections
|
||||
|
||||
import kotlin.collections.List
|
||||
|
||||
class ListExample {
|
||||
|
||||
private val countries = listOf("Germany", "India", "Japan", "Brazil", "Australia")
|
||||
private val cities = mutableListOf("Berlin", "Calcutta", "Seoul", "Sao Paulo", "Sydney")
|
||||
|
||||
fun createList(): List<String> {
|
||||
val countryList = listOf("Germany", "India", "Japan", "Brazil")
|
||||
return countryList
|
||||
}
|
||||
|
||||
fun createMutableList(): MutableList<String> {
|
||||
val cityList = mutableListOf("Berlin", "Calcutta", "Seoul", "Sao Paulo")
|
||||
return cityList
|
||||
}
|
||||
|
||||
fun iterateUsingForEachLoop(): List<Int> {
|
||||
val countryLength = mutableListOf<Int>()
|
||||
countries.forEach { it ->
|
||||
print("$it ")
|
||||
println(" Length: ${it.length}")
|
||||
countryLength.add(it.length)
|
||||
}
|
||||
return countryLength
|
||||
}
|
||||
|
||||
fun iterateUsingForLoop(): List<Int> {
|
||||
val countryLength = mutableListOf<Int>()
|
||||
for (country in countries) {
|
||||
print("$country ")
|
||||
println(" Length: ${country.length}")
|
||||
countryLength.add(country.length)
|
||||
}
|
||||
return countryLength
|
||||
}
|
||||
|
||||
fun iterateUsingForLoopRange(): List<Int> {
|
||||
val countryLength = mutableListOf<Int>()
|
||||
for (i in 0 until countries.size) {
|
||||
print("${countries[i]} ")
|
||||
println(" Length: ${countries[i].length}")
|
||||
countryLength.add(countries[i].length)
|
||||
}
|
||||
return countryLength
|
||||
}
|
||||
|
||||
fun iterateUsingForEachIndexedLoop(): List<Int> {
|
||||
val countryLength = mutableListOf<Int>()
|
||||
countries.forEachIndexed { i, e ->
|
||||
println("country[$i] = $e")
|
||||
print(" Index: $i")
|
||||
println(" Length: ${e.length}")
|
||||
countryLength.add(e.length)
|
||||
}
|
||||
return countryLength
|
||||
}
|
||||
|
||||
fun iterateUsingListIterator() {
|
||||
val iterator = countries.listIterator()
|
||||
while (iterator.hasNext()) {
|
||||
val country = iterator.next()
|
||||
print("$country ")
|
||||
}
|
||||
println()
|
||||
|
||||
while (iterator.hasPrevious()) {
|
||||
println("Index: ${iterator.previousIndex()}")
|
||||
}
|
||||
}
|
||||
|
||||
fun iterateUsingIterator() {
|
||||
val iterator = cities.iterator()
|
||||
iterator.next()
|
||||
iterator.remove()
|
||||
println(cities)
|
||||
}
|
||||
|
||||
fun iterateUsingMutableListIterator() {
|
||||
val iterator = cities.listIterator(1)
|
||||
iterator.next()
|
||||
iterator.add("London")
|
||||
iterator.next()
|
||||
iterator.set("Milan")
|
||||
println(cities)
|
||||
}
|
||||
|
||||
fun retrieveElementsInList(): String {
|
||||
println(countries[2])
|
||||
return countries[2]
|
||||
}
|
||||
|
||||
fun retrieveElementsUsingGet(): String {
|
||||
println(countries.get(3))
|
||||
return countries.get(3)
|
||||
}
|
||||
|
||||
fun retrieveElementsFirstAndLast(): String? {
|
||||
println(countries.first())
|
||||
println(countries.last())
|
||||
println(countries.first { it.length > 7 })
|
||||
println(countries.last { it.startsWith("J") })
|
||||
println(countries.firstOrNull { it.length > 8 })
|
||||
return countries.firstOrNull { it.length > 8 }
|
||||
}
|
||||
|
||||
fun retrieveSubList(): List<String> {
|
||||
val subList = countries.subList(1, 4)
|
||||
println(subList)
|
||||
return subList
|
||||
}
|
||||
|
||||
fun retrieveListSliceUsingIndices(): List<String> {
|
||||
val sliceList = countries.slice(1..4)
|
||||
println(sliceList)
|
||||
return sliceList
|
||||
}
|
||||
|
||||
fun retrieveListSliceUsingIndicesList(): List<String> {
|
||||
val sliceList = countries.slice(listOf(1, 4))
|
||||
println(sliceList)
|
||||
return sliceList
|
||||
}
|
||||
|
||||
fun countList(): Int {
|
||||
val count = countries.count()
|
||||
println(count)
|
||||
return count
|
||||
}
|
||||
|
||||
fun countListUsingPredicate(): Int {
|
||||
val count = countries.count { it.length > 5 }
|
||||
println(count)
|
||||
return count
|
||||
}
|
||||
|
||||
fun countListUsingProperty(): Int {
|
||||
val size = countries.size
|
||||
println(size)
|
||||
return size
|
||||
}
|
||||
|
||||
fun addToList(): List<String> {
|
||||
cities.add("Barcelona")
|
||||
println(cities)
|
||||
cities.add(3, "London")
|
||||
println(cities)
|
||||
cities.addAll(listOf("Singapore", "Moscow"))
|
||||
println(cities)
|
||||
cities.addAll(2, listOf("Prague", "Amsterdam"))
|
||||
println(cities)
|
||||
return cities
|
||||
}
|
||||
|
||||
fun removeFromList(): List<String> {
|
||||
cities.remove("Seoul")
|
||||
println(cities)
|
||||
cities.removeAt(1)
|
||||
println(cities)
|
||||
return cities
|
||||
}
|
||||
|
||||
fun replaceFromList(): List<String> {
|
||||
cities.set(3, "Prague")
|
||||
println(cities)
|
||||
cities[4] = "Moscow"
|
||||
println(cities)
|
||||
cities.fill("Barcelona")
|
||||
println(cities)
|
||||
return cities
|
||||
}
|
||||
|
||||
fun sortMutableList(): List<String> {
|
||||
cities.sort()
|
||||
println(cities)
|
||||
cities.sortDescending()
|
||||
println(cities)
|
||||
return cities
|
||||
}
|
||||
|
||||
fun sortList(): List<String> {
|
||||
val sortedCountries = countries.sorted()
|
||||
println("countries = $countries")
|
||||
println("sortedCountries = $sortedCountries")
|
||||
val sortedCountriesDescending = countries.sortedDescending()
|
||||
println("countries = $countries")
|
||||
println("sortedCountriesDescending = $sortedCountriesDescending")
|
||||
return sortedCountriesDescending
|
||||
}
|
||||
|
||||
fun checkOneElementInList(): Boolean {
|
||||
return countries.contains("Germany")
|
||||
}
|
||||
|
||||
fun checkOneElementInListUsingOperator(): Boolean {
|
||||
return "Spain" in countries
|
||||
}
|
||||
|
||||
fun checkElementsInList(): Boolean {
|
||||
return cities.containsAll(listOf("Calcutta", "Sao Paulo", "Sydney"))
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
package com.baeldung.collections
|
||||
|
||||
import org.assertj.core.api.Assertions.assertThat
|
||||
import org.junit.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
@@ -8,139 +9,204 @@ import kotlin.test.assertTrue
|
||||
class CollectionsTest {
|
||||
|
||||
@Test
|
||||
fun whenUseDifferentCollections_thenSuccess () {
|
||||
fun whenUseDifferentCollections_thenSuccess() {
|
||||
val theList = listOf("one", "two", "three")
|
||||
assertTrue(theList.contains("two"))
|
||||
assertTrue(theList.contains("two"))
|
||||
|
||||
val theMutableList = mutableListOf("one", "two", "three")
|
||||
theMutableList.add("four")
|
||||
assertTrue(theMutableList.contains("four"))
|
||||
assertTrue(theMutableList.contains("four"))
|
||||
|
||||
val theSet = setOf("one", "two", "three")
|
||||
assertTrue(theSet.contains("three"))
|
||||
assertTrue(theSet.contains("three"))
|
||||
|
||||
val theMutableSet = mutableSetOf("one", "two", "three")
|
||||
theMutableSet.add("four")
|
||||
assertTrue(theMutableSet.contains("four"))
|
||||
assertTrue(theMutableSet.contains("four"))
|
||||
|
||||
val theMap = mapOf(1 to "one", 2 to "two", 3 to "three")
|
||||
assertEquals(theMap[2],"two")
|
||||
assertEquals(theMap[2], "two")
|
||||
|
||||
val theMutableMap = mutableMapOf(1 to "one", 2 to "two", 3 to "three")
|
||||
theMutableMap[4] = "four"
|
||||
assertEquals(theMutableMap[4],"four")
|
||||
assertEquals(theMutableMap[4], "four")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenSliceCollection_thenSuccess () {
|
||||
fun whenSliceCollection_thenSuccess() {
|
||||
val theList = listOf("one", "two", "three")
|
||||
val resultList = theList.slice(1..2)
|
||||
|
||||
assertEquals(2, resultList.size)
|
||||
assertTrue(resultList.contains("two"))
|
||||
assertEquals(2, resultList.size)
|
||||
assertTrue(resultList.contains("two"))
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
fun whenJoinTwoCollections_thenSuccess () {
|
||||
fun whenJoinTwoCollections_thenSuccess() {
|
||||
val firstList = listOf("one", "two", "three")
|
||||
val secondList = listOf("four", "five", "six")
|
||||
val resultList = firstList + secondList
|
||||
|
||||
assertEquals(6, resultList.size)
|
||||
assertTrue(resultList.contains("two"))
|
||||
assertTrue(resultList.contains("five"))
|
||||
}
|
||||
|
||||
assertEquals(6, resultList.size)
|
||||
assertTrue(resultList.contains("two"))
|
||||
assertTrue(resultList.contains("five"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenFilterNullValues_thenSuccess () {
|
||||
fun whenFilterNullValues_thenSuccess() {
|
||||
val theList = listOf("one", null, "two", null, "three")
|
||||
val resultList = theList.filterNotNull()
|
||||
|
||||
assertEquals(3, resultList.size)
|
||||
}
|
||||
assertEquals(3, resultList.size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenFilterNonPositiveValues_thenSuccess () {
|
||||
fun whenFilterNonPositiveValues_thenSuccess() {
|
||||
val theList = listOf(1, 2, -3, -4, 5, -6)
|
||||
val resultList = theList.filter{ it > 0}
|
||||
val resultList = theList.filter { it > 0 }
|
||||
//val resultList = theList.filter{ x -> x > 0}
|
||||
|
||||
assertEquals(3, resultList.size)
|
||||
assertEquals(3, resultList.size)
|
||||
assertTrue(resultList.contains(1))
|
||||
assertFalse(resultList.contains(-4))
|
||||
}
|
||||
assertFalse(resultList.contains(-4))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenDropFirstItems_thenRemoved () {
|
||||
fun whenDropFirstItems_thenRemoved() {
|
||||
val theList = listOf("one", "two", "three", "four")
|
||||
val resultList = theList.drop(2)
|
||||
|
||||
assertEquals(2, resultList.size)
|
||||
assertFalse(resultList.contains("one"))
|
||||
assertFalse(resultList.contains("two"))
|
||||
}
|
||||
assertEquals(2, resultList.size)
|
||||
assertFalse(resultList.contains("one"))
|
||||
assertFalse(resultList.contains("two"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenDropFirstItemsBasedOnCondition_thenRemoved () {
|
||||
fun whenDropFirstItemsBasedOnCondition_thenRemoved() {
|
||||
val theList = listOf("one", "two", "three", "four")
|
||||
val resultList = theList.dropWhile{ it.length < 4 }
|
||||
val resultList = theList.dropWhile { it.length < 4 }
|
||||
|
||||
assertEquals(2, resultList.size)
|
||||
assertFalse(resultList.contains("one"))
|
||||
assertFalse(resultList.contains("two"))
|
||||
}
|
||||
assertEquals(2, resultList.size)
|
||||
assertFalse(resultList.contains("one"))
|
||||
assertFalse(resultList.contains("two"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenExcludeItems_thenRemoved () {
|
||||
fun whenExcludeItems_thenRemoved() {
|
||||
val firstList = listOf("one", "two", "three")
|
||||
val secondList = listOf("one", "three")
|
||||
val resultList = firstList - secondList
|
||||
|
||||
assertEquals(1, resultList.size)
|
||||
assertTrue(resultList.contains("two"))
|
||||
}
|
||||
assertEquals(1, resultList.size)
|
||||
assertTrue(resultList.contains("two"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenSearchForExistingItem_thenFound () {
|
||||
fun whenSearchForExistingItem_thenFound() {
|
||||
val theList = listOf("one", "two", "three")
|
||||
|
||||
assertTrue("two" in theList)
|
||||
}
|
||||
assertTrue("two" in theList)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenGroupItems_thenSuccess () {
|
||||
fun whenGroupItems_thenSuccess() {
|
||||
val theList = listOf(1, 2, 3, 4, 5, 6)
|
||||
val resultMap = theList.groupBy{ it % 3}
|
||||
val resultMap = theList.groupBy { it % 3 }
|
||||
|
||||
assertEquals(3, resultMap.size)
|
||||
assertEquals(3, resultMap.size)
|
||||
print(resultMap[1])
|
||||
assertTrue(resultMap[1]!!.contains(1))
|
||||
assertTrue(resultMap[2]!!.contains(5))
|
||||
}
|
||||
assertTrue(resultMap[2]!!.contains(5))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenApplyFunctionToAllItems_thenSuccess () {
|
||||
fun whenApplyFunctionToAllItems_thenSuccess() {
|
||||
val theList = listOf(1, 2, 3, 4, 5, 6)
|
||||
val resultList = theList.map{ it * it }
|
||||
val resultList = theList.map { it * it }
|
||||
print(resultList)
|
||||
assertEquals(4, resultList[1])
|
||||
assertEquals(9, resultList[2])
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenApplyMultiOutputFunctionToAllItems_thenSuccess () {
|
||||
fun whenApplyMultiOutputFunctionToAllItems_thenSuccess() {
|
||||
val theList = listOf("John", "Tom")
|
||||
val resultList = theList.flatMap{ it.toLowerCase().toList()}
|
||||
val resultList = theList.flatMap { it.toLowerCase().toList() }
|
||||
print(resultList)
|
||||
assertEquals(7, resultList.size)
|
||||
assertTrue(resultList.contains('j'))
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenApplyFunctionToAllItemsWithStartingValue_thenSuccess () {
|
||||
fun whenApplyFunctionToAllItemsWithStartingValue_thenSuccess() {
|
||||
val theList = listOf(1, 2, 3, 4, 5, 6)
|
||||
val finalResult = theList.fold( 1000, { oldResult, currentItem -> oldResult + (currentItem *currentItem)})
|
||||
val finalResult = theList.fold(1000, { oldResult, currentItem -> oldResult + (currentItem * currentItem) })
|
||||
print(finalResult)
|
||||
assertEquals(1091, finalResult)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenApplyingChunked_thenShouldBreakTheCollection() {
|
||||
val theList = listOf(1, 2, 3, 4, 5)
|
||||
val chunked = theList.chunked(2)
|
||||
|
||||
assertThat(chunked.size).isEqualTo(3)
|
||||
assertThat(chunked.first()).contains(1, 2)
|
||||
assertThat(chunked[1]).contains(3, 4)
|
||||
assertThat(chunked.last()).contains(5)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenApplyingChunkedWithTransformation_thenShouldBreakTheCollection() {
|
||||
val theList = listOf(1, 2, 3, 4, 5)
|
||||
val chunked = theList.chunked(3) { it.joinToString(", ") }
|
||||
|
||||
assertThat(chunked.size).isEqualTo(2)
|
||||
assertThat(chunked.first()).isEqualTo("1, 2, 3")
|
||||
assertThat(chunked.last()).isEqualTo("4, 5")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenApplyingWindowed_thenShouldCreateSlidingWindowsOfElements() {
|
||||
val theList = (1..6).toList()
|
||||
val windowed = theList.windowed(3)
|
||||
|
||||
assertThat(windowed.size).isEqualTo(4)
|
||||
assertThat(windowed.first()).contains(1, 2, 3)
|
||||
assertThat(windowed[1]).contains(2, 3, 4)
|
||||
assertThat(windowed[2]).contains(3, 4, 5)
|
||||
assertThat(windowed.last()).contains(4, 5, 6)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenApplyingWindowedWithTwoSteps_thenShouldCreateSlidingWindowsOfElements() {
|
||||
val theList = (1..6).toList()
|
||||
val windowed = theList.windowed(size = 3, step = 2)
|
||||
|
||||
assertThat(windowed.size).isEqualTo(2)
|
||||
assertThat(windowed.first()).contains(1, 2, 3)
|
||||
assertThat(windowed.last()).contains(3, 4, 5)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenApplyingPartialWindowedWithTwoSteps_thenShouldCreateSlidingWindowsOfElements() {
|
||||
val theList = (1..6).toList()
|
||||
val windowed = theList.windowed(size = 3, step = 2, partialWindows = true)
|
||||
|
||||
assertThat(windowed.size).isEqualTo(3)
|
||||
assertThat(windowed.first()).contains(1, 2, 3)
|
||||
assertThat(windowed[1]).contains(3, 4, 5)
|
||||
assertThat(windowed.last()).contains(5, 6)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenApplyingTransformingWindows_thenShouldCreateSlidingWindowsOfElements() {
|
||||
val theList = (1..6).toList()
|
||||
val windowed = theList.windowed(size = 3, step = 2, partialWindows = true) { it.joinToString(", ") }
|
||||
|
||||
assertThat(windowed.size).isEqualTo(3)
|
||||
assertThat(windowed.first()).isEqualTo("1, 2, 3")
|
||||
assertThat(windowed[1]).isEqualTo("3, 4, 5")
|
||||
assertThat(windowed.last()).isEqualTo("5, 6")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,126 @@
|
||||
package com.baeldung.kotlin.collections
|
||||
|
||||
import org.junit.jupiter.api.Test
|
||||
import org.junit.jupiter.api.Assertions.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class ListExampleUnitTest {
|
||||
|
||||
private val classUnderTest: ListExample = ListExample()
|
||||
|
||||
@Test
|
||||
fun whenListIsCreated_thenContainsElements() {
|
||||
assertTrue(classUnderTest.createList().contains("India"))
|
||||
assertTrue(classUnderTest.createMutableList().contains("Seoul"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenIterateUsingForEachLoop_thenSuccess() {
|
||||
assertEquals(7, classUnderTest.iterateUsingForEachLoop()[0])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenIterateUsingForLoop_thenSuccess() {
|
||||
assertEquals(5, classUnderTest.iterateUsingForLoop()[1])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenIterateUsingForLoopRange_thenSuccess() {
|
||||
assertEquals(6, classUnderTest.iterateUsingForLoopRange()[3])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenIterateUsingForEachIndexedLoop_thenSuccess() {
|
||||
assertEquals(9, classUnderTest.iterateUsingForEachIndexedLoop()[4])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenRetrieveElementsInList_thenSuccess() {
|
||||
assertEquals("Japan", classUnderTest.retrieveElementsInList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenRetrieveElementsUsingGet_thenSuccess() {
|
||||
assertEquals("Brazil", classUnderTest.retrieveElementsUsingGet())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenRetrieveElementsFirstAndLast_thenSuccess() {
|
||||
assertEquals("Australia", classUnderTest.retrieveElementsFirstAndLast())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenRetrieveSubList_thenSuccess() {
|
||||
assertEquals(3, classUnderTest.retrieveSubList().size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenRetrieveListSliceUsingIndices_thenSuccess() {
|
||||
assertEquals(4, classUnderTest.retrieveListSliceUsingIndices().size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenRetrieveListSliceUsingIndicesList_thenSuccess() {
|
||||
assertEquals(2, classUnderTest.retrieveListSliceUsingIndicesList().size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenCountList_thenSuccess() {
|
||||
assertEquals(5, classUnderTest.countList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenCountListUsingPredicate_thenSuccess() {
|
||||
assertEquals(3, classUnderTest.countListUsingPredicate())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenCountListUsingProperty_thenSuccess() {
|
||||
assertEquals(5, classUnderTest.countListUsingProperty())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenAddToList_thenSuccess() {
|
||||
assertEquals(11, classUnderTest.addToList().count())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenRemoveFromList_thenSuccess() {
|
||||
val list = classUnderTest.removeFromList()
|
||||
assertEquals(3, list.size)
|
||||
assertEquals("Sao Paulo", list[1])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenReplaceFromList_thenSuccess() {
|
||||
val list = classUnderTest.replaceFromList()
|
||||
assertEquals(5, list.size)
|
||||
assertEquals("Barcelona", list[1])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenSortMutableList_thenSuccess() {
|
||||
assertEquals("Sydney", classUnderTest.sortMutableList()[0])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenSortList_thenSuccess() {
|
||||
assertEquals("India", classUnderTest.sortList()[1])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenCheckOneElementInList_thenSuccess() {
|
||||
assertTrue(classUnderTest.checkOneElementInList())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenCheckOneElementInListUsingOperator_thenSuccess() {
|
||||
assertFalse(classUnderTest.checkOneElementInListUsingOperator())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun whenCheckElementsInList_thenSuccess() {
|
||||
assertTrue(classUnderTest.checkElementsInList())
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user