# -*- coding: utf-8 -*-

from ..syntax import macros, test, test_raises, the # noqa: F401

from ..test.fixtures import session, testset

from itertools import count, repeat

from collections import namedtuple

from ..fup import fupdate

from ..collections import frozendict

from ..gmemo import imemoize

def runtests():

with testset("mutable sequence"):

lst = [1, 2, 3]

out = fupdate(lst, 1, 42)

test[lst == [1, 2, 3]]

test[out == [1, 42, 3]]

test[type(out) is type(lst)]

with testset("immutable sequence"):

tup = (1, 2, 3, 4, 5)

out = fupdate(tup, slice(1, 5, 2), tuple(repeat(10, 2)))

test[tup == (1, 2, 3, 4, 5)]

test[out == (1, 10, 3, 10, 5)]

test[type(out) is type(tup)]

test[the[fupdate(tup)] == the[tup]] # no indices, no bindings --> copy

with testset("namedtuple"):

A = namedtuple("A", "p q")

a = A(17, 23)

out = fupdate(a, 0, 42)

test[a == A(17, 23)]

test[out == A(42, 23)]

test[the[type(out)] is the[type(a)]]

with testset("mutable mapping"):

d1 = {'foo': 'bar', 'fruit': 'apple'}

d2 = fupdate(d1, foo='tavern')

test[sorted(d1.items()) == [('foo', 'bar'), ('fruit', 'apple')]]

test[sorted(d2.items()) == [('foo', 'tavern'), ('fruit', 'apple')]]

test[the[type(d2)] is the[type(d1)]]

with testset("immutable mapping (unpythonic.collections.frozendict)"):

d3 = frozendict({'a': 1, 'b': 2})

d4 = fupdate(d3, a=23)

test[the[d4['a']] == 23 and the[d4['b']] == 2]

test[d3['a'] == 1]

test[the[type(d4)] is the[type(d3)]]

with testset("negative index"):

lst = [1, 2, 3]

out = fupdate(lst, -1, 42)

test[lst == [1, 2, 3]]

test[out == [1, 2, 42]]

with testset("no start index"):

tup = (1, 2, 3, 4, 5)

out = fupdate(tup, slice(None, 5, 2), tuple(repeat(10, 3)))

test[tup == (1, 2, 3, 4, 5)]

test[out == (10, 2, 10, 4, 10)]

with testset("no stop index"):

tup = (1, 2, 3, 4, 5)

out = fupdate(tup, slice(1, None, 2), tuple(repeat(10, 2)))

test[tup == (1, 2, 3, 4, 5)]

test[out == (1, 10, 3, 10, 5)]

with testset("no start or stop index, just step"):

tup = (1, 2, 3, 4, 5)

out = fupdate(tup, slice(None, None, 2), tuple(repeat(10, 3)))

test[tup == (1, 2, 3, 4, 5)]

test[out == (10, 2, 10, 4, 10)]

with testset("just step, backwards"):

tup = (1, 2, 3, 4, 5)

out = fupdate(tup, slice(None, None, -1), tuple(range(5)))

test[tup == (1, 2, 3, 4, 5)]

test[out == (4, 3, 2, 1, 0)]

out = fupdate(tup, slice(None, None, -1), range(5)) # no tuple() needed

test[out == (4, 3, 2, 1, 0)]

with testset("multiple individual items"):

tup = (1, 2, 3, 4, 5)

out = fupdate(tup, (1, 2, 3), (17, 23, 42))

test[tup == (1, 2, 3, 4, 5)]

test[out == (1, 17, 23, 42, 5)]

with testset("multiple slices and sequences"):

tup = tuple(range(10))

out = fupdate(tup, (slice(0, 10, 2), slice(1, 10, 2)),

(tuple(repeat(2, 5)), tuple(repeat(3, 5))))

test[tup == tuple(range(10))]

test[out == (2, 3, 2, 3, 2, 3, 2, 3, 2, 3)]

with testset("infinite replacement"):

tup = (1, 2, 3, 4, 5)

out = fupdate(tup, slice(None, None, None), repeat(42))

test[out == (42, 42, 42, 42, 42)]

tup = (1, 2, 3, 4, 5)

out = fupdate(tup, slice(None, None, None), count(start=10))

test[out == (10, 11, 12, 13, 14)]

with testset("memoized infinite replacement, reading its start backwards"):

tup = (1, 2, 3, 4, 5)

out = fupdate(tup, slice(None, None, -1), imemoize(repeat(42))())

test[out == (42, 42, 42, 42, 42)]

tup = (1, 2, 3, 4, 5)

out = fupdate(tup, slice(None, None, -1), imemoize(count(start=10))())

test[out == (14, 13, 12, 11, 10)]

with testset("mix and match"):

tup = tuple(range(10))

out = fupdate(tup, (slice(0, 10, 2), slice(1, 10, 2), 6),

(tuple(repeat(2, 5)), tuple(repeat(3, 5)), 42))

test[tup == tuple(range(10))]

test[out == (2, 3, 2, 3, 2, 3, 42, 3, 2, 3)]

with testset("error cases"):

with test_raises[IndexError, "should detect replacement sequence too short"]:

tup = (1, 2, 3, 4, 5)

out = fupdate(tup, slice(1, None, 2), (10,)) # need 2 items, have 1

# cannot specify both indices and bindings

test_raises[ValueError, fupdate(tup, slice(1, None, 2), (10,), somename="some value")]

# not memoized, cannot read a general iterable backwards

tup = (1, 2, 3, 4, 5)

test_raises[IndexError, fupdate(tup, slice(None, None, -1), count(start=10))]

if __name__ == '__main__': # pragma: no cover

with session(__file__):

runtests()