def test_copy(self):
a = values(1, 2, 3)
b = values(foo=4, bar=5)
c = values(1, 2, 3, foo=4, bar=5)
d = a(values)
e = b(values)
f = c(values)
self.assertEqual(a, d)
self.assertEqual(b, e)
self.assertEqual(c, f)
def test_copy(self):
a = values(1, 2, 3)
b = values(foo=4, bar=5)
c = values(1, 2, 3, foo=4, bar=5)
d = a(values)
e = b(values)
f = c(values)
self.assertEqual(a, d)
self.assertEqual(b, e)
self.assertEqual(c, f)
def test_repr(self):
"""
tests that the repr of a values is as expected.
"""
a = values()
self.assertEqual(repr(a), "values()")
a = values(1, 2, 3)
self.assertEqual(repr(a), "values(1, 2, 3)")
a = values(foo=4)
self.assertEqual(repr(a), "values(foo=4)")
a = values(1, 2, 3, foo=4)
self.assertEqual(repr(a), "values(1, 2, 3, foo=4)")
def test_repr(self):
"""
tests that the repr of a values is as expected.
"""
a = values()
self.assertEqual(repr(a), "values()")
a = values(1, 2, 3)
self.assertEqual(repr(a), "values(1, 2, 3)")
a = values(foo=4)
self.assertEqual(repr(a), "values(foo=4)")
a = values(1, 2, 3, foo=4)
self.assertEqual(repr(a), "values(1, 2, 3, foo=4)")
def test_addition(self):
a = values()
self.assertEqual(a + a, a)
self.assertEqual(a + (), a)
b = values(1, 2)
c = values(3, 4)
d = values(1, 2, 3, 4)
self.assertEqual(a + b, b)
self.assertEqual(a + c, c)
self.assertEqual(b + c, d)
self.assertEqual(a + b + c, d)
e = values(foo=1, bar=2)
f = values(baz=3, qux=4)
g = values(foo=1, bar=2, baz=3, qux=4)
self.assertEqual(a + e, e)
self.assertEqual(f + a, f)
self.assertEqual(e + f, g)
self.assertEqual(a + e + f + a, g)
self.assertEqual(e + dict(baz=3, qux=4), g)
self.assertEqual(dict(foo=1, bar=2) + f, g)
def test_addition(self):
a = values()
self.assertEqual(a + a, a)
self.assertEqual(a + (), a)
b = values(1, 2)
c = values(3, 4)
d = values(1, 2, 3, 4)
self.assertEqual(a + b, b)
self.assertEqual(a + c, c)
self.assertEqual(b + c, d)
self.assertEqual(a + b + c, d)
e = values(foo=1, bar=2)
f = values(baz=3, qux=4)
g = values(foo=1, bar=2, baz=3, qux=4)
self.assertEqual(a + e, e)
self.assertEqual(f + a, f)
self.assertEqual(e + f, g)
self.assertEqual(a + e + f + a, g)
self.assertEqual(e + dict(baz=3, qux=4), g)
self.assertEqual(dict(foo=1, bar=2) + f, g)
def test_mapping(self):
"""
tests treating the values object as a mapping, including equality
operations against other mappings
"""
a = values(a=1, b=2, c=3)
b = values(a=4, b=5, c=6)
self.assertEqual(dict(a), {'a': 1, 'b': 2, 'c': 3})
self.assertEqual(dict(b), {'a': 4, 'b': 5, 'c': 6})
# equality works in both directions
self.assertEqual(a, {'a': 1, 'b': 2, 'c': 3})
self.assertEqual({'a': 1, 'b': 2, 'c': 3}, a)
self.assertEqual(b, {'a': 4, 'b': 5, 'c': 6})
self.assertEqual({'a': 4, 'b': 5, 'c': 6}, b)
# so does inequality
self.assertNotEqual(a, {'a': 4, 'b': 5, 'c': 6})
self.assertNotEqual({'a': 4, 'b': 5, 'c': 6}, a)
self.assertNotEqual(b, {'a': 1, 'b': 2, 'c': 3})
self.assertNotEqual({'a': 1, 'b': 2, 'c': 3}, b)
c = values(1, 2, 3, a=4, b=5, c=6)
# whether it has positionals or not, only the keywords get
# converted over this way
self.assertEqual(dict(c), {'a': 4, 'b': 5, 'c': 6})
# a values with positionals can never be equivalent to a map
self.assertNotEqual(c, {'a': 4, 'b': 5, 'c': 6})
self.assertNotEqual({'a': 4, 'b': 5, 'c': 6}, c)
# test for equality with empty mappings (which means the
# underlying dict ref is probably NULL
v = values()
self.assertEqual(v, dict())
self.assertEqual(dict(), v)
self.assertNotEqual(v, dict(foo=1))
self.assertNotEqual(dict(foo=1), v)
def test_mapping(self):
"""
tests treating the values object as a mapping, including equality
operations against other mappings
"""
a = values(a=1, b=2, c=3)
b = values(a=4, b=5, c=6)
self.assertEqual(dict(a), {'a': 1, 'b': 2, 'c': 3})
self.assertEqual(dict(b), {'a': 4, 'b': 5, 'c': 6})
# equality works in both directions
self.assertEqual(a, {'a': 1, 'b': 2, 'c': 3})
self.assertEqual({'a': 1, 'b': 2, 'c': 3}, a)
self.assertEqual(b, {'a': 4, 'b': 5, 'c': 6})
self.assertEqual({'a': 4, 'b': 5, 'c': 6}, b)
# so does inequality
self.assertNotEqual(a, {'a': 4, 'b': 5, 'c': 6})
self.assertNotEqual({'a': 4, 'b': 5, 'c': 6}, a)
self.assertNotEqual(b, {'a': 1, 'b': 2, 'c': 3})
self.assertNotEqual({'a': 1, 'b': 2, 'c': 3}, b)
c = values(1, 2, 3, a=4, b=5, c=6)
# whether it has positionals or not, only the keywords get
# converted over this way
self.assertEqual(dict(c), {'a': 4, 'b': 5, 'c': 6})
# a values with positionals can never be equivalent to a map
self.assertNotEqual(c, {'a': 4, 'b': 5, 'c': 6})
self.assertNotEqual({'a': 4, 'b': 5, 'c': 6}, c)
# test for equality with empty mappings (which means the
# underlying dict ref is probably NULL
v = values()
self.assertEqual(v, dict())
self.assertEqual(dict(), v)
self.assertNotEqual(v, dict(foo=1))
self.assertNotEqual(dict(foo=1), v)
def test_subscript(self):
"""
tests that subscripting will defer correctly between positional
and keyword members
"""
a = values(1, 2, 3, a=4, b=5)
self.assertEqual(a[0], 1)
self.assertEqual(a[1], 2)
self.assertEqual(a[2], 3)
self.assertEqual(a['a'], 4)
self.assertEqual(a['b'], 5)
self.assertRaises(IndexError, lambda: a[3])
self.assertRaises(KeyError, lambda: a['c'])
b = values(1, 2, 3)
self.assertRaises(KeyError, lambda: b['a'])
def test_subscript(self):
"""
tests that subscripting will defer correctly between positional
and keyword members
"""
a = values(1, 2, 3, a=4, b=5)
self.assertEqual(a[0], 1)
self.assertEqual(a[1], 2)
self.assertEqual(a[2], 3)
self.assertEqual(a['a'], 4)
self.assertEqual(a['b'], 5)
self.assertRaises(IndexError, lambda: a[3])
self.assertRaises(KeyError, lambda: a['c'])
b = values(1, 2, 3)
self.assertRaises(KeyError, lambda: b['a'])
def test_invoke_more(self):
def gather(a, b, c, d=0):
return [a, b, c, d]
v = values(1, 2, 3)
self.assertRaises(TypeError, v)
self.assertEqual(v(gather, d=9), [1, 2, 3, 9])
v = values(1, 2, 3, d=4)
self.assertEqual(v(gather, d=9), [1, 2, 3, 9])
self.assertRaises(TypeError, v, gather, 9)
self.assertRaises(TypeError, v, gather, x=9)
v = values()
self.assertEqual(v(gather, 1, 2, 3), [1, 2, 3, 0])
self.assertEqual(v(gather, 1, 2, 3, d=9), [1, 2, 3, 9])
v = values(1)
self.assertEqual(v(gather, 2, 3), [1, 2, 3, 0])
self.assertEqual(v(gather, 2, 3, d=9), [1, 2, 3, 9])
def test_bool(self):
"""
Tests truthiness of values
"""
# empty values is the only False values
v = values()
self.assertFalse(v)
self.assertTrue(not v)
v = values(1, 2, 3)
self.assertTrue(v)
self.assertFalse(not v)
v = values(foo=4, bar=5)
self.assertTrue(v)
self.assertFalse(not v)
v = values(1, 2, 3, foo=4, bar=5)
self.assertTrue(v)
self.assertFalse(not v)
def test_invoke_more(self):
def gather(a, b, c, d=0):
return [a, b, c, d]
v = values(1, 2, 3)
self.assertRaises(TypeError, v)
self.assertEqual(v(gather, d=9), [1, 2, 3, 9])
v = values(1, 2, 3, d=4)
self.assertEqual(v(gather, d=9), [1, 2, 3, 9])
self.assertRaises(TypeError, v, gather, 9)
self.assertRaises(TypeError, v, gather, x=9)
v = values()
self.assertEqual(v(gather, 1, 2, 3), [1, 2, 3, 0])
self.assertEqual(v(gather, 1, 2, 3, d=9), [1, 2, 3, 9])
v = values(1)
self.assertEqual(v(gather, 2, 3), [1, 2, 3, 0])
self.assertEqual(v(gather, 2, 3, d=9), [1, 2, 3, 9])
def test_bool(self):
"""
Tests truthiness of values
"""
# empty values is the only False values
v = values()
self.assertFalse(v)
self.assertTrue(not v)
v = values(1, 2, 3)
self.assertTrue(v)
self.assertFalse(not v)
v = values(foo=4, bar=5)
self.assertTrue(v)
self.assertFalse(not v)
v = values(1, 2, 3, foo=4, bar=5)
self.assertTrue(v)
self.assertFalse(not v)
def test_sequence(self):
"""
tests treating the values object as a sequence, including equality
operations against other sequences
"""
a = values(1, 2, 3)
b = values(4, 5, 6)
self.assertEqual(len(a), 3)
self.assertEqual(len(b), 3)
self.assertEqual(sum(a), 6)
self.assertEqual(sum(b), 15)
self.assertEqual(list(a), [1, 2, 3])
self.assertEqual(list(b), [4, 5, 6])
self.assertEqual(a, (1, 2, 3))
self.assertEqual((1, 2, 3), a)
self.assertEqual(b, (4, 5, 6))
self.assertEqual((4, 5, 6), b)
self.assertNotEqual(a, (4, 5, 6))
self.assertNotEqual((4, 5, 6), a)
self.assertNotEqual(b, (1, 2, 3))
self.assertNotEqual((1, 2, 3), b)
c = values(1, 2, 3, foo=5)
self.assertEqual(list(c), [1, 2, 3])
self.assertNotEqual(c, (1, 2, 3))
self.assertNotEqual((1, 2, 3), c)
self.assertEqual(len(c), 3)
self.assertEqual(len(values()), 0)
self.assertEqual(len(values(foo=2)), 0)
self.assertEqual(len(values(9)), 1)
self.assertEqual(len(values(9, foo=8)), 1)
def test_sequence(self):
"""
tests treating the values object as a sequence, including equality
operations against other sequences
"""
a = values(1, 2, 3)
b = values(4, 5, 6)
self.assertEqual(len(a), 3)
self.assertEqual(len(b), 3)
self.assertEqual(sum(a), 6)
self.assertEqual(sum(b), 15)
self.assertEqual(list(a), [1, 2, 3])
self.assertEqual(list(b), [4, 5, 6])
self.assertEqual(a, (1, 2, 3))
self.assertEqual((1, 2, 3), a)
self.assertEqual(b, (4, 5, 6))
self.assertEqual((4, 5, 6), b)
self.assertNotEqual(a, (4, 5, 6))
self.assertNotEqual((4, 5, 6), a)
self.assertNotEqual(b, (1, 2, 3))
self.assertNotEqual((1, 2, 3), b)
c = values(1, 2, 3, foo=5)
self.assertEqual(list(c), [1, 2, 3])
self.assertNotEqual(c, (1, 2, 3))
self.assertNotEqual((1, 2, 3), c)
self.assertEqual(len(c), 3)
self.assertEqual(len(values()), 0)
self.assertEqual(len(values(foo=2)), 0)
self.assertEqual(len(values(9)), 1)
self.assertEqual(len(values(9, foo=8)), 1)
def test_invoke(self):
"""
tests that invocation functions as expected, and raises the
appropriate TypeErrors when there's a mismatch between the
values members and the function signature
todo: currently only unary invocation works. ie. you have to
pass only one argument to a values instance, and that must be
a callable that has a signature that works with the contents
of the values. Later on, I'll add support for passing
additional arguments along such that positional arguments are
appended to the values' positionals, and keyword arguments are
merged (with the invocation ones winning)
"""
def gather(a, b, c, d=0):
return [a, b, c, d]
v = values(1, 2, 3)
self.assertEqual(v(gather), [1, 2, 3, 0])
v = values(1, 2, 3, 4)
self.assertEqual(v(gather), [1, 2, 3, 4])
v = values(1, 2, 3, d=9)
self.assertEqual(v(gather), [1, 2, 3, 9])
v = values(c=8, b=7, a=6)
self.assertEqual(v(gather), [6, 7, 8, 0])
v = values(d=9, c=8, b=7, a=6)
self.assertEqual(v(gather), [6, 7, 8, 9])
v = values()
self.assertRaises(TypeError, v)
self.assertRaises(TypeError, v, gather)
v = values(d=5)
self.assertRaises(TypeError, v, gather)
v = values(1, 2)
self.assertRaises(TypeError, v, gather)
v = values(1, 2, d=5)
self.assertRaises(TypeError, v, gather)
v = values(1, 2, 3, 4, 5)
self.assertRaises(TypeError, v, gather)
v = values(1, 2, 3, foo=100)
self.assertRaises(TypeError, v, gather)
def test_invoke(self):
"""
tests that invocation functions as expected, and raises the
appropriate TypeErrors when there's a mismatch between the
values members and the function signature
todo: currently only unary invocation works. ie. you have to
pass only one argument to a values instance, and that must be
a callable that has a signature that works with the contents
of the values. Later on, I'll add support for passing
additional arguments along such that positional arguments are
appended to the values' positionals, and keyword arguments are
merged (with the invocation ones winning)
"""
def gather(a, b, c, d=0):
return [a, b, c, d]
v = values(1, 2, 3)
self.assertEqual(v(gather), [1, 2, 3, 0])
v = values(1, 2, 3, 4)
self.assertEqual(v(gather), [1, 2, 3, 4])
v = values(1, 2, 3, d=9)
self.assertEqual(v(gather), [1, 2, 3, 9])
v = values(c=8, b=7, a=6)
self.assertEqual(v(gather), [6, 7, 8, 0])
v = values(d=9, c=8, b=7, a=6)
self.assertEqual(v(gather), [6, 7, 8, 9])
v = values()
self.assertRaises(TypeError, v)
self.assertRaises(TypeError, v, gather)
v = values(d=5)
self.assertRaises(TypeError, v, gather)
v = values(1, 2)
self.assertRaises(TypeError, v, gather)
v = values(1, 2, d=5)
self.assertRaises(TypeError, v, gather)
v = values(1, 2, 3, 4, 5)
self.assertRaises(TypeError, v, gather)
v = values(1, 2, 3, foo=100)
self.assertRaises(TypeError, v, gather)
def test_hashing(self):
"""
Test that the hashing works for values
"""
a = values()
b = values()
self.assertEqual(hash(a), hash(a))
self.assertEqual(hash(a), hash(b))
self.assertEqual(hash(a), hash(tuple(a)))
c = values(1, 2, 3)
d = values(1, 2, 3)
e = values(4, 5, 6)
self.assertEqual(hash(c), hash(c))
self.assertEqual(hash(c), hash(d))
self.assertNotEqual(hash(c), hash(e))
self.assertNotEqual(hash(c), hash(a)) # vs. values()
self.assertEqual(hash(c), hash(tuple(c)))
f = values(foo=11, bar=12)
g1 = values(foo=11, bar=12)
g2 = values(bar=12, foo=11)
h = values(foo=21, bar=22, baz=99)
self.assertEqual(hash(f), hash(f))
self.assertEqual(hash(f), hash(g1))
self.assertEqual(hash(f), hash(g2))
self.assertNotEqual(hash(f), hash(h))
self.assertNotEqual(hash(f), hash(c)) # vs. values(1, 2, 3)
self.assertNotEqual(hash(f), hash(a)) # vs. values()
self.assertNotEqual(hash(f), hash(tuple(f)))
i = values(1, 2, 3, foo=4, bar=5)
j1 = values(1, 2, 3, foo=4, bar=5)
j2 = values(1, 2, 3, bar=5, foo=4)
k = values(4, 5, 6, foo=4, bar=5)
l = values(1, 2, 3, foo=9, bar=10)
m = values(4, 5, 6, foo=9, bar=10)
self.assertEqual(hash(i), hash(i))
self.assertEqual(hash(i), hash(j1))
self.assertEqual(hash(i), hash(j2))
self.assertNotEqual(hash(i), hash(k)) # diff args, same kwds
self.assertNotEqual(hash(i), hash(l)) # same args, diff kwds
self.assertNotEqual(hash(i), hash(m)) # diff args, diff kwds
self.assertNotEqual(hash(i), hash(tuple(i)))
bad_1 = values({"a": 1})
self.assertRaises(TypeError, hash, bad_1)
bad_2 = values(b={"b": 1})
self.assertRaises(TypeError, hash, bad_2)
bad_3 = values({"a": 1}, b={"b": 1})
self.assertRaises(TypeError, hash, bad_3)
data = {
values(): "wut",
values(1, 2, 3): "tacos",
values(foo=9): "foo niner",
values(2, 2, hands='blue'): "serenity",
}
setter = data.__setitem__
getter = data.__getitem__
self.assertEqual(data[values()], "wut")
self.assertEqual(data[()], "wut")
self.assertEqual(data[values(1, 2, 3)], "tacos")
self.assertEqual(data[(1, 2, 3)], "tacos")
self.assertEqual(data[values(foo=9)], "foo niner")
self.assertEqual(data[values(2, 2, hands='blue')], "serenity")
self.assertRaises(TypeError, setter, bad_1, None)
self.assertRaises(TypeError, setter, bad_2, None)
self.assertRaises(TypeError, setter, bad_3, None)
self.assertRaises(TypeError, getter, bad_1)
self.assertRaises(TypeError, getter, bad_2)
self.assertRaises(TypeError, getter, bad_3)
self.assertRaises(KeyError, getter, (1, 2, 3, 4))
self.assertRaises(KeyError, getter, values(1, 2, 3, foo=9))
self.assertRaises(KeyError, getter, values(2, 2, hands='tiny'))
self.assertRaises(KeyError, getter, values(hands='blue'))
self.assertRaises(KeyError, getter, values(1, 2, 3, 4))
self.assertRaises(KeyError, getter, values(bar=None))
def test_equality(self):
"""
tests to ensure the equality operations of a values are
functioning correctly when compared with another values
instance
"""
# permutations of values with only args
a = values(1, 2, 3)
b = values(1, 2, 3)
c = values(4, 5, 6)
self.assertEqual(a, a)
self.assertEqual(a, b)
self.assertEqual(b, a)
self.assertNotEqual(a, c)
self.assertNotEqual(b, c)
# permutations of values with only kwds
d = values(foo=9, bar=10)
e = values(foo=9, bar=10)
f = values(foo=100, quuz=200)
self.assertEqual(d, d)
self.assertEqual(d, e)
self.assertEqual(e, d)
self.assertNotEqual(d, f)
self.assertNotEqual(f, d)
self.assertNotEqual(a, d)
self.assertNotEqual(d, a)
# permutations of values with both args and kwds
g = values(1, 2, 3, foo=9, bar=10)
h = values(1, 2, 3, foo=9, bar=10)
i = values(1, 2, 3, foo=100, quuz=200)
j = values(4, 5, 6, foo=9, bar=10)
k = values(4, 5, 6, foo=100, quuz=200)
self.assertEqual(g, g) # identity
self.assertEqual(g, h) # similar
self.assertEqual(h, g) # - reversed
self.assertNotEqual(a, g) # args vs. args and kwds
self.assertNotEqual(g, a) # args and kwds vs. args
self.assertNotEqual(d, g) # kwds vs. args and kwds
self.assertNotEqual(g, d) # args and kwds vs. kwds
self.assertNotEqual(g, i) # args same, kwds differ
self.assertNotEqual(i, g) # - reversed
self.assertNotEqual(g, j) # args differ, kwds same
self.assertNotEqual(j, g) # - reversed
self.assertNotEqual(g, k) # ares and kwds differ
self.assertNotEqual(k, g) # - reversed
# the empty values, test it against the non-empty ones to make
# sure nothing breaks
z = values()
self.assertNotEqual(a, z)
self.assertNotEqual(z, a)
self.assertNotEqual(d, z)
self.assertNotEqual(z, d)
self.assertNotEqual(g, z)
self.assertNotEqual(z, g)
def test_hashing(self):
"""
Test that the hashing works for values
"""
a = values()
b = values()
self.assertEqual(hash(a), hash(a))
self.assertEqual(hash(a), hash(b))
self.assertEqual(hash(a), hash(tuple(a)))
c = values(1, 2, 3)
d = values(1, 2, 3)
e = values(4, 5, 6)
self.assertEqual(hash(c), hash(c))
self.assertEqual(hash(c), hash(d))
self.assertNotEqual(hash(c), hash(e))
self.assertNotEqual(hash(c), hash(a)) # vs. values()
self.assertEqual(hash(c), hash(tuple(c)))
f = values(foo=11, bar=12)
g1 = values(foo=11, bar=12)
g2 = values(bar=12, foo=11)
h = values(foo=21, bar=22, baz=99)
self.assertEqual(hash(f), hash(f))
self.assertEqual(hash(f), hash(g1))
self.assertEqual(hash(f), hash(g2))
self.assertNotEqual(hash(f), hash(h))
self.assertNotEqual(hash(f), hash(c)) # vs. values(1, 2, 3)
self.assertNotEqual(hash(f), hash(a)) # vs. values()
self.assertNotEqual(hash(f), hash(tuple(f)))
i = values(1, 2, 3, foo=4, bar=5)
j1 = values(1, 2, 3, foo=4, bar=5)
j2 = values(1, 2, 3, bar=5, foo=4)
k = values(4, 5, 6, foo=4, bar=5)
l = values(1, 2, 3, foo=9, bar=10)
m = values(4, 5, 6, foo=9, bar=10)
self.assertEqual(hash(i), hash(i))
self.assertEqual(hash(i), hash(j1))
self.assertEqual(hash(i), hash(j2))
self.assertNotEqual(hash(i), hash(k)) # diff args, same kwds
self.assertNotEqual(hash(i), hash(l)) # same args, diff kwds
self.assertNotEqual(hash(i), hash(m)) # diff args, diff kwds
self.assertNotEqual(hash(i), hash(tuple(i)))
bad_1 = values({"a": 1})
self.assertRaises(TypeError, hash, bad_1)
bad_2 = values(b={"b": 1})
self.assertRaises(TypeError, hash, bad_2)
bad_3 = values({"a": 1}, b={"b": 1})
self.assertRaises(TypeError, hash, bad_3)
data = {
values(): "wut",
values(1, 2, 3): "tacos",
values(foo=9): "foo niner",
values(2, 2, hands='blue'): "serenity",
}
setter = data.__setitem__
getter = data.__getitem__
self.assertEqual(data[values()], "wut")
self.assertEqual(data[()], "wut")
self.assertEqual(data[values(1, 2, 3)], "tacos")
self.assertEqual(data[(1, 2, 3)], "tacos")
self.assertEqual(data[values(foo=9)], "foo niner")
self.assertEqual(data[values(2, 2, hands='blue')], "serenity")
self.assertRaises(TypeError, setter, bad_1, None)
self.assertRaises(TypeError, setter, bad_2, None)
self.assertRaises(TypeError, setter, bad_3, None)
self.assertRaises(TypeError, getter, bad_1)
self.assertRaises(TypeError, getter, bad_2)
self.assertRaises(TypeError, getter, bad_3)
self.assertRaises(KeyError, getter, (1, 2, 3, 4))
self.assertRaises(KeyError, getter, values(1, 2, 3, foo=9))
self.assertRaises(KeyError, getter, values(2, 2, hands='tiny'))
self.assertRaises(KeyError, getter, values(hands='blue'))
self.assertRaises(KeyError, getter, values(1, 2, 3, 4))
self.assertRaises(KeyError, getter, values(bar=None))
def test_equality(self):
"""
tests to ensure the equality operations of a values are
functioning correctly when compared with another values
instance
"""
# permutations of values with only args
a = values(1, 2, 3)
b = values(1, 2, 3)
c = values(4, 5, 6)
self.assertEqual(a, a)
self.assertEqual(a, b)
self.assertEqual(b, a)
self.assertNotEqual(a, c)
self.assertNotEqual(b, c)
# permutations of values with only kwds
d = values(foo=9, bar=10)
e = values(foo=9, bar=10)
f = values(foo=100, quuz=200)
self.assertEqual(d, d)
self.assertEqual(d, e)
self.assertEqual(e, d)
self.assertNotEqual(d, f)
self.assertNotEqual(f, d)
self.assertNotEqual(a, d)
self.assertNotEqual(d, a)
# permutations of values with both args and kwds
g = values(1, 2, 3, foo=9, bar=10)
h = values(1, 2, 3, foo=9, bar=10)
i = values(1, 2, 3, foo=100, quuz=200)
j = values(4, 5, 6, foo=9, bar=10)
k = values(4, 5, 6, foo=100, quuz=200)
self.assertEqual(g, g) # identity
self.assertEqual(g, h) # similar
self.assertEqual(h, g) # - reversed
self.assertNotEqual(a, g) # args vs. args and kwds
self.assertNotEqual(g, a) # args and kwds vs. args
self.assertNotEqual(d, g) # kwds vs. args and kwds
self.assertNotEqual(g, d) # args and kwds vs. kwds
self.assertNotEqual(g, i) # args same, kwds differ
self.assertNotEqual(i, g) # - reversed
self.assertNotEqual(g, j) # args differ, kwds same
self.assertNotEqual(j, g) # - reversed
self.assertNotEqual(g, k) # ares and kwds differ
self.assertNotEqual(k, g) # - reversed
# the empty values, test it against the non-empty ones to make
# sure nothing breaks
z = values()
self.assertNotEqual(a, z)
self.assertNotEqual(z, a)
self.assertNotEqual(d, z)
self.assertNotEqual(z, d)
self.assertNotEqual(g, z)
self.assertNotEqual(z, g)