def test_corr_153_123(self):
     # Test (153, 123) code with 15 errors (correctable).
     (gdata, gcheck, rdata, rcheck) = self._make_test_data(seed=10032,
                                                           block_len=153,
                                                           data_len=123,
                                                           n_errors=15)
     decoded = qrdecode.rs_error_correction(rdata, rcheck, max_errors=15)
     self.assertEqual(decoded, gdata)
 def test_corr_100_80(self):
     # Test (100, 80) code with 10 errors (correctable).
     (gdata, gcheck, rdata, rcheck) = self._make_test_data(seed=10022,
                                                           block_len=100,
                                                           data_len=80,
                                                           n_errors=10)
     decoded = qrdecode.rs_error_correction(rdata, rcheck, max_errors=10)
     self.assertEqual(decoded, gdata)
 def test_corr_44_28(self):
     # Test (44, 28) code with 8 errors (correctable).
     (gdata, gcheck, rdata, rcheck) = self._make_test_data(seed=10012,
                                                           block_len=44,
                                                           data_len=28,
                                                           n_errors=8)
     decoded = qrdecode.rs_error_correction(rdata, rcheck, max_errors=8)
     self.assertEqual(decoded, gdata)
 def test_uncorr_44_28(self):
     # Test (44, 28) code with 9 errors (uncorrectable).
     (gdata, gcheck, rdata, rcheck) = self._make_test_data(seed=10013,
                                                           block_len=44,
                                                           data_len=28,
                                                           n_errors=9)
     with self.assertRaises(qrdecode.QRDecodeError):
         decoded = qrdecode.rs_error_correction(rdata, rcheck, max_errors=8)
 def test_corr_25_9(self):
     # Test (25, 9) code with 8 errors (correctable).
     (gdata, gcheck, rdata, rcheck) = self._make_test_data(seed=10002,
                                                           block_len=25,
                                                           data_len=9,
                                                           n_errors=8)
     decoded = qrdecode.rs_error_correction(rdata, rcheck, max_errors=8)
     self.assertEqual(decoded, gdata)
 def test_uncorr_153_123(self):
     # Test (153, 123) code with 16 errors (uncorrectable).
     (gdata, gcheck, rdata, rcheck) = self._make_test_data(seed=10033,
                                                           block_len=153,
                                                           data_len=123,
                                                           n_errors=16)
     with self.assertRaises(qrdecode.QRDecodeError):
         decoded = qrdecode.rs_error_correction(rdata,
                                                rcheck,
                                                max_errors=15)
 def test_uncorr_100_80(self):
     # Test (100, 80) code with 11 errors (uncorrectable).
     (gdata, gcheck, rdata, rcheck) = self._make_test_data(seed=10023,
                                                           block_len=100,
                                                           data_len=80,
                                                           n_errors=11)
     with self.assertRaises(qrdecode.QRDecodeError):
         decoded = qrdecode.rs_error_correction(rdata,
                                                rcheck,
                                                max_errors=10)
 def test_corr_25_9_1err_allval(self):
     # Test (25, 9) code with 1 error (correctable).
     # Do this for all possible error values.
     rnd = random.Random(10005)
     gdata = self._make_data_words(rnd, 9)
     gcheck = self._make_check_words(gdata, 25 - 9)
     for v in range(1, 256):
         rdata = list(gdata)
         rcheck = list(gcheck)
         rdata[0] ^= v
         decoded = qrdecode.rs_error_correction(rdata, rcheck, max_errors=8)
         self.assertEqual(decoded, gdata)
 def test_uncorr_25_9(self):
     # Test (25, 9) code with 9 errors (uncorrectable).
     # Note that there is a small probability that the random-generated
     # input turns out to be a correctable block for a different message.
     # However this probability is extremely small.
     # This applies to all tests in the category "test_uncorr_N_K".
     (gdata, gcheck, rdata, rcheck) = self._make_test_data(seed=10003,
                                                           block_len=25,
                                                           data_len=9,
                                                           n_errors=9)
     with self.assertRaises(qrdecode.QRDecodeError):
         decoded = qrdecode.rs_error_correction(rdata, rcheck, max_errors=8)
 def test_corr_25_9_1err_allpos(self):
     # Test (25, 9) code with 1 error (correctable).
     # Do this for all possible error locations.
     rnd = random.Random(10004)
     gdata = self._make_data_words(rnd, 9)
     gcheck = self._make_check_words(gdata, 25 - 9)
     for p in range(25):
         rdata = list(gdata)
         rcheck = list(gcheck)
         v = rnd.randint(1, 255)
         if p < 9:
             rdata[p] ^= v
         else:
             rcheck[p - 9] ^= v
         decoded = qrdecode.rs_error_correction(rdata, rcheck, max_errors=8)
         self.assertEqual(decoded, gdata)
 def test_corr_25_9_2err_allpos(self):
     # Test (25, 9) code with 2 errors (correctable).
     # Do this for all possible error locations.
     rnd = random.Random(10006)
     gdata = self._make_data_words(rnd, 9)
     gcheck = self._make_check_words(gdata, 25 - 9)
     for (p1, p2) in [(p1, p2) for p1 in range(25)
                      for p2 in range(p1 + 1, 25)]:
         rdata = list(gdata)
         rcheck = list(gcheck)
         v1 = rnd.randint(1, 255)
         v2 = rnd.randint(1, 255)
         if p1 < 9:
             rdata[p1] ^= v1
         else:
             rcheck[p1 - 9] ^= v1
         if p2 < 9:
             rdata[p2] ^= v2
         else:
             rcheck[p2 - 9] ^= v2
         decoded = qrdecode.rs_error_correction(rdata, rcheck, max_errors=8)
         self.assertEqual(decoded, gdata)