[test] Test ops with missing arguments

test/core/simd/meta/README.md

@@ -9,8 +9,11 @@ Currently it only support following simd test files generation.
 - 'simd_f32x4_cmp.wast'
 - 'simd_f64x2_cmp.wast'
 - 'simd_i8x16_arith.wast'
+- 'simd_i8x16_arith2.wast'
 - 'simd_i16x8_arith.wast'
+- 'simd_i16x8_arith2.wast'
 - 'simd_i32x4_arith.wast'
+- 'simd_i32x4_arith2.wast'
 - 'simd_f32x4_arith.wast'
 - 'simd_i64x2_arith.wast'
 - 'simd_f64x2_arith.wast'
@@ -19,9 +22,6 @@ Currently it only support following simd test files generation.
 - 'simd_i16x8_sat_arith.wast'
 - 'simd_f32x4.wast'
 - 'simd_f64x2.wast'
-- 'simd_i8x16.wast'
-- 'simd_i16x8.wast'
-- 'simd_i32x4.wast'
 
 
 Usage:

test/core/simd/meta/simd_arithmetic.py

@@ -14,7 +14,7 @@
 """
 
 from simd import SIMD
-from test_assert import AssertReturn
+from test_assert import AssertReturn, AssertInvalid
 
 
 class LaneNumber:
@@ -325,7 +325,40 @@ def get_invalid_cases(self):
                                                         operand_1='i32.const 0',
                                                         operand_2='f32.const 0.0'))
 
-        return '\n'.join(invalid_cases)
+        return '\n'.join(invalid_cases) + self.argument_empty_test()
+
+    def argument_empty_test(self):
+        """Test cases with empty argument.
+        """
+        cases = []
+
+        cases.append('\n\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.UNARY_OPS:
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE)
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases)
 
     def get_combine_cases(self):
         combine_cases = [';; combination\n(module']
@@ -413,4 +446,4 @@ def get_all_cases(self):
     def gen_test_cases(self):
         wast_filename = '../simd_{lane_type}_arith.wast'.format(lane_type=self.LANE_TYPE)
         with open(wast_filename, 'w') as fp:
-            fp.write(self.get_all_cases())
+            fp.write(self.get_all_cases())

test/core/simd/meta/simd_bitwise.py

@@ -5,14 +5,18 @@
 """
 
 from simd import SIMD
-from test_assert import AssertReturn
+from test_assert import AssertReturn, AssertInvalid
 
 
 class SimdBitWise(SIMD):
     """
     Generate common tests
     """
 
+    UNARY_OPS = ('not',)
+    BINARY_OPS = ('and', 'or', 'xor', 'andnot',)
+    TERNARY_OPS = ('bitselect',)
+
     # Test case template
     CASE_TXT = """;; Test all the bitwise operators on major boundary values and all special values.
 
@@ -182,6 +186,7 @@ def get_combination_case(self):
         lst_nested_case_func = []
         lst_in_block_case_assert = []
         lst_nested_case_assert = []
+        lst_argument_empty_case = []
 
         for ipr in lst_ipr:
 
@@ -242,9 +247,59 @@ def get_combination_case(self):
                '{assert_in_block_cases}' \
                '{assert_of_nested_cases}' \
                '\n(assert_return (invoke "as-param"))\n'.format(in_block_cases=''.join(lst_in_block_case_func),
-                                                                nested_cases=''.join(lst_nested_case_func),
-                                                                assert_in_block_cases=''.join(lst_in_block_case_assert),
-                                                                assert_of_nested_cases=''.join(lst_nested_case_assert))
+                                                    nested_cases=''.join(lst_nested_case_func),
+                                                    assert_in_block_cases=''.join(lst_in_block_case_assert),
+                                                    assert_of_nested_cases=''.join(lst_nested_case_assert))
+
+    def get_argument_empty_case(self):
+        """
+        Generate argument empty cases
+        """
+
+        cases = []
+
+        param_1 = SIMD.v128_const('0', 'i32x4')
+
+        cases.append('\n\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.UNARY_OPS:
+            case_data['op'] = 'v128.' + op
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = 'v128.' + op
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = param_1
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        for op in self.TERNARY_OPS:
+            case_data['op'] = 'v128.' + op
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = param_1 + ' ' + param_1
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'two-args-empty'
+            case_data['params'] = param_1
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases) + '\n'
+
 
     def get_all_cases(self):
         """
@@ -254,7 +309,7 @@ def get_all_cases(self):
         case_data = {'normal_case': self.get_normal_case()}
 
         # Add tests for unkonow operators for i32x4
-        return self.CASE_TXT.format(**case_data) + self.get_invalid_case() + self.get_combination_case()
+        return self.CASE_TXT.format(**case_data) + self.get_invalid_case() + self.get_combination_case() + self.get_argument_empty_case()
 
     def get_case_data(self):
         """
@@ -444,4 +499,4 @@ def gen_test_cases():
 
 
 if __name__ == '__main__':
-    gen_test_cases()
+    gen_test_cases()

test/core/simd/meta/simd_compare.py

@@ -9,7 +9,7 @@
 
 import abc
 from simd import SIMD
-from test_assert import AssertReturn
+from test_assert import AssertReturn, AssertInvalid
 
 
 # Generate common comparison tests
@@ -369,14 +369,41 @@ def get_normal_case(self):
 
         return '\n'.join(cases)
 
+    def argument_empty_test(self):
+        """Test cases with empty argument.
+        """
+        cases = []
+
+        cases.append('\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
+
+        for op in self.BINARY_OPS:
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE)
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases)
+
     # Generate all test cases
     def get_all_cases(self):
 
         case_data = {'normal_case': self.get_normal_case(),
                      'lane_type': self.LANE_TYPE}
 
         # Generate tests using the test template
-        return self.CASE_TXT.format(**case_data)
+        return self.CASE_TXT.format(**case_data) + self.argument_empty_test()
 
     # Generate test case file
     def gen_test_cases(self):

test/core/simd/meta/simd_f32x4_cmp.py

@@ -16,6 +16,9 @@
 class Simdf32x4CmpCase(SimdCmpCase):
 
     LANE_TYPE = 'f32x4'
+
+    BINARY_OPS = ['eq', 'ne', 'lt', 'le', 'gt', 'ge']
+
     # Test template, using this template to generate tests with variable test datas.
     CASE_TXT = """;; Test all the {lane_type} comparison operators on major boundary values and all special values.
 
@@ -501,4 +504,4 @@ def gen_test_cases():
 
 if __name__ == '__main__':
     f32x4 = Simdf32x4CmpCase()
-    f32x4.gen_test_cases()
+    f32x4.gen_test_cases()

test/core/simd/meta/simd_i16x8_cmp.py

@@ -14,6 +14,8 @@ class Simdi16x8CmpCase(SimdCmpCase):
 
     LANE_TYPE = 'i16x8'
 
+    BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u']
+
     # Overloads base class method and sets test data for i16x8.
     def get_case_data(self):
 
@@ -820,4 +822,4 @@ def gen_test_cases():
 
 if __name__ == '__main__':
     i16x8 = Simdi16x8CmpCase()
-    i16x8.gen_test_cases()
+    i16x8.gen_test_cases()

test/core/simd/meta/simd_i32x4_cmp.py

@@ -14,6 +14,8 @@ class Simdi32x4CmpCase(SimdCmpCase):
 
     LANE_TYPE = 'i32x4'
 
+    BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u']
+
     # Overload base class method and set test data for i32x4.
     def get_case_data(self):
 
@@ -832,4 +834,4 @@ def gen_test_cases():
 
 if __name__ == '__main__':
     i32x4 = Simdi32x4CmpCase()
-    i32x4.gen_test_cases()
+    i32x4.gen_test_cases()

test/core/simd/meta/simd_i8x16_cmp.py

@@ -15,6 +15,8 @@ class Simdi8x16CmpCase(SimdCmpCase):
     # set lane type
     LANE_TYPE = 'i8x16'
 
+    BINARY_OPS = ['eq', 'ne', 'lt_s', 'lt_u', 'le_s', 'le_u', 'gt_s', 'gt_u', 'ge_s', 'ge_u']
+
     # Overload base class method and set test data for i32x4.
     def get_case_data(self):
 

test/core/simd/meta/simd_int_arith2.py

@@ -5,7 +5,7 @@
 """
 
 from simd import SIMD
-from test_assert import AssertReturn
+from test_assert import AssertReturn, AssertInvalid
 from simd_lane_value import LaneValue
 from simd_integer_op import IntegerSimpleOp as IntOp
 
@@ -319,31 +319,29 @@ def gen_test_case_combination(self):
     def gen_test_case_empty_argument(self):
         """generate empty argument test cases"""
 
-        assert_1st_empyt_template = '\n(assert_invalid' \
-                                    '\n  (module' \
-                                    '\n    (func ${lane_type}.{op}-1st-arg-empty (result v128)' \
-                                    '\n      ({lane_type}.{op} {param_1})' \
-                                    '\n    )' \
-                                    '\n  )' \
-                                    '\n  "type mismatch"' \
-                                    '\n)'
-        assert_all_empty_template = '\n(assert_invalid' \
-                                    '\n  (module' \
-                                    '\n    (func ${lane_type}.{op}-all-args-empty (result v128)' \
-                                    '\n      ({lane_type}.{op})' \
-                                    '\n    )' \
-                                    '\n  )' \
-                                    '\n  "type mismatch"' \
-                                    '\n)'
+        cases = []
 
-        cases = ''
+        cases.append('\n\n;; Test operation with empty argument\n')
+
+        case_data = {
+            'op': '',
+            'extended_name': 'arg-empty',
+            'param_type': '',
+            'result_type': '(result v128)',
+            'params': '',
+        }
 
-        cases += '\n\n;; Test operation with empty argument\n'
         for op in self.BINARY_OPS:
-            cases += assert_1st_empyt_template.format(lane_type=self.LANE_TYPE, op=op, param_1=SIMD.v128_const('0', self.LANE_TYPE))
-            cases += assert_all_empty_template.format(lane_type=self.LANE_TYPE, op=op)
+            case_data['op'] = '{lane_type}.{op}'.format(lane_type=self.LANE_TYPE, op=op)
+            case_data['extended_name'] = '1st-arg-empty'
+            case_data['params'] = SIMD.v128_const('0', self.LANE_TYPE)
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
 
-        return cases
+            case_data['extended_name'] = 'arg-empty'
+            case_data['params'] = ''
+            cases.append(AssertInvalid.get_arg_empty_test(**case_data))
+
+        return '\n'.join(cases)
 
     @property
     def gen_funcs(self):
@@ -397,4 +395,4 @@ def gen_test_cases():
 
 
 if __name__ == '__main__':
-    gen_test_cases()
+    gen_test_cases()