folder rename due to python import conflict

2 files changed, 0 insertions, 480 deletions

diff --git a/test/query/ast/__init__.py b/test/query/ast/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/test/query/ast/__init__.py
+++ /dev/null
diff --git a/test/query/ast/test_filter_.py b/test/query/ast/test_filter_.py
deleted file mode 100644
index 4f69bdc..0000000
--- a/test/query/ast/test_filter_.py
+++ /dev/null
@@ -1,480 +0,0 @@
-"""
-
-Part of the tagit test suite.
-A copy of the license is provided with the project.
-Author: Matthias Baumgartner, 2022
-"""
-# imports
-import unittest
-
-# bsfs imports
-from bsfs.namespace import ns
-from bsfs.utils import URI
-
-# objects to test
-from bsfs.query.ast.filter_ import _Expression, FilterExpression, PredicateExpression
-from bsfs.query.ast.filter_ import _Branch, Any, All
-from bsfs.query.ast.filter_ import _Agg, And, Or
-from bsfs.query.ast.filter_ import Not, Has
-from bsfs.query.ast.filter_ import _Value, Is, Equals, Substring, StartsWith, EndsWith
-from bsfs.query.ast.filter_ import _Bounded, LessThan, GreaterThan
-from bsfs.query.ast.filter_ import Predicate, OneOf
-from bsfs.query.ast.filter_ import IsIn, IsNotIn
-
-
-## code ##
-
-class TestExpression(unittest.TestCase):
-    def test_essentials(self):
-        # comparison
-        self.assertEqual(_Expression(), _Expression())
-        self.assertEqual(FilterExpression(), FilterExpression())
-        self.assertEqual(PredicateExpression(), PredicateExpression())
-        self.assertEqual(hash(_Expression()), hash(_Expression()))
-        self.assertEqual(hash(FilterExpression()), hash(FilterExpression()))
-        self.assertEqual(hash(PredicateExpression()), hash(PredicateExpression()))
-        # comparison respects type
-        self.assertNotEqual(FilterExpression(), _Expression())
-        self.assertNotEqual(_Expression(), PredicateExpression())
-        self.assertNotEqual(PredicateExpression(), FilterExpression())
-        self.assertNotEqual(hash(FilterExpression()), hash(_Expression()))
-        self.assertNotEqual(hash(_Expression()), hash(PredicateExpression()))
-        self.assertNotEqual(hash(PredicateExpression()), hash(FilterExpression()))
-        # string conversion
-        self.assertEqual(str(_Expression()), '_Expression()')
-        self.assertEqual(str(FilterExpression()), 'FilterExpression()')
-        self.assertEqual(str(PredicateExpression()), 'PredicateExpression()')
-        self.assertEqual(repr(_Expression()), '_Expression()')
-        self.assertEqual(repr(FilterExpression()), 'FilterExpression()')
-        self.assertEqual(repr(PredicateExpression()), 'PredicateExpression()')
-
-
-class TestBranch(unittest.TestCase): # _Branch, Any, All
-    def test_essentials(self):
-        pred = PredicateExpression()
-        expr = FilterExpression()
-
-        # comparison respects type
-        self.assertNotEqual(_Branch(pred, expr), Any(pred, expr))
-        self.assertNotEqual(Any(pred, expr), All(pred, expr))
-        self.assertNotEqual(All(pred, expr), _Branch(pred, expr))
-        self.assertNotEqual(hash(_Branch(pred, expr)), hash(Any(pred, expr)))
-        self.assertNotEqual(hash(Any(pred, expr)), hash(All(pred, expr)))
-        self.assertNotEqual(hash(All(pred, expr)), hash(_Branch(pred, expr)))
-
-        for cls in (_Branch, Any, All):
-            # comparison
-            self.assertEqual(cls(pred, expr), cls(pred, expr))
-            self.assertEqual(hash(cls(pred, expr)), hash(cls(pred, expr)))
-            # comparison respects predicate
-            self.assertNotEqual(cls(ns.bse.filename, expr), cls(ns.bse.filesize, expr))
-            self.assertNotEqual(hash(cls(ns.bse.filename, expr)), hash(cls(ns.bse.filesize, expr)))
-            # comparison respects expression
-            self.assertNotEqual(cls(pred, Equals('hello')), cls(pred, Equals('world')))
-            self.assertNotEqual(hash(cls(pred, Equals('hello'))), hash(cls(pred, Equals('world'))))
-
-        # string conversion
-        self.assertEqual(str(_Branch(pred, expr)), f'_Branch({pred}, {expr})')
-        self.assertEqual(repr(_Branch(pred, expr)), f'_Branch({pred}, {expr})')
-        self.assertEqual(str(Any(pred, expr)), f'Any({pred}, {expr})')
-        self.assertEqual(repr(Any(pred, expr)), f'Any({pred}, {expr})')
-        self.assertEqual(str(All(pred, expr)), f'All({pred}, {expr})')
-        self.assertEqual(repr(All(pred, expr)), f'All({pred}, {expr})')
-
-    def test_members(self):
-        class Foo(): pass
-        pred = PredicateExpression()
-        expr = FilterExpression()
-
-        for cls in (_Branch, Any, All):
-            # predicate returns member
-            self.assertEqual(cls(PredicateExpression(), expr).predicate, PredicateExpression())
-            # can pass an URI
-            self.assertEqual(cls(ns.bse.filename, expr).predicate, Predicate(ns.bse.filename))
-            # can pass a PredicateExpression
-            self.assertEqual(cls(Predicate(ns.bse.filename), expr).predicate, Predicate(ns.bse.filename))
-            # must pass an URI or PredicateExpression
-            self.assertRaises(TypeError, cls, Foo(), expr)
-            # expression returns member
-            self.assertEqual(cls(pred, Equals('hello')).expr, Equals('hello'))
-            # expression must be a FilterExpression
-            self.assertRaises(TypeError, cls, ns.bse.filename, 'hello')
-            self.assertRaises(TypeError, cls, ns.bse.filename, 1234)
-            self.assertRaises(TypeError, cls, ns.bse.filename, Foo())
-
-
-class TestAgg(unittest.TestCase): # _Agg, And, Or
-    def test_essentials(self):
-        expr = {Equals('hello'), Equals('world')}
-
-        # comparison respects type
-        self.assertNotEqual(_Agg(expr), And(expr))
-        self.assertNotEqual(And(expr), Or(expr))
-        self.assertNotEqual(Or(expr), _Agg(expr))
-        self.assertNotEqual(hash(_Agg(expr)), hash(And(expr)))
-        self.assertNotEqual(hash(And(expr)), hash(Or(expr)))
-        self.assertNotEqual(hash(Or(expr)), hash(_Agg(expr)))
-
-        for cls in (_Agg, And, Or):
-            # comparison
-            self.assertEqual(cls(expr), cls(expr))
-            self.assertEqual(hash(cls(expr)), hash(cls(expr)))
-            # comparison respects expression
-            self.assertNotEqual(cls(expr), cls(Equals('world')))
-            self.assertNotEqual(hash(cls(expr)), hash(cls(Equals('world'))))
-            self.assertNotEqual(cls(Equals('hello')), cls(Equals('world')))
-            self.assertNotEqual(hash(cls(Equals('hello'))), hash(cls(Equals('world'))))
-
-        # string conversion
-        self.assertEqual(str(_Agg(Equals('hello'))), '_Agg({Equals(hello)})')
-        self.assertEqual(repr(_Agg(Equals('hello'))), '_Agg({Equals(hello)})')
-        self.assertEqual(str(And(Equals('hello'))), 'And({Equals(hello)})')
-        self.assertEqual(repr(And(Equals('hello'))), 'And({Equals(hello)})')
-        self.assertEqual(str(Or(Equals('hello'))), 'Or({Equals(hello)})')
-        self.assertEqual(repr(Or(Equals('hello'))), 'Or({Equals(hello)})')
-
-    def test_expression(self):
-        class Foo(): pass
-
-        for cls in (_Agg, And, Or):
-            # can pass expressions as arguments
-            self.assertSetEqual(cls(Equals('hello'), Equals('world')).expr, {Equals('hello'), Equals('world')})
-            # can pass one expressions as argument
-            self.assertSetEqual(cls(Equals('hello')).expr, {Equals('hello')})
-            # can pass expressions as iterator
-            self.assertSetEqual(cls(iter((Equals('hello'), Equals('world')))).expr, {Equals('hello'), Equals('world')})
-            # can pass expressions as generator
-            def gen():
-                yield Equals('hello')
-                yield Equals('world')
-            self.assertSetEqual(cls(gen()).expr, {Equals('hello'), Equals('world')})
-            # can pass expressions as list-like
-            self.assertSetEqual(cls((Equals('hello'), Equals('world'))).expr, {Equals('hello'), Equals('world')})
-            # can pass one expression as list-like
-            self.assertSetEqual(cls([Equals('hello')]).expr, {Equals('hello')})
-            # must pass expressions
-            self.assertRaises(TypeError, cls, Foo(), Foo())
-            self.assertRaises(TypeError, cls, [Foo(), Foo()])
-
-            # iter
-            self.assertSetEqual(set(iter(cls(Equals('hello'), Equals('world')))), {Equals('hello'), Equals('world')})
-            # contains
-            self.assertIn(Equals('world'), cls(Equals('hello'), Equals('world')))
-            self.assertNotIn(Equals('foo'), cls(Equals('hello'), Equals('world')))
-            # len
-            self.assertEqual(len(cls(Equals('hello'), Equals('world'))), 2)
-            self.assertEqual(len(cls(Equals('hello'), Equals('world'), Equals('foo'))), 3)
-
-
-
-class TestNot(unittest.TestCase):
-    def test_essentials(self):
-        expr = FilterExpression()
-        # comparison
-        self.assertEqual(Not(expr), Not(expr))
-        self.assertEqual(hash(Not(expr)), hash(Not(expr)))
-        # comparison respects type
-        self.assertNotEqual(Not(expr), FilterExpression())
-        self.assertNotEqual(hash(Not(expr)), hash(FilterExpression()))
-        # comparison respects expression
-        self.assertNotEqual(Not(Equals('hello')), Not(Equals('world')))
-        self.assertNotEqual(hash(Not(Equals('hello'))), hash(Not(Equals('world'))))
-        # string conversion
-        self.assertEqual(str(Not(Equals('hello'))), 'Not(Equals(hello))')
-        self.assertEqual(repr(Not(Equals('hello'))), 'Not(Equals(hello))')
-
-    def test_expression(self):
-        # Not requires an expression argument
-        self.assertRaises(TypeError, Not)
-        # expression must be a FilterExpression
-        self.assertRaises(TypeError, Not, 'hello')
-        self.assertRaises(TypeError, Not, 1234)
-        self.assertRaises(TypeError, Not, Predicate(ns.bse.filesize))
-        # member returns expression
-        self.assertEqual(Not(Equals('hello')).expr, Equals('hello'))
-
-
-class TestHas(unittest.TestCase):
-    def test_essentials(self):
-        pred = PredicateExpression()
-        count = FilterExpression()
-        # comparison
-        self.assertEqual(Has(pred, count), Has(pred, count))
-        self.assertEqual(hash(Has(pred, count)), hash(Has(pred, count)))
-        # comparison respects type
-        self.assertNotEqual(Has(pred, count), FilterExpression())
-        self.assertNotEqual(hash(Has(pred, count)), hash(FilterExpression()))
-        # comparison respects predicate
-        self.assertNotEqual(Has(pred, count), Has(Predicate(ns.bse.filesize), count))
-        self.assertNotEqual(hash(Has(pred, count)), hash(Has(Predicate(ns.bse.filesize), count)))
-        # comparison respects count
-        self.assertNotEqual(Has(pred, count), Has(pred, LessThan(5)))
-        self.assertNotEqual(hash(Has(pred, count)), hash(Has(pred, LessThan(5))))
-        # string conversion
-        self.assertEqual(str(Has(Predicate(ns.bse.filesize), LessThan(5))),
-            f'Has(Predicate({ns.bse.filesize}, False), LessThan(5.0, True))')
-        self.assertEqual(repr(Has(Predicate(ns.bse.filesize), LessThan(5))),
-            f'Has(Predicate({ns.bse.filesize}, False), LessThan(5.0, True))')
-
-    def test_members(self):
-        pred = PredicateExpression()
-        count = FilterExpression()
-        # member returns expression
-        # predicate must be an URI or a PredicateExpression
-        self.assertEqual(Has(ns.bse.filesize, count).predicate, Predicate(ns.bse.filesize))
-        self.assertEqual(Has(Predicate(ns.bse.filesize), count).predicate, Predicate(ns.bse.filesize))
-        self.assertRaises(TypeError, Has, 1234, FilterExpression())
-        self.assertRaises(TypeError, Has, FilterExpression(), FilterExpression())
-        # member returns count
-        # count must be None, an integer, or a FilterExpression
-        self.assertEqual(Has(pred).count, GreaterThan(1, False))
-        self.assertEqual(Has(pred, LessThan(5)).count, LessThan(5))
-        self.assertEqual(Has(pred, 5).count, Equals(5))
-        self.assertRaises(TypeError, Has, pred, 'hello')
-        self.assertRaises(TypeError, Has, pred, Predicate(ns.bse.filesize))
-
-
-
-class TestValue(unittest.TestCase):
-    def test_essentials(self):
-        # comparison respects type
-        self.assertNotEqual(_Value('hello'), Equals('hello'))
-        self.assertNotEqual(Equals('hello'), Is('hello'))
-        self.assertNotEqual(Is('hello'), Substring('hello'))
-        self.assertNotEqual(Substring('hello'), StartsWith('hello'))
-        self.assertNotEqual(StartsWith('hello'), EndsWith('hello'))
-        self.assertNotEqual(EndsWith('hello'), _Value('hello'))
-        self.assertNotEqual(hash(_Value('hello')), hash(Equals('hello')))
-        self.assertNotEqual(hash(Equals('hello')), hash(Is('hello')))
-        self.assertNotEqual(hash(Is('hello')), hash(Substring('hello')))
-        self.assertNotEqual(hash(Substring('hello')), hash(StartsWith('hello')))
-        self.assertNotEqual(hash(StartsWith('hello')), hash(EndsWith('hello')))
-        self.assertNotEqual(hash(EndsWith('hello')), hash(_Value('hello')))
-
-        for cls in (_Value, Is, Equals, Substring, StartsWith, EndsWith):
-            # comparison
-            self.assertEqual(cls('hello'), cls('hello'))
-            self.assertEqual(hash(cls('hello')), hash(cls('hello')))
-            # comparison respects value
-            self.assertNotEqual(cls('hello'), cls('world'))
-            self.assertNotEqual(hash(cls('hello')), hash(cls('world')))
-
-        # string conversion
-        self.assertEqual(str(_Value('hello')), '_Value(hello)')
-        self.assertEqual(repr(_Value('hello')), '_Value(hello)')
-        self.assertEqual(str(Is('hello')), 'Is(hello)')
-        self.assertEqual(repr(Is('hello')), 'Is(hello)')
-        self.assertEqual(str(Equals('hello')), 'Equals(hello)')
-        self.assertEqual(repr(Equals('hello')), 'Equals(hello)')
-        self.assertEqual(str(Substring('hello')), 'Substring(hello)')
-        self.assertEqual(repr(Substring('hello')), 'Substring(hello)')
-        self.assertEqual(str(StartsWith('hello')), 'StartsWith(hello)')
-        self.assertEqual(repr(StartsWith('hello')), 'StartsWith(hello)')
-        self.assertEqual(str(EndsWith('hello')), 'EndsWith(hello)')
-        self.assertEqual(repr(EndsWith('hello')), 'EndsWith(hello)')
-
-    def test_value(self):
-        class Foo(): pass
-        for cls in (_Value, Is, Equals, Substring, StartsWith, EndsWith):
-            # value can be anything
-            # value returns member
-            f = Foo()
-            self.assertEqual(cls('hello').value, 'hello')
-            self.assertEqual(cls(1234).value, 1234)
-            self.assertEqual(cls(f).value, f)
-
-
-class TestBounded(unittest.TestCase):
-    def test_essentials(self):
-        # comparison respects type
-        self.assertNotEqual(_Bounded(1234), LessThan(1234))
-        self.assertNotEqual(LessThan(1234), GreaterThan(1234))
-        self.assertNotEqual(GreaterThan(1234), _Bounded(1234))
-        self.assertNotEqual(hash(_Bounded(1234)), hash(LessThan(1234)))
-        self.assertNotEqual(hash(LessThan(1234)), hash(GreaterThan(1234)))
-        self.assertNotEqual(hash(GreaterThan(1234)), hash(_Bounded(1234)))
-
-        for cls in (_Bounded, LessThan, GreaterThan):
-            # comparison
-            self.assertEqual(cls(1234), cls(1234))
-            self.assertEqual(hash(cls(1234)), hash(cls(1234)))
-            # comparison respects threshold
-            self.assertNotEqual(cls(1234), cls(4321))
-            self.assertNotEqual(hash(cls(1234)), hash(cls(4321)))
-            # comparison respects strict
-            self.assertNotEqual(cls(1234, True), cls(1234, False))
-            self.assertNotEqual(hash(cls(1234, True)), hash(cls(1234, False)))
-
-        # string conversion
-        self.assertEqual(str(_Bounded(1234, False)), '_Bounded(1234.0, False)')
-        self.assertEqual(repr(_Bounded(1234, False)), '_Bounded(1234.0, False)')
-        self.assertEqual(str(LessThan(1234, False)), 'LessThan(1234.0, False)')
-        self.assertEqual(repr(LessThan(1234, False)), 'LessThan(1234.0, False)')
-        self.assertEqual(str(GreaterThan(1234, False)), 'GreaterThan(1234.0, False)')
-        self.assertEqual(repr(GreaterThan(1234, False)), 'GreaterThan(1234.0, False)')
-
-    def test_members(self):
-        class Foo(): pass
-        for cls in (_Bounded, LessThan, GreaterThan):
-            # threshold becomes float
-            self.assertEqual(cls(1.234).threshold, 1.234)
-            self.assertEqual(cls(1234).threshold, 1234.0)
-            self.assertEqual(cls('1234').threshold, 1234)
-            self.assertRaises(TypeError, cls, Foo())
-            # strict becomes bool
-            self.assertEqual(cls(1234, True).strict, True)
-            self.assertEqual(cls(1234, False).strict, False)
-            self.assertEqual(cls(1234, Foo()).strict, True)
-
-
-class TestPredicate(unittest.TestCase):
-    def test_essentials(self):
-        # comparison
-        self.assertEqual(Predicate(ns.bse.filesize), Predicate(ns.bse.filesize))
-        self.assertEqual(hash(Predicate(ns.bse.filesize)), hash(Predicate(ns.bse.filesize)))
-        # comparison respects type
-        self.assertNotEqual(Predicate(ns.bse.filesize), PredicateExpression())
-        self.assertNotEqual(hash(Predicate(ns.bse.filesize)), hash(PredicateExpression()))
-        # comparison respects predicate
-        self.assertNotEqual(Predicate(ns.bse.filesize), Predicate(ns.bse.filename))
-        self.assertNotEqual(hash(Predicate(ns.bse.filesize)), hash(Predicate(ns.bse.filename)))
-        # comparison respects reverse
-        self.assertNotEqual(Predicate(ns.bse.filesize, True), Predicate(ns.bse.filesize, False))
-        self.assertNotEqual(hash(Predicate(ns.bse.filesize, True)), hash(Predicate(ns.bse.filesize, False)))
-        # string conversion
-        self.assertEqual(str(Predicate(ns.bse.filesize)), f'Predicate({ns.bse.filesize}, False)')
-        self.assertEqual(str(Predicate(ns.bse.filesize, True)),
-            f'Predicate({ns.bse.filesize}, True)')
-        self.assertEqual(repr(Predicate(ns.bse.filesize)), f'Predicate({ns.bse.filesize}, False)')
-        self.assertEqual(repr(Predicate(ns.bse.filesize, True)),
-            f'Predicate({ns.bse.filesize}, True)')
-
-    def test_members(self):
-        # member returns predicate
-        # predicate must be an URI
-        self.assertEqual(Predicate(ns.bse.filesize).predicate, ns.bse.filesize)
-        self.assertEqual(Predicate(URI('hello world')).predicate, URI('hello world'))
-        self.assertRaises(TypeError, Predicate, 1234)
-        self.assertRaises(TypeError, Predicate, FilterExpression())
-        self.assertRaises(TypeError, Predicate, FilterExpression())
-        # reverse becomes a boolean
-        self.assertEqual(Predicate(ns.bse.filesize, True).reverse, True)
-        self.assertEqual(Predicate(ns.bse.filesize, False).reverse, False)
-        self.assertEqual(Predicate(ns.bse.filesize, 'abc').reverse, True)
-
-
-class TestOneOf(unittest.TestCase):
-    def test_essentials(self):
-        expr = {Predicate(ns.bse.filename), Predicate(ns.bse.filesize)}
-        # comparison
-        self.assertEqual(OneOf(expr), OneOf(expr))
-        self.assertEqual(hash(OneOf(expr)), hash(OneOf(expr)))
-        # comparison respects type
-        self.assertNotEqual(OneOf(expr), PredicateExpression())
-        self.assertNotEqual(hash(OneOf(expr)), hash(PredicateExpression()))
-        # comparison respects expression
-        self.assertNotEqual(OneOf(expr), OneOf(Predicate(ns.bse.filename)))
-        self.assertNotEqual(hash(OneOf(expr)), hash(OneOf(Predicate(ns.bse.filename))))
-        # string conversion
-        self.assertEqual(str(OneOf(Predicate(ns.bse.filesize))),
-            f'OneOf({{Predicate({ns.bse.filesize}, False)}})')
-        self.assertEqual(repr(OneOf(Predicate(ns.bse.filesize))),
-            f'OneOf({{Predicate({ns.bse.filesize}, False)}})')
-
-    def test_expression(self):
-        class Foo(): pass
-        # can pass expressions as arguments
-        self.assertSetEqual(OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename)).expr,
-            {Predicate(ns.bse.filesize), Predicate(ns.bse.filename)})
-        # can pass one expressions as argument
-        self.assertSetEqual(OneOf(Predicate(ns.bse.filesize)).expr,
-            {Predicate(ns.bse.filesize)})
-        # can pass expressions as iterator
-        self.assertSetEqual(OneOf(iter((Predicate(ns.bse.filesize), Predicate(ns.bse.filename)))).expr,
-            {Predicate(ns.bse.filesize), Predicate(ns.bse.filename)})
-        # can pass expressions as generator
-        def gen():
-            yield Predicate(ns.bse.filesize)
-            yield Predicate(ns.bse.filename)
-        self.assertSetEqual(OneOf(gen()).expr,
-            {Predicate(ns.bse.filesize), Predicate(ns.bse.filename)})
-        # can pass expressions as list-like
-        self.assertSetEqual(OneOf((Predicate(ns.bse.filesize), Predicate(ns.bse.filename))).expr,
-            {Predicate(ns.bse.filesize), Predicate(ns.bse.filename)})
-        # can pass one expression as list-like
-        self.assertSetEqual(OneOf([Predicate(ns.bse.filesize)]).expr,
-            {Predicate(ns.bse.filesize)})
-        # must pass expressions
-        self.assertRaises(TypeError, OneOf, Foo(), Foo())
-        self.assertRaises(TypeError, OneOf, [Foo(), Foo()])
-        # must pass at least one expression
-        self.assertRaises(AttributeError, OneOf)
-
-        # iter
-        self.assertSetEqual(set(iter(OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename)))),
-            {Predicate(ns.bse.filesize), Predicate(ns.bse.filename)})
-        # contains
-        self.assertIn(Predicate(ns.bse.filesize),
-            OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename)))
-        self.assertNotIn(Predicate(ns.bse.tag),
-            OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename)))
-        # len
-        self.assertEqual(len(OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename))), 2)
-        self.assertEqual(len(OneOf(Predicate(ns.bse.filesize), Predicate(ns.bse.filename), Predicate(ns.bse.tag))), 3)
-
-
-    def testIsIn(self):
-        # can pass expressions as arguments
-        self.assertEqual(IsIn('http://example.com/entity#1234', 'http://example.com/entity#4321'),
-            Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321')))
-        # can pass one expression as argument
-        self.assertEqual(IsIn('http://example.com/entity#1234'),
-            Or(Is('http://example.com/entity#1234')))
-        # can pass expressions as iterator
-        self.assertEqual(IsIn(iter(('http://example.com/entity#1234', 'http://example.com/entity#4321'))),
-            Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321')))
-        # can pass expressions as generator
-        def gen():
-            yield 'http://example.com/entity#1234'
-            yield 'http://example.com/entity#4321'
-        self.assertEqual(IsIn(gen()),
-            Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321')))
-        # can pass expressions as list-like
-        self.assertEqual(IsIn(['http://example.com/entity#1234', 'http://example.com/entity#4321']),
-            Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321')))
-        # can pass one expression as list-like
-        self.assertEqual(IsIn(['http://example.com/entity#1234']),
-            Or(Is('http://example.com/entity#1234')))
-
-
-    def testIsNotIn(self):
-        # can pass expressions as arguments
-        self.assertEqual(IsNotIn('http://example.com/entity#1234', 'http://example.com/entity#4321'),
-            Not(Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321'))))
-        # can pass one expression as argument
-        self.assertEqual(IsNotIn('http://example.com/entity#1234'),
-            Not(Or(Is('http://example.com/entity#1234'))))
-        # can pass expressions as iterator
-        self.assertEqual(IsNotIn(iter(('http://example.com/entity#1234', 'http://example.com/entity#4321'))),
-            Not(Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321'))))
-        # can pass expressions as generator
-        def gen():
-            yield 'http://example.com/entity#1234'
-            yield 'http://example.com/entity#4321'
-        self.assertEqual(IsNotIn(gen()),
-            Not(Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321'))))
-        # can pass expressions as list-like
-        self.assertEqual(IsNotIn(['http://example.com/entity#1234', 'http://example.com/entity#4321']),
-            Not(Or(Is('http://example.com/entity#1234'), Is('http://example.com/entity#4321'))))
-        # can pass one expression as list-like
-        self.assertEqual(IsNotIn(['http://example.com/entity#1234']),
-            Not(Or(Is('http://example.com/entity#1234'))))
-
-
-
-## main ##
-
-if __name__ == '__main__':
-    unittest.main()
-
-## EOF ##