예제 #1
0
 def test_simple(self):
     print(self.segment.byte_bounds_offset(), len(self.segment))
     r2 = self.segment.rawdata[100:400]
     s2 = DefaultSegment(r2)
     print(s2.byte_bounds_offset(), len(s2), s2.__getstate__())
     r3 = s2.rawdata[100:200]
     s3 = DefaultSegment(r3)
     print(s3.byte_bounds_offset(), len(s3), s3.__getstate__())
     order = list(reversed(list(range(700, 800))))
     r4 = self.segment.rawdata.get_indexed(order)
     s4 = DefaultSegment(r4)
     print(s4.byte_bounds_offset(), len(s4), s4.__getstate__())
     
     slist = [s2, s3, s4]
     for s in slist:
         print(s)
     j = jsonpickle.dumps(slist)
     print(j)
     
     slist2 = jsonpickle.loads(j)
     print(slist2)
     for s in slist2:
         s.reconstruct_raw(self.segment.rawdata)
         print(s)
     
     for orig, rebuilt in zip(slist, slist2):
         print("orig", orig.data[:])
         print("rebuilt", rebuilt.data[:])
         assert np.array_equal(orig[:], rebuilt[:])
예제 #2
0
    def test_simple(self):
        print(self.segment.byte_bounds_offset(), len(self.segment))
        r2 = self.segment.rawdata[100:400]
        s2 = DefaultSegment(r2)
        print(s2.byte_bounds_offset(), len(s2), s2.__getstate__())
        r3 = s2.rawdata[100:200]
        s3 = DefaultSegment(r3)
        print(s3.byte_bounds_offset(), len(s3), s3.__getstate__())
        order = list(reversed(list(range(700, 800))))
        r4 = self.segment.rawdata.get_indexed(order)
        s4 = DefaultSegment(r4)
        print(s4.byte_bounds_offset(), len(s4), s4.__getstate__())

        slist = [s2, s3, s4]
        for s in slist:
            print(s)
        j = jsonpickle.dumps(slist)
        print(j)

        slist2 = jsonpickle.loads(j)
        print(slist2)
        for s in slist2:
            s.reconstruct_raw(self.segment.rawdata)
            print(s)

        for orig, rebuilt in zip(slist, slist2):
            print("orig", orig.data[:])
            print("rebuilt", rebuilt.data[:])
            assert np.array_equal(orig[:], rebuilt[:])
예제 #3
0
class TestJsonPickle(object):
    def setup(self):
        data = np.arange(2048, dtype=np.uint8)
        self.segment = DefaultSegment(SegmentData(data))

    def test_simple(self):
        print self.segment.byte_bounds_offset(), len(self.segment)
        r2 = self.segment.rawdata[100:400]
        s2 = DefaultSegment(r2)
        print s2.byte_bounds_offset(), len(s2), s2.__getstate__()
        r3 = s2.rawdata[100:200]
        s3 = DefaultSegment(r3)
        print s3.byte_bounds_offset(), len(s3), s3.__getstate__()
        order = list(reversed(range(700, 800)))
        r4 = self.segment.rawdata.get_indexed(order)
        s4 = DefaultSegment(r4)
        print s4.byte_bounds_offset(), len(s4), s4.__getstate__()
        
        slist = [s2, s3, s4]
        for s in slist:
            print s
        j = jsonpickle.dumps(slist)
        print j
        
        slist2 = jsonpickle.loads(j)
        print slist2
        for s in slist2:
            s.reconstruct_raw(self.segment.rawdata)
            print s
        
        for orig, rebuilt in zip(slist, slist2):
            print "orig", orig.data[:]
            print "rebuilt", rebuilt.data[:]
            assert np.array_equal(orig[:], rebuilt[:])
예제 #4
0
    def test_indexed_sub(self):
        base = self.segment
        assert not base.rawdata.is_indexed
        raw = base.rawdata[512:1536]  # 1024 byte segment
        sub = DefaultSegment(raw, 512)

        assert not sub.rawdata.is_indexed
        for i in range(len(sub)):
            ri = sub.get_raw_index(i)
            assert ri == sub.origin + i
            assert sub[i] == base[ri]
        start, end = sub.byte_bounds_offset()
        assert start == 512
        assert end == 1536

        with pytest.raises(IndexError) as e:
            # attempt to get indexes to 1024 * 3... Index to big => fail!
            s, indexes = get_indexed(sub, 1024, 3)

        # try with elements up to 256 * 3
        s, indexes = get_indexed(sub, 256, 3)
        print(sub.data)
        print(indexes)
        print(s.data[:])
        assert s.rawdata.is_indexed
        for i in range(len(indexes)):
            ri = s.get_raw_index(i)
            print(ri, "base[ri]=%d" % base[ri], i, indexes[i],
                  "s[i]=%d" % s[i])
            assert ri == sub.origin + indexes[i]
            assert s[i] == base[ri]
        start, end = s.byte_bounds_offset()
        assert start == 0
        assert end == len(base)

        # get indexed into indexed, will result in every 9th byte
        s2, indexes2 = get_indexed(s, 64, 3)
        assert s2.rawdata.is_indexed
        for i in range(len(indexes2)):
            assert s2.get_raw_index(i) == sub.origin + indexes2[i] * 3
        start, end = s.byte_bounds_offset()
        assert start == 0
        assert end == len(base)
예제 #5
0
 def test_indexed_sub(self):
     base = self.segment
     assert not base.rawdata.is_indexed
     raw = base.rawdata[512:1536]  # 1024 byte segment
     sub = DefaultSegment(raw, 512)
     
     assert not sub.rawdata.is_indexed
     for i in range(len(sub)):
         ri = sub.get_raw_index(i)
         assert ri == sub.start_addr + i
         assert sub[i] == base[ri]
     start, end = sub.byte_bounds_offset()
     assert start == 512
     assert end == 1536
     
     with pytest.raises(IndexError) as e:
         # attempt to get indexes to 1024 * 3... Index to big => fail!
         s, indexes = get_indexed(sub, 1024, 3)
     
     # try with elements up to 256 * 3
     s, indexes = get_indexed(sub, 256, 3)
     print sub.data
     print indexes
     print s.data[:]
     assert s.rawdata.is_indexed
     for i in range(len(indexes)):
         ri = s.get_raw_index(i)
         print ri, "base[ri]=%d" % base[ri], i, indexes[i], "s[i]=%d" % s[i]
         assert ri == sub.start_addr + indexes[i]
         assert s[i] == base[ri]
     start, end = s.byte_bounds_offset()
     assert start == 0
     assert end == len(base)
     
     # get indexed into indexed, will result in every 9th byte
     s2, indexes2 = get_indexed(s, 64, 3)
     assert s2.rawdata.is_indexed
     for i in range(len(indexes2)):
         assert s2.get_raw_index(i) == sub.start_addr + indexes2[i] * 3
     start, end = s.byte_bounds_offset()
     assert start == 0
     assert end == len(base)