Beispiel #1
0
    def test_position_at_fration(self):
        ranges = [(0, 4), (4, 16), (16, 24), (24, 32)]
        source = ConcatSource([
            iobase.SourceBundle((range[1] - range[0]) / 32.,
                                RangeSource(*range), None, None)
            for range in ranges
        ])

        range_tracker = source.get_range_tracker()
        self.assertEqual(range_tracker.position_at_fraction(0), (0, 0))
        self.assertEqual(range_tracker.position_at_fraction(.01), (0, 1))
        self.assertEqual(range_tracker.position_at_fraction(.1), (0, 4))
        self.assertEqual(range_tracker.position_at_fraction(.125), (1, 4))
        self.assertEqual(range_tracker.position_at_fraction(.2), (1, 7))
        self.assertEqual(range_tracker.position_at_fraction(.7), (2, 23))
        self.assertEqual(range_tracker.position_at_fraction(.75), (3, 24))
        self.assertEqual(range_tracker.position_at_fraction(.8), (3, 26))
        self.assertEqual(range_tracker.position_at_fraction(1), (4, None))

        range_tracker = source.get_range_tracker((1, None), (3, None))
        self.assertEqual(range_tracker.position_at_fraction(0), (1, 4))
        self.assertEqual(range_tracker.position_at_fraction(.01), (1, 5))
        self.assertEqual(range_tracker.position_at_fraction(.5), (1, 14))
        self.assertEqual(range_tracker.position_at_fraction(.599), (1, 16))
        self.assertEqual(range_tracker.position_at_fraction(.601), (2, 17))
        self.assertEqual(range_tracker.position_at_fraction(1), (3, None))
  def test_position_at_fration(self):
    ranges = [(0, 4), (4, 16), (16, 24), (24, 32)]
    source = ConcatSource([iobase.SourceBundle((range[1] - range[0]) / 32.,
                                               RangeSource(*range),
                                               None, None)
                           for range in ranges])

    range_tracker = source.get_range_tracker()
    self.assertEquals(range_tracker.position_at_fraction(0), (0, 0))
    self.assertEquals(range_tracker.position_at_fraction(.01), (0, 1))
    self.assertEquals(range_tracker.position_at_fraction(.1), (0, 4))
    self.assertEquals(range_tracker.position_at_fraction(.125), (1, 4))
    self.assertEquals(range_tracker.position_at_fraction(.2), (1, 7))
    self.assertEquals(range_tracker.position_at_fraction(.7), (2, 23))
    self.assertEquals(range_tracker.position_at_fraction(.75), (3, 24))
    self.assertEquals(range_tracker.position_at_fraction(.8), (3, 26))
    self.assertEquals(range_tracker.position_at_fraction(1), (4, None))

    range_tracker = source.get_range_tracker((1, None), (3, None))
    self.assertEquals(range_tracker.position_at_fraction(0), (1, 4))
    self.assertEquals(range_tracker.position_at_fraction(.01), (1, 5))
    self.assertEquals(range_tracker.position_at_fraction(.5), (1, 14))
    self.assertEquals(range_tracker.position_at_fraction(.599), (1, 16))
    self.assertEquals(range_tracker.position_at_fraction(.601), (2, 17))
    self.assertEquals(range_tracker.position_at_fraction(1), (3, None))
Beispiel #3
0
 def test_read(self):
   sources = [TestConcatSource.DummySource(range(start, start + 10)) for start
              in [0, 10, 20]]
   concat = ConcatSource(sources)
   range_tracker = concat.get_range_tracker(None, None)
   read_data = [value for value in concat.read(range_tracker)]
   self.assertCountEqual(list(range(30)), read_data)
Beispiel #4
0
 def test_read(self):
   sources = [TestConcatSource.DummySource(range(start, start + 10)) for start
              in [0, 10, 20]]
   concat = ConcatSource(sources)
   range_tracker = concat.get_range_tracker(None, None)
   read_data = [value for value in concat.read(range_tracker)]
   self.assertItemsEqual(range(30), read_data)
Beispiel #5
0
 def test_fraction_consumed_at_end(self):
     source = ConcatSource([
         RangeSource(0, 2),
         RangeSource(2, 4),
     ])
     range_tracker = source.get_range_tracker((2, None), None)
     self.assertEqual(range_tracker.fraction_consumed(), 1.0)
Beispiel #6
0
    def test_conact_source(self):
        source = ConcatSource([
            RangeSource(0, 4),
            RangeSource(4, 8),
            RangeSource(8, 12),
            RangeSource(12, 16),
        ])
        self.assertEqual(list(source.read(source.get_range_tracker())),
                         list(range(16)))
        self.assertEqual(
            list(source.read(source.get_range_tracker((1, None), (2, 10)))),
            list(range(4, 10)))
        range_tracker = source.get_range_tracker(None, None)
        self.assertEqual(range_tracker.position_at_fraction(0), (0, 0))
        self.assertEqual(range_tracker.position_at_fraction(.5), (2, 8))
        self.assertEqual(range_tracker.position_at_fraction(.625), (2, 10))

        # Simulate a read.
        self.assertEqual(range_tracker.try_claim((0, None)), True)
        self.assertEqual(range_tracker.sub_range_tracker(0).try_claim(2), True)
        self.assertEqual(range_tracker.fraction_consumed(), 0.125)

        self.assertEqual(range_tracker.try_claim((1, None)), True)
        self.assertEqual(range_tracker.sub_range_tracker(1).try_claim(6), True)
        self.assertEqual(range_tracker.fraction_consumed(), 0.375)
        self.assertEqual(range_tracker.try_split((0, 1)), None)
        self.assertEqual(range_tracker.try_split((1, 5)), None)

        self.assertEqual(range_tracker.try_split((3, 14)), ((3, None), 0.75))
        self.assertEqual(range_tracker.try_claim((3, None)), False)
        self.assertEqual(range_tracker.sub_range_tracker(1).try_claim(7), True)
        self.assertEqual(range_tracker.try_claim((2, None)), True)
        self.assertEqual(range_tracker.sub_range_tracker(2).try_claim(9), True)

        self.assertEqual(range_tracker.try_split((2, 8)), None)
        self.assertEqual(range_tracker.try_split((2, 11)), ((2, 11), 11. / 12))
        self.assertEqual(
            range_tracker.sub_range_tracker(2).try_claim(10), True)
        self.assertEqual(
            range_tracker.sub_range_tracker(2).try_claim(11), False)
  def test_conact_source(self):
    source = ConcatSource([RangeSource(0, 4),
                           RangeSource(4, 8),
                           RangeSource(8, 12),
                           RangeSource(12, 16),
                          ])
    self.assertEqual(list(source.read(source.get_range_tracker())),
                     range(16))
    self.assertEqual(list(source.read(source.get_range_tracker((1, None),
                                                               (2, 10)))),
                     range(4, 10))
    range_tracker = source.get_range_tracker(None, None)
    self.assertEqual(range_tracker.position_at_fraction(0), (0, 0))
    self.assertEqual(range_tracker.position_at_fraction(.5), (2, 8))
    self.assertEqual(range_tracker.position_at_fraction(.625), (2, 10))

    # Simulate a read.
    self.assertEqual(range_tracker.try_claim((0, None)), True)
    self.assertEqual(range_tracker.sub_range_tracker(0).try_claim(2), True)
    self.assertEqual(range_tracker.fraction_consumed(), 0.125)

    self.assertEqual(range_tracker.try_claim((1, None)), True)
    self.assertEqual(range_tracker.sub_range_tracker(1).try_claim(6), True)
    self.assertEqual(range_tracker.fraction_consumed(), 0.375)
    self.assertEqual(range_tracker.try_split((0, 1)), None)
    self.assertEqual(range_tracker.try_split((1, 5)), None)

    self.assertEqual(range_tracker.try_split((3, 14)), ((3, None), 0.75))
    self.assertEqual(range_tracker.try_claim((3, None)), False)
    self.assertEqual(range_tracker.sub_range_tracker(1).try_claim(7), True)
    self.assertEqual(range_tracker.try_claim((2, None)), True)
    self.assertEqual(range_tracker.sub_range_tracker(2).try_claim(9), True)

    self.assertEqual(range_tracker.try_split((2, 8)), None)
    self.assertEqual(range_tracker.try_split((2, 11)), ((2, 11), 11. / 12))
    self.assertEqual(range_tracker.sub_range_tracker(2).try_claim(10), True)
    self.assertEqual(range_tracker.sub_range_tracker(2).try_claim(11), False)