File: ListSpecificTest.kt

package info (click to toggle)
kotlin 1.3.31%2Bds1-3
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 109,908 kB
  • sloc: java: 454,756; xml: 18,599; javascript: 10,452; sh: 513; python: 97; makefile: 69; ansic: 4
file content (95 lines) | stat: -rw-r--r-- 2,562 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
/*
 * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
 * that can be found in the license/LICENSE.txt file.
 */

package test.collections

import kotlin.test.*

class ListSpecificTest {
    val data = listOf("foo", "bar")
    val empty = listOf<String>()

    @Test
    fun _toString() {
        assertEquals("[foo, bar]", data.toString())
    }

    @Test
    fun tail() {
        val data = listOf("foo", "bar", "whatnot")
        val actual = data.drop(1)
        assertEquals(listOf("bar", "whatnot"), actual)
    }

    @Test
    fun slice() {
        val list = listOf('A', 'B', 'C', 'D')

        assertEquals(emptyList(), list.slice(IntRange.EMPTY))

        // ABCD
        // 0123
        assertEquals(listOf('B', 'C', 'D'), list.slice(1..3))
        assertEquals(listOf('D', 'C', 'B'), list.slice(3 downTo 1))

        val iter = listOf(2, 0, 3)
        assertEquals(listOf('C', 'A', 'D'), list.slice(iter))

        for (range in listOf(-1 until 0, 0 until 2, 2..2)) {
            val bounds = "range: $range"
            val exClass = IndexOutOfBoundsException::class
            assertFailsWith(exClass, bounds) { listOf("x").slice(range) }
            assertFailsWith(exClass, bounds) { listOf("x").slice(range.asIterable()) }
        }
    }

    @Test
    fun getOr() {
        expect("foo") { data.get(0) }
        expect("bar") { data.get(1) }
        assertFails { data.get(2) }
        assertFails { data.get(-1) }
        assertFails { empty.get(0) }

        expect("foo") { data.getOrElse(0, { "" }) }
        expect("zoo") { data.getOrElse(-1, { "zoo" }) }
        expect("zoo") { data.getOrElse(2, { "zoo" }) }
        expect("zoo") { empty.getOrElse(0) { "zoo" } }

        expect(null) { empty.getOrNull(0) }

    }

    @Test
    fun lastIndex() {
        assertEquals(-1, empty.lastIndex)
        assertEquals(1, data.lastIndex)
    }

    @Test
    fun indexOfLast() {
        expect(-1) { data.indexOfLast { it.contains("p") } }
        expect(1) { data.indexOfLast { it.length == 3 } }
        expect(-1) { empty.indexOfLast { it.startsWith('f') } }
    }

    @Test
    fun mutableList() {
        val items = listOf("beverage", "location", "name")

        var list = listOf<String>()
        for (item in items) {
            list += item
        }

        assertEquals(3, list.size)
        assertEquals("beverage,location,name", list.joinToString(","))
    }

    @Test
    fun testNullToString() {
        assertEquals("[null]", listOf<String?>(null).toString())
    }
}