Add liberasurecode_rs_vand test cases

test/test_pyeclib_api.py

@@ -26,6 +26,7 @@ from string import ascii_letters, ascii_uppercase, digits
 import sys
 import tempfile
 import unittest
+from pyeclib.ec_iface import ECBackendNotSupported
 from pyeclib.ec_iface import ECDriverError
 from pyeclib.ec_iface import ECInsufficientFragments
 
@@ -117,13 +118,26 @@ class TestPyECLibDriver(unittest.TestCase):
                 else:
                     _instance = ECDriver(k=10, m=5, ec_type=_type)
             except ECDriverError:
-                self.fail("%s algorithm not supported" % _type)
+                self.fail("%p: %s algorithm not supported" % _instance, _type)
+
+        self.assertRaises(ECBackendNotSupported, ECDriver, k=10, m=5,
+                          ec_type="invalid_algo")
 
     def test_small_encode(self):
         pyeclib_drivers = []
         pyeclib_drivers.append(ECDriver(k=12, m=2, ec_type="jerasure_rs_vand"))
         pyeclib_drivers.append(ECDriver(k=11, m=2, ec_type="jerasure_rs_vand"))
         pyeclib_drivers.append(ECDriver(k=10, m=2, ec_type="jerasure_rs_vand"))
+        pyeclib_drivers.append(ECDriver(k=8, m=4, ec_type="jerasure_rs_vand"))
+
+        pyeclib_drivers.append(ECDriver(k=12, m=2,
+                                        ec_type="liberasurecode_rs_vand"))
+        pyeclib_drivers.append(ECDriver(k=11, m=2,
+                                        ec_type="liberasurecode_rs_vand"))
+        pyeclib_drivers.append(ECDriver(k=10, m=2,
+                                        ec_type="liberasurecode_rs_vand"))
+        pyeclib_drivers.append(ECDriver(k=8, m=4,
+                                        ec_type="liberasurecode_rs_vand"))
 
         encode_strs = [b"a", b"hello", b"hellohyhi", b"yo"]
 
@@ -196,80 +210,97 @@ class TestPyECLibDriver(unittest.TestCase):
 #                pyeclib_driver.verify_stripe_metadata(fragment_metadata_list) == -1)
 #
 
-    def get_available_backend(self, k, m, ec_type, chksum_type = "inline_crc32"):
+    def check_metadata_formatted(self, k, m, ec_type, chksum_type):
-      if ec_type[:11] == "flat_xor_hd":
-        return ECDriver(k=k, m=m, ec_type="flat_xor_hd", chksum_type=chksum_type)
-      elif ec_type in self.available_backends:
-        return ECDriver(k=k, m=m, ec_type=ec_type, chksum_type=chksum_type)
-      else:
-        return None
-
-    def test_get_metadata_formatted(self):
-        pyeclib_driver = ECDriver(k=12, m=2, ec_type="jerasure_rs_vand", chksum_type="inline_crc32")
 
         filesize = 1024 * 1024 * 3
-        file_str = ''.join(random.choice(ascii_letters) for i in range(filesize))
+        file_str = ''.join(random.choice(ascii_letters)
+                           for i in range(filesize))
         file_bytes = file_str.encode('utf-8')
 
+        pyeclib_driver = ECDriver(k=k, m=m, ec_type=ec_type,
+                                  chksum_type=chksum_type)
+
         fragments = pyeclib_driver.encode(file_bytes)
 
-        i = 0
+        f = 0
         for fragment in fragments:
             metadata = pyeclib_driver.get_metadata(fragment, 1)
-          if metadata.has_key('index'):
+            if 'index' in metadata:
-            self.assertEqual(metadata['index'], i)
+                self.assertEqual(metadata['index'], f)
             else:
-            self.assertTrue(false)
+                self.assertTrue(False)
 
-          if metadata.has_key('chksum_mismatch'):
+            if 'chksum_mismatch' in metadata:
                 self.assertEqual(metadata['chksum_mismatch'], 0)
             else:
-            self.assertTrue(false)
+                self.assertTrue(False)
 
-          if metadata.has_key('backend_id'):
+            if 'backend_id' in metadata:
-            self.assertEqual(metadata['backend_id'], 'jerasure_rs_vand')
+                self.assertEqual(metadata['backend_id'], ec_type)
             else:
-            self.assertTrue(false)
+                self.assertTrue(False)
 
-          if metadata.has_key('orig_data_size'):
+            if 'orig_data_size' in metadata:
                 self.assertEqual(metadata['orig_data_size'], 3145728)
             else:
-            self.assertTrue(false)
+                self.assertTrue(False)
 
-          if metadata.has_key('chksum_type'):
+            if 'chksum_type' in metadata:
                 self.assertEqual(metadata['chksum_type'], 'crc32')
             else:
-            self.assertTrue(false)
+                self.assertTrue(False)
 
-          if not metadata.has_key('backend_version'):
+            if 'backend_version' not in metadata:
-            self.assertTrue(false)
+                self.assertTrue(False)
 
-          if not metadata.has_key('chksum'):
+            if 'chksum' not in metadata:
-            self.assertTrue(false)
+                self.assertTrue(False)
 
-          if not metadata.has_key('size'):
+            if 'size' not in metadata:
-            self.assertTrue(false)
+                self.assertTrue(False)
-
-          i += 1
 
+            f += 1
 
+    def test_get_metadata_formatted(self):
+        self.check_metadata_formatted(12, 2, "jerasure_rs_vand",
+                                      "inline_crc32")
+        self.check_metadata_formatted(12, 2, "liberasurecode_rs_vand",
+                                      "inline_crc32")
+        self.check_metadata_formatted(8, 4, "liberasurecode_rs_vand",
+                                      "inline_crc32")
 
     def test_verify_fragment_inline_chksum_fail(self):
         pyeclib_drivers = []
         pyeclib_drivers.append(
-            ECDriver(k=12, m=2, ec_type="jerasure_rs_vand", chksum_type="inline_crc32"))
+            ECDriver(k=12, m=2, ec_type="jerasure_rs_vand",
+                     chksum_type="inline_crc32"))
         pyeclib_drivers.append(
-            ECDriver(k=12, m=3, ec_type="jerasure_rs_vand", chksum_type="inline_crc32"))
+            ECDriver(k=12, m=3, ec_type="jerasure_rs_vand",
+                     chksum_type="inline_crc32"))
         pyeclib_drivers.append(
-            ECDriver(k=12, m=4, ec_type="jerasure_rs_vand", chksum_type="inline_crc32"))
+            ECDriver(k=12, m=4, ec_type="jerasure_rs_vand",
+                     chksum_type="inline_crc32"))
         pyeclib_drivers.append(
-            ECDriver(k=12, m=2, ec_type="jerasure_rs_cauchy", chksum_type="inline_crc32"))
+            ECDriver(k=12, m=2, ec_type="jerasure_rs_cauchy",
+                     chksum_type="inline_crc32"))
+
+        pyeclib_drivers.append(
+            ECDriver(k=12, m=2, ec_type="liberasurecode_rs_vand",
+                     chksum_type="inline_crc32"))
+        pyeclib_drivers.append(
+            ECDriver(k=12, m=3, ec_type="liberasurecode_rs_vand",
+                     chksum_type="inline_crc32"))
+        pyeclib_drivers.append(
+            ECDriver(k=12, m=4, ec_type="liberasurecode_rs_vand",
+                     chksum_type="inline_crc32"))
+        pyeclib_drivers.append(
+            ECDriver(k=12, m=2, ec_type="liberasurecode_rs_vand",
+                     chksum_type="inline_crc32"))
 
         filesize = 1024 * 1024 * 3
         file_str = ''.join(random.choice(ascii_letters) for i in range(filesize))
         file_bytes = file_str.encode('utf-8')
 
-
         for pyeclib_driver in pyeclib_drivers:
             fragments = pyeclib_driver.encode(file_bytes)
 
@@ -339,6 +370,12 @@ class TestPyECLibDriver(unittest.TestCase):
             ECDriver(k=11, m=2, ec_type="jerasure_rs_vand"))
         pyeclib_drivers.append(
             ECDriver(k=10, m=2, ec_type="jerasure_rs_vand"))
+        pyeclib_drivers.append(
+            ECDriver(k=12, m=2, ec_type="liberasurecode_rs_vand"))
+        pyeclib_drivers.append(
+            ECDriver(k=11, m=2, ec_type="liberasurecode_rs_vand"))
+        pyeclib_drivers.append(
+            ECDriver(k=10, m=2, ec_type="liberasurecode_rs_vand"))
 
         file_size = 1024 * 1024
         segment_size = 3 * 1024
@@ -372,6 +409,12 @@ class TestPyECLibDriver(unittest.TestCase):
             ECDriver(k=11, m=2, ec_type="jerasure_rs_vand"))
         pyeclib_drivers.append(
             ECDriver(k=10, m=2, ec_type="jerasure_rs_vand"))
+        pyeclib_drivers.append(
+            ECDriver(k=12, m=2, ec_type="liberasurecode_rs_vand"))
+        pyeclib_drivers.append(
+            ECDriver(k=11, m=2, ec_type="liberasurecode_rs_vand"))
+        pyeclib_drivers.append(
+            ECDriver(k=10, m=2, ec_type="liberasurecode_rs_vand"))
 
         file_sizes = [
             1024 * 1024,
@@ -450,6 +493,12 @@ class TestPyECLibDriver(unittest.TestCase):
             ECDriver(k=12, m=6, ec_type="flat_xor_hd"))
         pyeclib_drivers.append(
             ECDriver(k=10, m=5, ec_type="flat_xor_hd"))
+        pyeclib_drivers.append(
+            ECDriver(k=12, m=2, ec_type="liberasurecode_rs_vand"))
+        pyeclib_drivers.append(
+            ECDriver(k=8, m=6, ec_type="liberasurecode_rs_vand"))
+        pyeclib_drivers.append(
+            ECDriver(k=10, m=4, ec_type="liberasurecode_rs_vand"))
 
         for pyeclib_driver in pyeclib_drivers:
             for file_size in self.file_sizes:
@@ -457,7 +506,6 @@ class TestPyECLibDriver(unittest.TestCase):
                 tmp_file.seek(0)
                 whole_file_str = tmp_file.read()
                 whole_file_bytes = whole_file_str.encode('utf-8')
-                got_exception = False
 
                 encode_input = whole_file_bytes
                 orig_fragments = pyeclib_driver.encode(encode_input)
@@ -511,33 +559,32 @@ class TestPyECLibDriver(unittest.TestCase):
                         fragments[i] = corrupted_fragment
                       i += 1
 
-                    try:
+                    self.assertRaises(ECInsufficientFragments,
-                      decoded_string = pyeclib_driver.decode(fragments[:], force_metadata_checks=True)
+                                      pyeclib_driver.decode,
-                    except:
+                                      fragments[:], force_metadata_checks=True)
-                      got_exception = True 
-                    self.assertTrue(got_exception)
 
-    def test_liberasurecode_error(self):
+    def get_available_backend(self, k, m, ec_type, chksum_type="inline_crc32"):
-        pyeclib_driver = self.get_available_backend(k=10, m=5, ec_type="flat_xor_hd_3")
+        if ec_type[:11] == "flat_xor_hd":
+            return ECDriver(k=k, m=m, ec_type="flat_xor_hd",
+                            chksum_type=chksum_type)
+        elif ec_type in _available_backends:
+            return ECDriver(k=k, m=m, ec_type=ec_type, chksum_type=chksum_type)
+        else:
+            return None
+
+    def test_liberasurecode_insufficient_frags_error(self):
         file_size = self.file_sizes[0]
         tmp_file = self.files[file_size]
         tmp_file.seek(0)
         whole_file_str = tmp_file.read()
         whole_file_bytes = whole_file_str.encode('utf-8')
-        hit_exception = False
+        for ec_type in ['flat_xor_hd_3', 'liberasurecode_rs_vand']:
-
+            pyeclib_driver = self.get_available_backend(
+                k=10, m=5, ec_type=ec_type)
             fragments = pyeclib_driver.encode(whole_file_bytes)
-
+            self.assertRaises(ECInsufficientFragments,
-        #
+                              pyeclib_driver.reconstruct,
-        # Test reconstructor with insufficient fragments
+                              [fragments[0]], [1, 2, 3, 4, 5, 6])
-        #
-        try:
-            pyeclib_driver.reconstruct([fragments[0]], [1, 2, 3, 4, 5, 6])
-        except ECInsufficientFragments as e:
-            hit_exception = True
-            self.assertTrue(e.error_str.__str__().find("Insufficient number of fragments") > -1)
-
-        self.assertTrue(hit_exception)
 
     def test_min_parity_fragments_needed(self):
         pyeclib_drivers = []