def test_get_bricks_from_slice_1d(self):
        total_domain = (15, )
        brick_extents = (((0, 4), ), ((5, 9), ), ((10, 14), ))
        rtree_extents = ((0, 0, 4, 0), (5, 0, 9, 0), (10, 0, 14, 0))

        brick_0 = (0, ((0, 4), ))
        brick_1 = (1, ((5, 9), ))
        brick_2 = (2, ((10, 14), ))

        from coverage_model.test.bricking_assessment_utility import BrickingAssessor
        rtree = RTreeProxy()
        for x in BrickingAssessor.rtree_populator(rtree_extents,
                                                  brick_extents):
            rtree.insert(*x)

        # Try a variety of slices
        self._get_bricks_assert(slice(None), rtree, total_domain, 3,
                                [brick_0, brick_1, brick_2])

        self._get_bricks_assert(slice(None, None, 3), rtree, total_domain, 3,
                                [brick_0, brick_1, brick_2])

        self._get_bricks_assert(slice(0, 3), rtree, total_domain, 1, [brick_0])

        self._get_bricks_assert(slice(5, 9), rtree, total_domain, 1, [brick_1])

        self._get_bricks_assert(slice(6, None), rtree, total_domain, 2,
                                [brick_1, brick_2])

        self._get_bricks_assert(
            slice(None, None, 10), rtree, total_domain, 3,
            [brick_0, brick_1, brick_2
             ])  # three bricks, tho the middle one isn't needed

        self._get_bricks_assert(([1, 3], ), rtree, total_domain, 1, [brick_0])

        self._get_bricks_assert(([2, 4, 7], ), rtree, total_domain, 2,
                                [brick_0, brick_1])

        self._get_bricks_assert(
            ([3, 12], ), rtree, total_domain, 3,
            [brick_0, brick_1, brick_2
             ])  # three bricks, tho the middle one isn't needed

        self._get_bricks_assert(1, rtree, total_domain, 1, [brick_0])

        self._get_bricks_assert(6, rtree, total_domain, 1, [brick_1])

        self._get_bricks_assert(13, rtree, total_domain, 1, [brick_2])
    def test_get_bricks_from_slice_3d(self):
        total_domain = (10, 15, 5)
        brick_extents = (((0, 4), (0, 4), (0, 4)), ((0, 4), (5, 9), (0, 4)),
                         ((0, 4), (10, 14), (0, 4)), ((5, 9), (0, 4), (0, 4)),
                         ((5, 9), (5, 9), (0, 4)), ((5, 9), (10, 14), (0, 4)))
        rtree_extents = ((0, 0, 0, 4, 4, 4), (0, 5, 0, 4, 9, 4),
                         (0, 10, 0, 4, 14, 4), (5, 0, 0, 9, 4, 4),
                         (5, 5, 0, 9, 9, 4), (5, 10, 0, 9, 14, 4))

        brick_0 = (0, ((0, 4), (0, 4), (0, 4)))
        brick_1 = (1, ((0, 4), (5, 9), (0, 4)))
        brick_2 = (2, ((0, 4), (10, 14), (0, 4)))
        brick_3 = (3, ((5, 9), (0, 4), (0, 4)))
        brick_4 = (4, ((5, 9), (5, 9), (0, 4)))
        brick_5 = (5, ((5, 9), (10, 14), (0, 4)))

        from coverage_model.test.bricking_assessment_utility import BrickingAssessor
        rtree = RTreeProxy()
        for x in BrickingAssessor.rtree_populator(rtree_extents,
                                                  brick_extents):
            rtree.insert(*x)

        # Get all bricks
        self._get_bricks_assert(
            (slice(None), ) * 3, rtree, total_domain, 6,
            [brick_0, brick_1, brick_2, brick_3, brick_4, brick_5])

        self._get_bricks_assert((0, 0, 0), rtree, total_domain, 1, [brick_0])

        self._get_bricks_assert((8, 5, 2), rtree, total_domain, 1, [brick_4])

        self._get_bricks_assert((4, 12, 1), rtree, total_domain, 1, [brick_2])

        self._get_bricks_assert((9, 13, [0, 2]), rtree, total_domain, 1,
                                [brick_5])

        self._get_bricks_assert((8, [3, 5, 12], 0), rtree, total_domain, 3,
                                [brick_3, brick_4, brick_5])

        self._get_bricks_assert(([5, 9], 10, 0), rtree, total_domain, 1,
                                [brick_5])

        self._get_bricks_assert(([5, 9], [4, 12, 13], 0), rtree, total_domain,
                                3, [brick_3, brick_4, brick_5])

        self._get_bricks_assert(([2, 4], [2, 11], [1, 3, 4]), rtree,
                                total_domain, 3, [brick_0, brick_1, brick_2])

        self._get_bricks_assert(([2, 3, 9], 12, [1, 3, 4]), rtree,
                                total_domain, 2, [brick_2, brick_5])

        self._get_bricks_assert((slice(None), 12, [1, 3, 4]), rtree,
                                total_domain, 2, [brick_2, brick_5])

        self._get_bricks_assert((slice(1, 7), 3, [1, 3, 4]), rtree,
                                total_domain, 2, [brick_0, brick_3])

        self._get_bricks_assert((slice(3, 4), 7, [1, 3, 4]), rtree,
                                total_domain, 1, [brick_1])

        self._get_bricks_assert(
            (slice(2, 8, 7), [1, 6, 12], 4), rtree, total_domain, 6,
            [brick_0, brick_1, brick_2, brick_3, brick_4, brick_5])

        self._get_bricks_assert((slice(2, 4, 7), slice(None), 2), rtree,
                                total_domain, 3, [brick_0, brick_1, brick_2])

        self._get_bricks_assert(
            (slice(None, 4), slice(9, None, 2), slice(None)), rtree,
            total_domain, 2, [brick_1, brick_2])

        self._get_bricks_assert(
            (slice(None, 6, 4), slice(12, None, 2), slice(3, None)), rtree,
            total_domain, 2, [brick_2, brick_5])

        self._get_bricks_assert(
            (slice(None, 8), slice(6, 13, 4), slice(None, None, 3)), rtree,
            total_domain, 4, [brick_1, brick_2, brick_4, brick_5])
    def test_get_bricks_from_slice_2d(self):
        total_domain = (15, 10)
        brick_extents = (((0, 4), (0, 4)), ((0, 4), (5, 9)), ((5, 9), (0, 4)),
                         ((5, 9), (5, 9)), ((10, 14), (0, 4)), ((10, 14), (5,
                                                                           9)))
        rtree_extents = ((0, 0, 4, 4), (0, 5, 4, 9), (5, 0, 9, 4),
                         (5, 5, 9, 9), (10, 0, 14, 4), (10, 5, 14, 9))

        brick_0 = (0, ((0, 4), (0, 4)))
        brick_1 = (1, ((0, 4), (5, 9)))
        brick_2 = (2, ((5, 9), (0, 4)))
        brick_3 = (3, ((5, 9), (5, 9)))
        brick_4 = (4, ((10, 14), (0, 4)))
        brick_5 = (5, ((10, 14), (5, 9)))

        from coverage_model.test.bricking_assessment_utility import BrickingAssessor
        rtree = RTreeProxy()
        for x in BrickingAssessor.rtree_populator(rtree_extents,
                                                  brick_extents):
            rtree.insert(*x)

        # Get all bricks
        self._get_bricks_assert(
            (slice(None), ) * 2, rtree, total_domain, 6,
            [brick_0, brick_1, brick_2, brick_3, brick_4, brick_5])

        self._get_bricks_assert(
            (slice(None), slice(None, 8)), rtree, total_domain, 6,
            [brick_0, brick_1, brick_2, brick_3, brick_4, brick_5])

        self._get_bricks_assert((slice(None), slice(None, 4)), rtree,
                                total_domain, 3, [brick_0, brick_2, brick_4])

        self._get_bricks_assert((slice(7, 12), slice(5, 8)), rtree,
                                total_domain, 2, [brick_3, brick_5])

        self._get_bricks_assert(
            (slice(2, 14, 3), slice(2, 7)), rtree, total_domain, 6,
            [brick_0, brick_1, brick_2, brick_3, brick_4, brick_5])

        self._get_bricks_assert(
            (slice(2, 14, 10), slice(2, 7)), rtree, total_domain, 6,
            [brick_0, brick_1, brick_2, brick_3, brick_4, brick_5])

        self._get_bricks_assert((0, slice(2, 8, 3)), rtree, total_domain, 2,
                                [brick_0, brick_1])

        self._get_bricks_assert((6, slice(2, 7)), rtree, total_domain, 2,
                                [brick_2, brick_3])

        self._get_bricks_assert((slice(None, 12), 7), rtree, total_domain, 3,
                                [brick_1, brick_3, brick_5])

        self._get_bricks_assert((12, slice(2, None, 4)), rtree, total_domain,
                                2, [brick_4, brick_5])

        self._get_bricks_assert(([1, 2], 9), rtree, total_domain, 1, [brick_1])

        self._get_bricks_assert(([0, 14], 3), rtree, total_domain, 3,
                                [brick_0, brick_2, brick_4])

        self._get_bricks_assert((3, [1, 8]), rtree, total_domain, 2,
                                [brick_0, brick_1])

        self._get_bricks_assert(([2, 5], [1, 8]), rtree, total_domain, 4,
                                [brick_0, brick_1, brick_2, brick_3])

        self._get_bricks_assert(([6, 9], [1, 8]), rtree, total_domain, 2,
                                [brick_2, brick_3])

        self._get_bricks_assert(([2, 8, 13], [7, 8]), rtree, total_domain, 3,
                                [brick_1, brick_3, brick_5])