/*
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you under the Apache License, Version 2.0 (the
 *  "License"); you may not use this file except in compliance
 *  with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing,
 *  software distributed under the License is distributed on an
 *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 *  specific language governing permissions and limitations
 *  under the License.
 */
package groovy

import groovy.transform.TypeChecked

class ListTest extends GroovyTestCase {

    void testList() {
        def x = [10, 11]
        assert x.size() == 2
        x.add("cheese")
        assert x.size() == 3
        assert x.contains(10)
        assert x.contains(11)
        assert x.contains("cheese")
        assert x.get(0) == 10
        assert x.get(1) == 11
        assert x.get(2) == "cheese"

        // subscript operator
        assert x[0] == 10
        assert x[1] == 11
        assert x[2] == "cheese"

        x[3] = 12
        assert x[3] == 12
        assert x.contains("cheese")
        assert x.contains(10)
    }

    void testEmptyList() {
        def x = []
        assert x.size() == 0
        x.add("cheese")
        assert x.get(0) == "cheese"
        assert x.size() == 1
        assert x[0] == "cheese"
    }

    void testSubscript() {
        def x = []
        x[1] = 'cheese'
        assert x[0] == null
        assert x[1] == 'cheese'

        x[2] = 'gromit'
        x[3] = 'wallace'
        assert x.size() == 4

        x[-1] = 'nice'
        assert x[3] == 'nice'

        x[-2] = 'cheese'
        assert x[2] == 'cheese'
    }

    void testClosure() {
        def l = [1, 2, 3, "abc"]
        def result = ''
        def block = { i -> result += i }
        l.each(block)
        assert result == '123abc'
        l.each { i -> result += i }
        assert result == '123abc123abc'
    }

    void testMax() {
        def l = [1, 2, 5, 3, 7, 1]
        assert l.max() == 7

        l = [7, 2, 3]
        assert l.max() == 7

        l = [1, 2, 7]
        assert l.max() == 7

        // GROOVY-1006        
        l = [1, 3.2, 4L, (short) 7]
        assert l.max() == (short) 7
    }

    void testMin() {
        def l = [6, 4, 5, 1, 7, 2]
        assert l.min() == 1

        l = [7, 1, 3]
        assert l.min() == 1

        l = [1, 2, 7]
        assert l.min() == 1

        // GROOVY-1006        
        l = [(long) 1, 3.2, 4L, (short) 7]
        assert l.min() == (long) 1
    }

    void testPlus() {
        def l1 = [6, 4, 5, 1, 7, 2]
        def l2 = [6, 4, 5, 1, 7, [4, 5]]
        def l3 = l1 + l2
        assert l3 == [6, 4, 5, 1, 7, 2, 6, 4, 5, 1, 7, [4, 5]]

        l1 = [1, 5.2, 9]
        l2 = [3, 4L]
        l3 = [1, 5.2, 9, 3, 4L]
        assert l1 + l2 == l3
    }

    void testPlusOneElement() {
        def l1 = [6, 4, 5, 1, 7, 2]
        def l2 = "erererer"
        assert l1 + l2 == [6, 4, 5, 1, 7, 2, "erererer"]
    }

    void testListAppend() {
        def list = [1, 2]
        list << 3 << 4 << 5
        assert list == [1, 2, 3, 4, 5]
        def x = [] << 'a' << 'hello' << [2, 3] << 5
        assert x == ['a', 'hello', [2, 3], 5]
    }

    void testTimes() {
        def l = [4, 7, 8]
        assert l * 3 == [4, 7, 8, 4, 7, 8, 4, 7, 8]
    }

    // GROOVY-1006
    void testMinus() {
        def l1 = [1, 1, 2, 2, 3, 3, 3, 4, 5, 3, 5]
        def l2 = [1, 2.0, 4L]
        assert l1 - l2 == [3, 3, 3, 5, 3, 5]
    }

    // GROOVY-1006
    void testMinusDifferentTypes() {
        def l1 = [1, 1, "wrer", 2, 3, 3, "wrewer", 4, 5, "w", "w"]
        def l2 = [1, 2, "w"]
        assert l1 - l2 == ["wrer", 3, 3, "wrewer", 4, 5]
    }

    void testMinusEmptyCollection() {
        // GROOVY-790
        def list = [1, 1]
        assert list - [] == list

        // GROOVY-1006    
        list = [1, 2, 2, 3, 1]
        assert list - [] == list
    }

    void testIntersect() {
        def l1 = [1, 1, "wrer", 2, 3, 3, "wrewer", 4, 5, "w", "w"]
        def l2 = [1, 2, "f", "w"]
        assert l1.intersect(l2) == [1, 2, "w"]

        // GROOVY-1006    
        l1 = [1, 1.0, "wrer", 2, 3, 3L, "wrewer", 4, 5, "w", "w"]
        l2 = [(double) 1, 2L, "f", "w"]
        assert l1.intersect(l2) == [1, 2, "w"]
    }

    // GROOVY-1006
    void testListEqual() {
        assert [1, 2.0, 3L, (short) 4] == [1, 2, 3, 4]
    }

    // GROOVY-1006
    void testSortNumbersMixedType() {
        assert [1, (short) 3, 4L, 2.9, (float) 5.2].sort() == [1, 2.9, (short) 3, 4L, (float) 5.2]
    }

    // GROOVY-1006
    void testUnique() {
        def a = [1, 4L, 1.0]
        def b = a.unique()
        assert (b == a && a == [1, 4])
        a = [1, "foo", (short) 3, 4L, 1.0, (float) 3.0]
        b = a.unique()
        assert (b == a && a == [1, "foo", (short) 3, 4L])
    }

    // incorporates GROOVY-2904 and GROOVY-3102
    void testListFlatten() {
        def orig = [[[4, 5, 6, [46, 7, "erer"]], null, 4, [3, 6, 78]], 4]
        def flat = orig.flatten()
        assert flat == [4, 5, 6, 46, 7, "erer", null, 4, 3, 6, 78, 4]
    }

    void testFlattenListOfMaps() {
        def orig = [[a: 1, b: 2], [c: 3, d: 4]]
        def flat = orig.flatten()
        assert flat == orig
    }

    void testFlattenListOfArrays() {
        def orig = ["one".toList().toArray(), "two".toList().toArray()]
        def flat = orig.flatten()
        assert flat == ["o", "n", "e", "t", "w", "o"]
    }

    // incorporates GROOVY-2904 and GROOVY-3102
    void testFlattenListWithSuppliedClosure() {
        def orig = [[[4, 5, 6, [46, 7, "erer"]], null, 4, [3, 6, 78]], 4]
        def notSelfAsList = { def ans = it.iterator().toList(); ans != [it] ? ans : it }
        def flat = orig.flatten(notSelfAsList)
        assert flat == [4, 5, 6, 46, 7, "e", "r", "e", "r", 4, 3, 6, 78, 4]
    }

    void testFlattenListOfMapsWithClosure() {
        def orig = [[a: 1, b: 2], [c: 3, d: 4]]
        def flat = orig.flatten { it instanceof Map ? it.values() : it }
        assert flat == [1, 2, 3, 4]
        flat = orig.flatten { it instanceof Map ? it.keySet() : it }
        assert flat == ["a", "b", "c", "d"]
    }

    void testFlattenWithRanges() {
        def flat = [1, 3, 20..24, 33].flatten()
        assert flat == [1, 3, 20, 21, 22, 23, 24, 33]
    }

    void testListsAndRangesCompare() {
        def l = [1, 2, 3]
        def r = 1..3
        assert r == l
        assert l == r
    }

    void testRemove() {
        def l = ['a', 'b', 'c']
        l.remove(1)
        assert l == ['a', 'c']
        l.remove(0)
        assert l == ['c']
        assert l.size() == 1
    }

    void testPop() {
        def l = []
        l << 'a' << 'b'
        def value = l.pop()
        assert value == 'b'
        assert l == ['a']

        l.add('c')
        value = l.pop()
        assert value == 'c'
        value = l.pop()
        assert value == 'a'
        try {
            l.pop()
            fail("Should have thrown an exception")
        }
        catch (NoSuchElementException e) {
            assert e.message.contains('Cannot pop() an empty List')
        }
    }

    void testBoolCoerce() {
        // Explicit coercion
        assertFalse((Boolean) [])
        assertTrue((Boolean) [1])

        // Implicit coercion in statements
        List list = null
        if (list) {
            fail("null should have evaluated to false, but didn't")
        }
        list = []
        if (list) {
            fail("[] should have evaluated to false, but didn't")
        }
        list = [1]
        if (!list) {
            fail("[1] should have evaluated to true, but didn't")
        }
    }

    void testIndices() {
        assert 0..2 == [5, 6, 7].indices
        assert 0..<0 == [].indices
    }

    // see also SubscriptTest
    void testGetAtRange() {
        def list = [0, 1, 2, 3]
        assert list[0..3] == list         , 'full list'
        assert list[0..0] == [0]          , 'one element range'
        assert list[0..<0] == []          , 'empty range'
        assert list[3..0] == [3, 2, 1, 0] , 'reverse range'
        assert list[3..<0] == [3, 2, 1]   , 'reverse exclusive range'
        assert list[-2..-1] == [2, 3]     , 'negative index range'
        assert list[-2..<-1] == [2]       , 'negative index range exclusive'
        assert list[-1..-2] == [3, 2]     , 'negative index range reversed'
        assert list[-1..<-2] == [3]       , 'negative index range reversed exclusive'  // aaaahhhhh !
        assert list[0..-1] == list        , 'pos - neg value'
        assert list[0..<-1] == [0, 1, 2]  , 'pos - neg value exclusive'
        assert list[0..<-2] == [0, 1]     , 'pos - neg value exclusive'
        shouldFail(GroovyRuntimeException) { list[null] }
        shouldFail(IndexOutOfBoundsException) { list[5..6] }
    }

    void testPutAtSplice() {
        // usual assignments
        def list = [0, 1, 2, 3]
        list[1, 2] = [11, 12]
        assert list == [0, 11, 12, 3], 'same length assignment'
        list = [0, 1, 2, 3]
        shouldFail(IllegalArgumentException) {
            list[1, 1] = [11]
        }
        list = [0, 1, 2, 3]
        shouldFail(IllegalArgumentException) {
            list[1, 0] = []
        }
        // assignments outside current bounds
        list = [0, 1, 2, 3]
        list[-1, -2] = [-1, -2]
        assert list == [0, 1, -2, -1], 'left of left border'
        list = [0, 1, 2, 3]
        list[3, 4] = [3, 4]
        assert list == [0, 1, 2, 3, 4]
    }

    void testPutAtRange() {
        // usual assignments
        def list = [0, 1, 2, 3]
        list[1..2] = [11, 12]
        assert list == [0, 11, 12, 3], 'same length assignment'
        list = [0, 1, 2, 3]
        list[1..1] = [11]
        assert list == [0, 11, 2, 3], 'length 1 assignment'
        list = [0, 1, 2, 3]
        list[0..<0] = []
        assert list == [0, 1, 2, 3], 'length 0 assignment, empty splice'
        // assignments at bounds
        list = [0, 1, 2, 3]
        list[0..0] = [10]
        assert list == [10, 1, 2, 3], 'left border assignment'
        list = [0, 1, 2, 3]
        list[3..3] = [13]
        assert list == [0, 1, 2, 13], 'right border assignment'
        // assignments outside current bounds
        list = [0, 1, 2, 3]
        list[-1..-1] = [-1]
        assert list == [0, 1, 2, -1], 'left of left border'
        list = [0, 1, 2, 3]
        list[3..4] = [3, 4]
        assert list == [0, 1, 2, 3, 4]
        // structural changes
        list = [0, 1, 2, 3]
        list[1..2] = ['x']
        assert list == [0, 'x', 3], 'compacting'
        list = [0, 1, 2, 3]
        list[1..2] = ['x', 'x', 'x']
        assert list == [0, 'x', 'x', 'x', 3], 'extending'
    }

    void testCrazyPutAtRange() {
        def list = []
        list[0..<0] = [0, 1, 2, 3]
        assert list == [0, 1, 2, 3], 'fill by empty Range'
        list = [0, 1, 2, 3]
        list[3..0] = []
        assert list == [], 'delete by reverse Range'
        list = [0, 1, 2, 3]
        list[-4..-1] = []
        assert list == [], 'delete by negativ Range'
        list = [0, 1, 2, 3]
        list[0..-1] = []
        assert list == [], 'delete by pos-negativ Range'
    }

    // GROOVY-1128
    void testAsSynchronized() {
        def synclist = [].asSynchronized() << 1
        assert synclist == [1]
    }

    // GROOVY-1128
    void testAsImmutable() {
        def immlist = [1, 2, 3].asImmutable()
        assert immlist == [1, 2, 3]
        def testlist = ['a', 'b', 'c', 'd', 'e']
        assert testlist[immlist] == ['b', 'c', 'd']
        assert immlist[0] == 1
        assert immlist[0..-1] == immlist
        shouldFail(UnsupportedOperationException) {
            immlist << 1
        }
        shouldFail(UnsupportedOperationException) {
            immlist[0..<0] = [0]
        }
        shouldFail(UnsupportedOperationException) {
            immlist[0] = 1
        }
    }

    void testWithIndex_indexed_groovy7175() {
        assert [] == [].withIndex()
        assert [] == [].withIndex(10)
        assert [["a", 0], ["b", 1]] == ["a", "b"].withIndex()
        assert [["a", 5], ["b", 6]] == ["a", "b"].withIndex(5)
        assert ["0: a", "1: b"] == ["a", "b"].withIndex().collect { str, idx -> "$idx: $str" }
        assert ["1: a", "2: b"] == ["a", "b"].withIndex(1).collect { str, idx -> "$idx: $str" }
        assert [:] == [].indexed()
        assert [:] == [].indexed(10)
        assert [0: 'a', 1: 'b'] == ["a", "b"].indexed()
        assert [5: 'a', 6: 'b'] == ["a", "b"].indexed(5)
        assert ["0: a", "1: b"] == ["a", "b"].indexed().collect { idx, str -> "$idx: $str" }
        assert ["1: a", "2: b"] == ["a", "b"].indexed(1).collect { idx, str -> "$idx: $str" }
    }

    @TypeChecked
    void testWithIndex_indexed_typeChecked_groovy7175() {
        assert ["A", "BB"] == ["a", "b"].indexed(1).collect { idx, str -> str.toUpperCase() * idx }
    }

    // GROOVY-4946
    void testLazyDefault() {
        def l1 = [].withLazyDefault { 42 }
        assert l1[0] == 42
        assert l1[2] == 42
        assert l1 == [42, null, 42]
        assert l1[1] == 42

        def l3 = [].withLazyDefault { it }
        assert l3[1] == 1
        assert l3[3] == 3

        def l4 = [0, 1, null, 3].withLazyDefault { 42 }
        assert l4[0] == 0
        assert l4[1] == 1
        assert l4[3] == 3
        assert l4 == [0, 1, null, 3]

        def l5 = [].withLazyDefault { it }
        assert l5[1] == 1
        assert l5[3] == 3
        assert l5[5] == 5
        assert l5 == [null, 1, null, 3, null, 5]

        def l6 = [].withLazyDefault { int index -> index }
        assert l6[1] == 1
        assert l6[3] == 3
        assert l6[5] == 5
        assert l6[0..5] == [null, 1, null, 3, null, 5]
    }

    void testEagerDefault() {
        def l1 = [].withEagerDefault { 42 }
        assert l1[0] == 42
        assert l1[2] == 42
        assert l1 == [42, 42, 42]
        assert l1[1] == 42
        assert l1[-1] == 42
        assert l1[-3] == 42

        def l2 = [].withEagerDefault { 42 }
        assert l2[0] == 42

        def l3 = [].withEagerDefault { it }
        assert l3[1] == 1
        assert l3[3] == 3
        assert l3 == [0, 1, 2, 3]

        def l4 = [0, 1, null, 3].withEagerDefault { 42 }
        assert l4[0] == 0
        assert l4[1] == 1
        assert l4[3] == 3
        assert l4 == [0, 1, null, 3]

        def l5 = [].withEagerDefault { it }
        assert l5[1] == 1
        assert l5[3] == 3
        assert l5[5] == 5
        assert l5 == [0, 1, 2, 3, 4, 5]

        def l6 = [].withEagerDefault { int index -> index }
        assert l6[1] == 1
        assert l6[3] == 3
        assert l6[5] == 5
        assert l6[0..5] == [0, 1, 2, 3, 4, 5]
    }

    void testDefaultReturnWithDefaultSubList() {
        def l1 = [].withLazyDefault { 42 }
        assert l1[2] == 42
        assert l1 == [null, null, 42]

        def l2 = l1.subList(0, 2)
        assert l2 == [null, null]
        assert l2[2] == 42
        assert l2 == [null, null, 42]
    }

    void testDefaultRedirectsToWithLazyDefault() {
        def l1 = [].withDefault { 42 }
        assert l1[2] == 42
        assert l1 == [null, null, 42]
    }

    void testDefaultNullAsDefaultValue() {
        def l1 = [].withEagerDefault { null }
        assert l1[0] == null
        assert l1[2] == null
        assert l1 == [null, null, null]
    }

    void testLazyListAndRangeAccess() {
        def l1 = [].withDefault { 42 }
        assert [null, 42] == l1[1..2]
    }

    void testEagerListAndRangeAccess() {
        def l1 = [].withEagerDefault { 42 }
        assert [42, 42] == l1[1..2]
    }

    void testLazyListAndNegativeIndexAccess() {
        def l1 = [].withDefault { 42 }
        assert 42 == l1[1]
        assert 42 == l1[-1]
    }

    void testeEagerListAndNegativeIndexAccess() {
        def l1 = [].withEagerDefault { 42 }
        assert 42 == l1[1]
        assert 42 == l1[-1]
    }

    void testLazyListAndNegativeRangeAccess() {
        def l1 = [].withDefault { 42 }
        assert 42 == l1[0]
        assert 42 == l1[1]

        def subList = l1[0..-1]
        assert [42, 42] == subList
    }

    void testEagerListAndNegativeRangeAccess() {
        def l1 = [].withEagerDefault { 42 }
        assert 42 == l1[0]
        assert 42 == l1[1]

        def subList = l1[0..-1]
        assert [42, 42] == subList
    }

    void testLazyListAndFailingNegativeRangeAccess() {
        def l1 = [].withDefault { 42 }

        shouldFail(IndexOutOfBoundsException) {
            l1[-42..0]
        }
    }

    void testEagerListAndFailingNegativeRangeAccess() {
        def l1 = [].withEagerDefault { 42 }

        shouldFail(IndexOutOfBoundsException) {
            l1[-42..0]
        }
    }

    void testLazyListAndEmptyRangeAccess() {
        def l1 = [].withDefault { 42 }
        assert l1[0..<0] instanceof ListWithDefault
        assert l1[0..<0] == []
    }

    void testEagerListAndEmptyRangeAccess() {
        def l1 = [].withEagerDefault { 42 }
        assert l1[0..<0] instanceof ListWithDefault
        assert l1[0..<0] == []
    }

    void testLazyListAndReversedRangeAccess() {
        def l1 = [].withDefault { 42 }

        assert 42 == l1[0]
        assert 42 == l1[1]
        assert 42 == l1[2]

        def subList = l1[2..0]
        assert subList instanceof ListWithDefault
    }

    void testEagerListAndReversedRangeAccess() {
        def l1 = [].withEagerDefault { 42 }

        assert 42 == l1[0]
        assert 42 == l1[1]
        assert 42 == l1[2]

        def subList = l1[2..0]
        assert subList instanceof ListWithDefault
    }

    void testLazyListAndCollectionOfIndices() {
        def l1 = [].withDefault { 42 }
        assert [42, 42, 42] == l1[0,1,2]
        assert l1.size() == 3
    }

    void testEagerListAndCollectionOfIndices() {
        def l1 = [].withEagerDefault { 42 }
        assert [42, 42, 42] == l1[0,1,2]
        assert l1.size() == 3
    }

    void testLazyListAndCollectionOfCollectionIndices() {
        def l1 = [].withDefault { 42 }
        assert [42, 42, 42] == l1[0,[1,2]]
        assert l1.size() == 3
    }

    void testLazyListAndCollectionOfRangeIndices() {
        def l1 = [].withDefault { 42 }
        assert [42, null, 42] == l1[0,[1..2]]
        assert l1.size() == 3
    }

    void testEagerListAndCollectionOfRangeIndices() {
        def l1 = [].withEagerDefault { 42 }
        assert [42, 42, 42] == l1[0,[1..2]]
        assert l1.size() == 3
    }

    void testDefaultAndCollectionOfIndicesReturnsCorrectType() {
        def l1 = [].withDefault { 42 }
        assert  l1[0,[1..2]] instanceof ListWithDefault
    }

    void testLazyListAndUnorderedCollectionIndices() {
        def l1 = [].withLazyDefault { 42 }

        assert [42, 42, 42] == l1[2, 0, 3]
    }

    void testLazyListAndNegativeReversedRangeAccess() {
        def a = [1].withDefault {42}
        assert a[2..-1] == [42, null, 1]
    }

    void testEagerListAndNegativeReversedRangeAccess() {
        def a = [1].withEagerDefault {42}
        assert a[2..-1] == [42, 42, 1]
    }

    void testEagerListAndNegativeCollectionIndicesAccess() {
        def a = [1].withEagerDefault {42}
        assert a[0,-1] == [1, 1]
    }

    void testEagerLazyListInvocation() {
        def a = [1].withEagerDefault {42}.withEagerDefault {43}
        assert a[0,2,-1] == [1, 43, 43]
    }

    void testEagerListWithNegativeIndex() {
        def a = [].withEagerDefault { 42 }
        shouldFail(IndexOutOfBoundsException) {
            a[-2]
        }
    }

    void testLazyListCollectionIndicesSubList() {
        def list = [1].withDefault{42}
        assert list[4] == 42
        assert list == [1, null, null, null, 42]

        def sub = list[0,2,4]
        assert sub.size() == 3
        assert sub[3] == 42
    }

    void testLazyListRangeIndexSubList() {
        def list = [1].withDefault{42}
        assert list[4] == 42
        assert list == [1, null, null, null, 42]

        def sub = list[0..4]
        assert sub[5] == 42
    }

    void testCollectionAccessCreatesListCopy() {
        def list = [0,1,2,3]
        def sublist = list[0,1]

        assert sublist == [0,1]

        sublist[0] = 42

        assert sublist == [42, 1]
        assert list == [0,1,2,3]
    }

    void testLazyListCollectionAccessCreatesListCopy() {
        def list = [0,1,2,3].withDefault { 42 }
        def sublist = list[0,1]

        assert sublist == [0,1]

        sublist[0] = 42

        assert sublist == [42, 1]
        assert list == [0,1,2,3]
    }

    void testRangeAccessCreatesListCopy() {
        def list = [0,1,2,3]
        def sublist = list[0..<2]

        assert sublist == [0,1]

        sublist[0] = 42

        assert sublist == [42, 1]
        assert list == [0,1,2,3]
    }

    void testLazyListRangeAccessCreatesListCopy() {
        def list = [0,1,2,3].withDefault { 42 }
        def sublist = list[0..<2]

        assert sublist == [0,1]

        sublist[0] = 42

        assert sublist == [42, 1]
        assert list == [0,1,2,3]
    }

    void testLazyListSubListCreatesListDelegateCopy() {
        def list = [0,1,2,3].withDefault { 42 }
        def sublist = list[0..1]

        assert sublist instanceof ListWithDefault
        assert sublist.size() == 2

        sublist[0] = 42

        assert list == [0,1,2,3]
    }

    void testReversedRangeAccessCreatesListCopy() {
        def list = [0,1,2,3]
        def sublist = list[1..0]

        assert sublist == [1,0]

        sublist[0] = 42

        assert sublist == [42, 0]
        assert list == [0,1,2,3]
    }

    void testReversedLazyListRangeAccessCreatesListCopy() {
        def list = [0,1,2,3].withDefault { 42 }
        def sublist = list[1..0]

        assert sublist == [1,0]

        sublist[0] = 42

        assert sublist == [42, 0]
        assert list == [0,1,2,3]
    }

    void testRangeAccessOnLinkedListCreatesLinkedListCopy() {
        def list = new LinkedList([0,1,2,3])
        def sublist = list[0..<2]

        assert sublist == [0,1]
        assert sublist instanceof LinkedList
    }

    void testReversedRangeAccessOnLinkedListCreatesLinkedListCopy() {
        def list = new LinkedList([0,1,2,3])
        def sublist = list[1..0]

        assert sublist == [1,0]
        assert sublist instanceof LinkedList
    }

    void testEmptyRangeAccessReturnsLinkedListCopy() {
        def list = new LinkedList([0,1,2,3])
        assert list[0..<0] instanceof LinkedList
    }

    void testRemoveAt() {
        shouldFail(IndexOutOfBoundsException) {
            [].removeAt(0)
        }
        def list = [1, 2, 3]
        assert 2 == list.removeAt(1)
        assert [1, 3] == list
    }

    void testRemoveElement() {
        def list = [1, 2, 3, 2]
        assert list.removeElement(2)
        assert [1, 3, 2] == list
        assert !list.removeElement(4)
        assert [1, 3, 2] == list
    }

    // GROOVY-7299
    void testMultipleVeryLongLlists() {
        def script = "def a = ["+'1000,'*2000+"];def b = ["+'1000,'*2000+"]; def c=(a+b).sum(); assert c==4_000_000";
        assertScript script
    }
}
