def testUnion1(self):
        si1 = SpanningInterval(CL, Interval(CL, 1.0, 3.0, CL),
                               Interval(OP, 1.0, PINF, OP), CL)
        si2 = SpanningInterval(CL, Interval(CL, 1.0, 3.0, OP),
                               Interval(CL, 1.0, 3.0, OP), CL)
        self.containment(si1, si2, isProperSubset=False, isSuperset=False)

        self.assertEqual(si1.containsInterval(Interval(CL, 1, 1, CL)), False)

        self.assertEqual(si2.containsInterval(Interval(CL, 1, 1, CL)), True)

        csi1 = si1.complement()

        interval = csi1.intersectInterval(si2)

        self.assertEqual(
            SpanningInterval.union(si1, si2),
            SpanningIntervalSet([
                SpanningInterval(CL, Interval(CL, 1.0, 3.0, CL),
                                 Interval(CL, 1.0, PINF, OP), CL)
            ]))

        self.assertEqual(
            SpanningInterval.union(
                SpanningInterval(OP, Interval(OP, NINF, 3.0, OP),
                                 Interval(OP, 1.0, PINF, OP), CL),
                SpanningInterval(OP, Interval(OP, NINF, 3.0, OP),
                                 Interval(CL, 1.0, 3.0, CL), CL)),
            SpanningIntervalSet([
                SpanningInterval(OP, Interval(OP, NINF, 3.0, OP),
                                 Interval(CL, 1.0, PINF, OP), CL)
            ]))
    def testSomething(self):
        si1 = SpanningInterval(CL, Interval(OP, NINF, 1.0, OP),
                               Interval(CL, 1.0, 1.0, CL), OP)
        si2 = SpanningInterval(OP, Interval(OP, NINF, 1.0, OP),
                               Interval(CL, 1.0, 1.0, CL), OP)

        self.assertEquals(si1.containsInterval(Interval(CL, 0, 1, OP)), True)
        self.assertNotEqual(si1, emptySpanningInterval)
        self.assertNotEqual(si1.normalized(), emptySpanningInterval)
        print "si1", si1.normalized()

        sis = SpanningIntervalSet([si1, si2])
    def testContainsInterval(self):

        si = SpanningInterval(CL, Interval(CL, 0, 1, CL),
                              Interval(CL, 2, 3, CL), CL)

        self.assertEqual(si.containsInterval(Interval(CL, 0.5, 2.5, CL)), True)