tests:vle_vse: extend test converage to e16 and e32

Change-Id: Iead1b1e965018b0d351879635670828cb68fe1ab

tests/CMakeLists.txt

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index b98912a..e3644c5 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -118,7 +118,7 @@
   LINKOPTS
    -Xlinker --defsym=__itcm_length__=128K
   TIMEOUT
-    500
+    40
 )
 
 vec_cc_test(

tests/vle_vse_test.cpp

diff --git a/tests/vle_vse_test.cpp b/tests/vle_vse_test.cpp
index 457490f..5542b29 100644
--- a/tests/vle_vse_test.cpp
+++ b/tests/vle_vse_test.cpp
@@ -1,5 +1,5 @@
 #include <riscv_vector.h>
-#include <springbok_intrinsics.h>
+#include <springbok.h>
 #include <stddef.h>
 
 #include "pw_unit_test/framework.h"
@@ -19,23 +19,63 @@
     int32_t avl = AVLS[i];
     int vlmax;
     int vl;
-    std::tie(vlmax, vl) = vector_test_setup<uint8_t>(
-        lmul, avl, {test_vector_1, test_vector_2});
+    switch (sew) {
+      case SEW_E8:
+        std::tie(vlmax, vl) = vector_test_setup<uint8_t>(
+            lmul, avl, {test_vector_1, test_vector_2});
+        break;
+      case SEW_E16:
+        std::tie(vlmax, vl) = vector_test_setup<uint16_t>(
+            lmul, avl, {test_vector_1, test_vector_2});
+        break;
+      case SEW_E32:
+        std::tie(vlmax, vl) = vector_test_setup<uint32_t>(
+            lmul, avl, {test_vector_1, test_vector_2});
+        break;
+      default: {
+        LOG_ERROR("Not supported SEW");
+        ASSERT_TRUE(false);
+        break;
+      }
+    }
+
     if (avl > vlmax) {
       continue;
     }
-    fill_random_vector<uint8_t>(test_vector_1, vl);
+    LOG_DEBUG("vl: %d", vl);
 
     // load c-array values into vector
     // TODO(gkielian): utilize intrinsics for vle
     if (use_intrinsic) {
     } else {
-      __asm__ volatile("vle8.v v0, (%0)" : : "r"(test_vector_1));
-
-      // 2) store the vector back into memory (into result c-array)
-      __asm__ volatile("vse8.v v0, (%0)" : : "r"(test_vector_2));
+      switch (sew) {
+        case SEW_E8: {
+          fill_random_vector<uint8_t>(test_vector_1, vl);
+          __asm__ volatile("vle8.v v0, (%0)" : : "r"(test_vector_1));
+          __asm__ volatile("vse8.v v0, (%0)" : : "r"(test_vector_2));
+          assert_vec_elem_eq<uint8_t>(vl, test_vector_1, test_vector_2);
+          break;
+        }
+        case SEW_E16: {
+          fill_random_vector<uint16_t>(
+              reinterpret_cast<uint16_t *>(test_vector_1), vl);
+          __asm__ volatile("vle16.v v0, (%0)" : : "r"(test_vector_1));
+          __asm__ volatile("vse16.v v0, (%0)" : : "r"(test_vector_2));
+          assert_vec_elem_eq<uint16_t>(vl, test_vector_1, test_vector_2);
+          break;
+        }
+        case SEW_E32: {
+          fill_random_vector<uint32_t>(
+              reinterpret_cast<uint32_t *>(test_vector_1), vl);
+          __asm__ volatile("vle32.v v0, (%0)" : : "r"(test_vector_1));
+          __asm__ volatile("vse32.v v0, (%0)" : : "r"(test_vector_2));
+          assert_vec_elem_eq<uint32_t>(vl, test_vector_1, test_vector_2);
+          break;
+        }
+        default:
+          break;
+      }
     }
-    assert_vec_elem_eq<uint8_t>(vl, test_vector_1, test_vector_2);
   }
 }
 
@@ -55,5 +95,37 @@
   vlevse_test(VSEW::SEW_E8, VLMUL::LMUL_M8, false);
 }
 
+TEST(VleVseTest, vle16vse16_e16m1) {
+  vlevse_test(VSEW::SEW_E16, VLMUL::LMUL_M1, false);
+}
+
+TEST(VleVseTest, vle16vse16_e16m2) {
+  vlevse_test(VSEW::SEW_E16, VLMUL::LMUL_M2, false);
+}
+
+TEST(VleVseTest, vle16vse16_e16m4) {
+  vlevse_test(VSEW::SEW_E16, VLMUL::LMUL_M4, false);
+}
+
+TEST(VleVseTest, vle16vse16_e16m8) {
+  vlevse_test(VSEW::SEW_E16, VLMUL::LMUL_M8, false);
+}
+
+TEST(VleVseTest, vle32vse32_e32m1) {
+  vlevse_test(VSEW::SEW_E32, VLMUL::LMUL_M1, false);
+}
+
+TEST(VleVseTest, vle32vse32_e32m2) {
+  vlevse_test(VSEW::SEW_E32, VLMUL::LMUL_M2, false);
+}
+
+TEST(VleVseTest, vle32vse32_e32m4) {
+  vlevse_test(VSEW::SEW_E32, VLMUL::LMUL_M4, false);
+}
+
+TEST(VleVseTest, vle32vse32_e32m8) {
+  vlevse_test(VSEW::SEW_E32, VLMUL::LMUL_M8, false);
+}
+
 }  // namespace
 }  // namespace vle_vse_test