|
- from nilmdb import Interval, IntervalSet, IntervalError
- from datetime import datetime
- from nose.tools import assert_raises
- import itertools
-
- def test_interval():
- """Test the Interval class"""
- d1 = datetime.strptime("19801205","%Y%m%d")
- d2 = datetime.strptime("19900216","%Y%m%d")
- d3 = datetime.strptime("20111205","%Y%m%d")
-
- # basic construction
- i = Interval(d1, d1)
- i = Interval(d1, d3)
- assert(i.start == d1)
- assert(i.end == d3)
-
- # assignment should work
- i.start = d2
- try:
- i.end = d1
- raise Exception("should have died there")
- except IntervalError:
- pass
- i.start = d1
- i.end = d2
-
- # end before start
- assert_raises(IntervalError, Interval, d3, d1)
-
- # wrong type
- assert_raises(IntervalError, Interval, 1, 2)
-
- # compare
- assert(Interval(d1, d2) == Interval(d1, d2))
- assert(Interval(d1, d2) < Interval(d1, d3))
- assert(Interval(d1, d3) > Interval(d1, d2))
- assert(Interval(d1, d2) < Interval(d2, d3))
- assert(Interval(d1, d3) < Interval(d2, d3))
- assert(Interval(d2, d2) > Interval(d1, d3))
- assert(Interval(d3, d3) == Interval(d3, d3))
- assert_raises(TypeError, cmp, i, 123)
-
- # subset
- assert(Interval(d1, d3).subset(d1, d2) == Interval(d1, d2))
- assert_raises(IntervalError, Interval(d2, d3).subset, d1, d2)
-
- # append
- assert(Interval(d1, d2).is_adjacent(Interval(d2,d3)))
- assert(Interval(d2, d3).is_adjacent(Interval(d1,d2)))
- assert(not Interval(d2, d3).is_adjacent(Interval(d1,d3)))
- assert_raises(TypeError, Interval(d1, d2).is_adjacent, 1)
-
- # misc
- assert(repr(i) == repr(eval(repr(i).replace("datetime.",""))))
- assert(str(i) == "[1980-12-05 00:00:00 -> 1990-02-16 00:00:00]")
-
- def test_interval_intersect():
- """Test Interval intersections"""
- dates = [ datetime.strptime(year, "%y") for year in [ "00", "01", "02", "03" ] ]
- perm = list(itertools.permutations(dates, 2))
- prod = list(itertools.product(perm, perm))
- should_intersect = {
- False: [4, 5, 8, 20, 48, 56, 60, 96, 97, 100],
- True: [0, 1, 2, 12, 13, 14, 16, 17, 24, 25, 26, 28, 29,
- 32, 49, 50, 52, 53, 61, 62, 64, 65, 68, 98, 101, 104]}
- for i,((a,b),(c,d)) in enumerate(prod):
- try:
- i1 = Interval(a, b)
- i2 = Interval(c, d)
- assert(i1.intersects(i2) == i2.intersects(i1))
- assert(i in should_intersect[i1.intersects(i2)])
- except IntervalError:
- assert(i not in should_intersect[True] and
- i not in should_intersect[False])
- assert_raises(TypeError, i1.intersects, 1234)
-
- def test_intervalset_construct():
- """Test interval set construction"""
- dates = [ datetime.strptime(year, "%y") for year in [ "00", "01", "02", "03" ]]
-
- a = Interval(dates[0], dates[1])
- b = Interval(dates[1], dates[2])
- c = Interval(dates[0], dates[2])
- d = Interval(dates[2], dates[3])
-
- iseta = IntervalSet(a)
- isetb = IntervalSet([a, b])
- isetc = IntervalSet([a])
- assert(iseta != isetb)
- assert(iseta == isetc)
- assert(iseta != 3)
- assert(IntervalSet(a) != IntervalSet(b))
-
- print iseta == None
- assert_raises(TypeError, cmp, iseta, isetb)
- assert_raises(IntervalError, IntervalSet, [a, b, c])
- assert_raises(TypeError, IntervalSet, [1, 2])
-
- iset = IntervalSet(isetb) # test iterator
- assert(iset == isetb)
- assert(len(iset) == 2)
- assert(len(IntervalSet()) == 0)
-
- # Test adding
- iset = IntervalSet(a)
- iset += IntervalSet(b)
- assert(iset == IntervalSet([a, b]))
- iset = IntervalSet(a)
- iset += b
- assert(iset == IntervalSet([a, b]))
- iset = IntervalSet(a) + IntervalSet(b)
- assert(iset == IntervalSet([a, b]))
- iset = IntervalSet(b) + a
- assert(iset == IntervalSet([a, b]))
-
- # A set consisting of [0-1],[1-2] should match a set consisting of [0-2]
- assert(IntervalSet([a,b]) == IntervalSet([c]))
- # Etc
- assert(IntervalSet([a,d]) != IntervalSet([c]))
- assert(IntervalSet([c]) != IntervalSet([a,d]))
- assert(IntervalSet([c,d]) != IntervalSet([b,d]))
-
- # misc
- assert(repr(iset) == repr(eval(repr(iset).replace("datetime.",""))))
-
- def iset(string):
- """Build an IntervalSet from a string, for testing purposes
-
- Each character is a year
- [ = interval start
- | = interval end + adjacent start
- ] = interval end
- anything else is ignored
- """
- iset = IntervalSet()
- for i, c in enumerate(string):
- day = datetime.strptime("{0:04d}".format(i+2000), "%Y")
- if (c == "["):
- start = day
- elif (c == "|"):
- iset += Interval(start, day)
- start = day
- elif (c == "]"):
- iset += Interval(start, day)
- del start
- return iset
-
- def test_intervalset_iset():
- """Test basic iset construction"""
- assert(iset(" [----] ") ==
- iset(" [-|--] "))
-
- assert(iset("[] [--] ") +
- iset(" [] [--]") ==
- iset("[|] [-----]"))
-
- def test_intervalset_intsersect():
- """Test intersection (&)"""
- assert_raises(TypeError, iset("[--]").__and__, 1234)
-
- assert(iset("[---------]") &
- iset(" [---] ") ==
- iset(" [---] "))
-
- assert(iset(" [---] ") &
- iset("[---------]") ==
- iset(" [---] "))
-
- assert(iset(" [-----]") &
- iset(" [-----] ") ==
- iset(" [--] "))
-
- assert(iset(" [---]") &
- iset(" [--] ") ==
- iset(" "))
-
- assert(iset(" [-|---]") &
- iset(" [-----|-] ") ==
- iset(" [----] "))
-
- assert(iset(" [-|-] ") &
- iset(" [-|--|--] ") ==
- iset(" [---] "))
-
- assert(iset(" [----][--]") &
- iset("[-] [--] []") ==
- iset(" [] [-] []"))
|