Star1359
1455
代码
代码
Issues116
Pull Requests271
Actions
项目讨论
Wiki
分析
Star1359
1455
已合并
test:Modify licence date and delete space #1420
zhaowenrui创建于 3月2日
test:Modify licence date and delete space #1420
已合并
zhaowenrui创建于 3月2日
从zhaowenrui666/ops-mathut2合入到cann/ops-mathmaster
共 5 个文件变更+93-114
Mmath/triangular_solve/tests/CMakeLists.txt+1-1
@@ -1,5 +1,5 @@
1# -----------------------------------------------------------------------------------------------------------1# -----------------------------------------------------------------------------------------------------------
2-# Copyright (c) 2025 Huawei Technologies Co., Ltd.2+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
3# This program is free software, you can redistribute it and/or modify it under the terms and conditions of3# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4# CANN Open Software License Agreement Version 2.0 (the "License").4# CANN Open Software License Agreement Version 2.0 (the "License").
5# Please refer to the License for details. You may not use this file except in compliance with the License5# Please refer to the License for details. You may not use this file except in compliance with the License
Mmath/triangular_solve/tests/ut/CMakeLists.txt+1-1
@@ -1,5 +1,5 @@
1# -----------------------------------------------------------------------------------------------------------1# -----------------------------------------------------------------------------------------------------------
2-# Copyright (c) 2025 Huawei Technologies Co., Ltd.2+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
3# This program is free software, you can redistribute it and/or modify it under the terms and conditions of3# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4# CANN Open Software License Agreement Version 2.0 (the "License").4# CANN Open Software License Agreement Version 2.0 (the "License").
5# Please refer to the License for details. You may not use this file except in compliance with the License.5# Please refer to the License for details. You may not use this file except in compliance with the License.
Mmath/triangular_solve/tests/ut/op_api/CMakeLists.txt+1-1
@@ -1,5 +1,5 @@
1# -----------------------------------------------------------------------------------------------------------1# -----------------------------------------------------------------------------------------------------------
2-# Copyright (c) 2025 Huawei Technologies Co., Ltd.2+# Copyright (c) 2026 Huawei Technologies Co., Ltd.
3# This program is free software, you can redistribute it and/or modify it under the terms and conditions of3# This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4# CANN Open Software License Agreement Version 2.0 (the "License").4# CANN Open Software License Agreement Version 2.0 (the "License").
5# Please refer to the License for details. You may not use this file except in compliance with the License.5# Please refer to the License for details. You may not use this file except in compliance with the License.
Mmath/triangular_solve/tests/ut/op_api/test_aclnn_l0_triangular_solve.cpp+1-1
@@ -1,5 +1,5 @@
1/**1/**
2- * Copyright (c) 2025 Huawei Technologies Co., Ltd.2+ * Copyright (c) 2026 Huawei Technologies Co., Ltd.
3 * This program is free software, you can redistribute it and/or modify it under the terms and conditions of3 * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 * CANN Open Software License Agreement Version 2.0 (the "License").4 * CANN Open Software License Agreement Version 2.0 (the "License").
5 * Please refer to the License for details. You may not use this file except in compliance with the License.5 * Please refer to the License for details. You may not use this file except in compliance with the License.
Mmath/triangular_solve/tests/ut/op_api/test_aclnn_l2_triangular_solve.cpp+89-110
@@ -1,5 +1,5 @@
1/**1/**
2- * Copyright (c) 2025 Huawei Technologies Co., Ltd.2+ * Copyright (c) 2026 Huawei Technologies Co., Ltd.
3 * This program is free software, you can redistribute it and/or modify it under the terms and conditions of3 * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
4 * CANN Open Software License Agreement Version 2.0 (the "License").4 * CANN Open Software License Agreement Version 2.0 (the "License").
5 * Please refer to the License for details. You may not use this file except in compliance with the License.5 * Please refer to the License for details. You may not use this file except in compliance with the License.
@@ -18,16 +18,21 @@ using namespace std;
18 18 
19class l2_triangular_solve_test : public testing::Test {19class l2_triangular_solve_test : public testing::Test {
20protected:20protected:
21- static void SetUpTestCase() { cout << "Triangular Solve Test Setup" << endl; }21+ static void SetUpTestCase()
22- static void TearDownTestCase() { cout << "Triangular Solve Test TearDown" << endl; }22+ {
23+ cout << "Triangular Solve Test Setup" << endl;
24+ }
25+ static void TearDownTestCase()
26+ {
27+ cout << "Triangular Solve Test TearDown" << endl;
28+ }
23};29};
24 30 
25TEST_F(l2_triangular_solve_test, case_normal)31TEST_F(l2_triangular_solve_test, case_normal)
26{32{
27- auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND)33+ auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
28- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});34+ auto b_desc =
29- auto b_desc = TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND)35+ TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
30- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
31 bool upper = true;36 bool upper = true;
32 bool transpose = false;37 bool transpose = false;
33 bool unitriangular = false;38 bool unitriangular = false;
@@ -35,8 +40,8 @@ TEST_F(l2_triangular_solve_test, case_normal)
35 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);40 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
36 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);41 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
37 42 
38- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),43+ auto ut =
39- OUTPUT(X_desc, M_desc));44+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
40 uint64_t workspaceSize = 0;45 uint64_t workspaceSize = 0;
41 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);46 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
42 EXPECT_EQ(aclRet, ACLNN_SUCCESS);47 EXPECT_EQ(aclRet, ACLNN_SUCCESS);
@@ -44,12 +49,10 @@ TEST_F(l2_triangular_solve_test, case_normal)
44 49 
45TEST_F(l2_triangular_solve_test, case_nullptr)50TEST_F(l2_triangular_solve_test, case_nullptr)
46 51 
47- 
48{52{
49- auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND)53+ auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
50- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});54+ auto b_desc =
51- auto b_desc = TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND)55+ TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
52- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
53 bool upper = true;56 bool upper = true;
54 bool transpose = false;57 bool transpose = false;
55 bool unitriangular = false;58 bool unitriangular = false;
@@ -57,26 +60,26 @@ TEST_F(l2_triangular_solve_test, case_nullptr)
57 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);60 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
58 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);61 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
59 62 
60- auto ut1 = OP_API_UT(aclnnTriangularSolve, INPUT(nullptr, A_desc, upper, transpose, unitriangular),63+ auto ut1 = OP_API_UT(
61- OUTPUT(X_desc, M_desc));64+ aclnnTriangularSolve, INPUT(nullptr, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
62 uint64_t workspaceSize1 = 0;65 uint64_t workspaceSize1 = 0;
63 aclnnStatus aclRet1 = ut1.TestGetWorkspaceSize(&workspaceSize1);66 aclnnStatus aclRet1 = ut1.TestGetWorkspaceSize(&workspaceSize1);
64 EXPECT_EQ(aclRet1, ACLNN_ERR_INNER_NULLPTR);67 EXPECT_EQ(aclRet1, ACLNN_ERR_INNER_NULLPTR);
65 68 
66- auto ut2 = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, nullptr, upper, transpose, unitriangular),69+ auto ut2 = OP_API_UT(
67- OUTPUT(X_desc, M_desc));70+ aclnnTriangularSolve, INPUT(b_desc, nullptr, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
68 uint64_t workspaceSize2 = 0;71 uint64_t workspaceSize2 = 0;
69 aclnnStatus aclRet2 = ut2.TestGetWorkspaceSize(&workspaceSize2);72 aclnnStatus aclRet2 = ut2.TestGetWorkspaceSize(&workspaceSize2);
70 EXPECT_EQ(aclRet2, ACLNN_ERR_INNER_NULLPTR);73 EXPECT_EQ(aclRet2, ACLNN_ERR_INNER_NULLPTR);
71 74 
72- auto ut3 = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),75+ auto ut3 = OP_API_UT(
73- OUTPUT(nullptr, M_desc));76+ aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(nullptr, M_desc));
74 uint64_t workspaceSize3 = 0;77 uint64_t workspaceSize3 = 0;
75 aclnnStatus aclRet3 = ut3.TestGetWorkspaceSize(&workspaceSize3);78 aclnnStatus aclRet3 = ut3.TestGetWorkspaceSize(&workspaceSize3);
76 EXPECT_EQ(aclRet3, ACLNN_ERR_INNER_NULLPTR);79 EXPECT_EQ(aclRet3, ACLNN_ERR_INNER_NULLPTR);
77 80 
78- auto ut4 = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),81+ auto ut4 = OP_API_UT(
79- OUTPUT(X_desc, nullptr));82+ aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, nullptr));
80 uint64_t workspaceSize4 = 0;83 uint64_t workspaceSize4 = 0;
81 aclnnStatus aclRet4 = ut4.TestGetWorkspaceSize(&workspaceSize4);84 aclnnStatus aclRet4 = ut4.TestGetWorkspaceSize(&workspaceSize4);
82 EXPECT_EQ(aclRet4, ACLNN_ERR_INNER_NULLPTR);85 EXPECT_EQ(aclRet4, ACLNN_ERR_INNER_NULLPTR);
@@ -84,20 +87,15 @@ TEST_F(l2_triangular_solve_test, case_nullptr)
84 87 
85TEST_F(l2_triangular_solve_test, case_dtype_valid)88TEST_F(l2_triangular_solve_test, case_dtype_valid)
86{89{
87- vector<aclDataType> ValidList = {90+ vector<aclDataType> ValidList = {ACL_FLOAT, ACL_DOUBLE, ACL_COMPLEX64, ACL_COMPLEX128, ACL_FLOAT16};
88- ACL_FLOAT,91+ 
89- ACL_DOUBLE,
90- ACL_COMPLEX64,
91- ACL_COMPLEX128,
92- ACL_FLOAT16};
93-
94 int length = ValidList.size();92 int length = ValidList.size();
95 for (int i = 0; i < length; i++) {93 for (int i = 0; i < length; i++) {
96- auto A_desc = TensorDesc({1, 1, 3, 3}, ValidList[i], ACL_FORMAT_ND)94+ auto A_desc =
97- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});95+ TensorDesc({1, 1, 3, 3}, ValidList[i], ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
98 auto b_desc = TensorDesc({1, 1, 3, 4}, ValidList[i], ACL_FORMAT_ND)96 auto b_desc = TensorDesc({1, 1, 3, 4}, ValidList[i], ACL_FORMAT_ND)
99- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}); 97+ .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
100- 98+ 
101 bool upper = true;99 bool upper = true;
102 bool transpose = false;100 bool transpose = false;
103 bool unitriangular = false;101 bool unitriangular = false;
@@ -105,8 +103,8 @@ TEST_F(l2_triangular_solve_test, case_dtype_valid)
105 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);103 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
106 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);104 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
107 105 
108- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),106+ auto ut = OP_API_UT(
109- OUTPUT(X_desc, M_desc));107+ aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
110 // SAMPLE: only test GetWorkspaceSize108 // SAMPLE: only test GetWorkspaceSize
111 uint64_t workspaceSize = 0;109 uint64_t workspaceSize = 0;
112 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);110 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
@@ -118,13 +116,11 @@ TEST_F(l2_triangular_solve_test, case_dtype_valid)
118 }116 }
119}117}
120 118 
121- 
122TEST_F(l2_triangular_solve_test, case_dtype_diff)119TEST_F(l2_triangular_solve_test, case_dtype_diff)
123{120{
124- auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND)121+ auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
125- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});122+ auto b_desc =
126- auto b_desc = TensorDesc({1, 1, 3, 4}, ACL_DOUBLE, ACL_FORMAT_ND)123+ TensorDesc({1, 1, 3, 4}, ACL_DOUBLE, ACL_FORMAT_ND).Value(vector<double>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
127- .Value(vector<double>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
128 bool upper = true;124 bool upper = true;
129 bool transpose = false;125 bool transpose = false;
130 bool unitriangular = false;126 bool unitriangular = false;
@@ -132,8 +128,8 @@ TEST_F(l2_triangular_solve_test, case_dtype_diff)
132 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);128 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
133 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);129 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
134 130 
135- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),131+ auto ut =
136- OUTPUT(X_desc, M_desc));132+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
137 uint64_t workspaceSize = 0;133 uint64_t workspaceSize = 0;
138 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);134 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
139 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);135 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
@@ -141,10 +137,8 @@ TEST_F(l2_triangular_solve_test, case_dtype_diff)
141 137 
142TEST_F(l2_triangular_solve_test, case_dim_less_2)138TEST_F(l2_triangular_solve_test, case_dim_less_2)
143{139{
144- auto A_desc = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND)140+ auto A_desc = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3});
145- .Value(vector<float>{1, 2, 3});141+ auto b_desc = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3});
146- auto b_desc = TensorDesc({3}, ACL_FLOAT, ACL_FORMAT_ND)
147- .Value(vector<float>{1, 2, 3});
148 bool upper = true;142 bool upper = true;
149 bool transpose = false;143 bool transpose = false;
150 bool unitriangular = false;144 bool unitriangular = false;
@@ -152,8 +146,8 @@ TEST_F(l2_triangular_solve_test, case_dim_less_2)
152 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);146 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
153 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);147 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
154 148 
155- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),149+ auto ut =
156- OUTPUT(X_desc, M_desc));150+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
157 uint64_t workspaceSize = 0;151 uint64_t workspaceSize = 0;
158 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);152 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
159 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);153 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
@@ -162,9 +156,9 @@ TEST_F(l2_triangular_solve_test, case_dim_less_2)
162TEST_F(l2_triangular_solve_test, case_dim_more_8)156TEST_F(l2_triangular_solve_test, case_dim_more_8)
163{157{
164 auto A_desc = TensorDesc({1, 1, 1, 1, 1, 1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND)158 auto A_desc = TensorDesc({1, 1, 1, 1, 1, 1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND)
165- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});159+ .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
166 auto b_desc = TensorDesc({1, 1, 1, 1, 1, 1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND)160 auto b_desc = TensorDesc({1, 1, 1, 1, 1, 1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND)
167- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}); 161+ .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
168 bool upper = true;162 bool upper = true;
169 bool transpose = false;163 bool transpose = false;
170 bool unitriangular = false;164 bool unitriangular = false;
@@ -172,8 +166,8 @@ TEST_F(l2_triangular_solve_test, case_dim_more_8)
172 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);166 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
173 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);167 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
174 168 
175- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),169+ auto ut =
176- OUTPUT(X_desc, M_desc));170+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
177 uint64_t workspaceSize = 0;171 uint64_t workspaceSize = 0;
178 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);172 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
179 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);173 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
@@ -181,10 +175,9 @@ TEST_F(l2_triangular_solve_test, case_dim_more_8)
181 175 
182TEST_F(l2_triangular_solve_test, case_a_square)176TEST_F(l2_triangular_solve_test, case_a_square)
183{177{
184- auto A_desc = TensorDesc({1, 1, 3, 2}, ACL_FLOAT, ACL_FORMAT_ND)178+ auto A_desc = TensorDesc({1, 1, 3, 2}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6});
185- .Value(vector<float>{1, 2, 3, 4, 5, 6});179+ auto b_desc =
186- auto b_desc = TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND)180+ TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
187- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
188 bool upper = true;181 bool upper = true;
189 bool transpose = false;182 bool transpose = false;
190 bool unitriangular = false;183 bool unitriangular = false;
@@ -192,8 +185,8 @@ TEST_F(l2_triangular_solve_test, case_a_square)
192 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);185 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
193 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);186 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
194 187 
195- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),188+ auto ut =
196- OUTPUT(X_desc, M_desc));189+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
197 uint64_t workspaceSize = 0;190 uint64_t workspaceSize = 0;
198 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);191 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
199 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);192 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
@@ -201,10 +194,8 @@ TEST_F(l2_triangular_solve_test, case_a_square)
201 194 
202TEST_F(l2_triangular_solve_test, case_matrix_shape)195TEST_F(l2_triangular_solve_test, case_matrix_shape)
203{196{
204- auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND)197+ auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
205- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});198+ auto b_desc = TensorDesc({1, 1, 2, 4}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2});
206- auto b_desc = TensorDesc({1, 1, 2, 4}, ACL_FLOAT, ACL_FORMAT_ND)
207- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2});
208 bool upper = true;199 bool upper = true;
209 bool transpose = false;200 bool transpose = false;
210 bool unitriangular = false;201 bool unitriangular = false;
@@ -212,8 +203,8 @@ TEST_F(l2_triangular_solve_test, case_matrix_shape)
212 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);203 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
213 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);204 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
214 205 
215- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),206+ auto ut =
216- OUTPUT(X_desc, M_desc));207+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
217 uint64_t workspaceSize = 0;208 uint64_t workspaceSize = 0;
218 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);209 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
219 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);210 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
@@ -221,10 +212,9 @@ TEST_F(l2_triangular_solve_test, case_matrix_shape)
221 212 
222TEST_F(l2_triangular_solve_test, case_shape_boardcast_fail)213TEST_F(l2_triangular_solve_test, case_shape_boardcast_fail)
223{214{
224- auto A_desc = TensorDesc({1, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND)215+ auto A_desc = TensorDesc({1, 2, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8});
225- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8});216+ auto b_desc =
226- auto b_desc = TensorDesc({1, 3, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND)217+ TensorDesc({1, 3, 2, 2}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
227- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
228 bool upper = true;218 bool upper = true;
229 bool transpose = false;219 bool transpose = false;
230 bool unitriangular = false;220 bool unitriangular = false;
@@ -232,8 +222,8 @@ TEST_F(l2_triangular_solve_test, case_shape_boardcast_fail)
232 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);222 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
233 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);223 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
234 224 
235- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),225+ auto ut =
236- OUTPUT(X_desc, M_desc));226+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
237 uint64_t workspaceSize = 0;227 uint64_t workspaceSize = 0;
238 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);228 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
239 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);229 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
@@ -241,10 +231,9 @@ TEST_F(l2_triangular_solve_test, case_shape_boardcast_fail)
241 231 
242TEST_F(l2_triangular_solve_test, case_shape_boardcast_succ)232TEST_F(l2_triangular_solve_test, case_shape_boardcast_succ)
243{233{
244- auto A_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND)234+ auto A_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
245- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});235+ auto b_desc =
246- auto b_desc = TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND)236+ TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
247- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
248 bool upper = true;237 bool upper = true;
249 bool transpose = false;238 bool transpose = false;
250 bool unitriangular = false;239 bool unitriangular = false;
@@ -252,8 +241,8 @@ TEST_F(l2_triangular_solve_test, case_shape_boardcast_succ)
252 auto X_desc = TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);241 auto X_desc = TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);
253 auto M_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);242 auto M_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);
254 243 
255- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),244+ auto ut =
256- OUTPUT(X_desc, M_desc));245+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
257 uint64_t workspaceSize = 0;246 uint64_t workspaceSize = 0;
258 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);247 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
259 EXPECT_EQ(aclRet, ACLNN_SUCCESS);248 EXPECT_EQ(aclRet, ACLNN_SUCCESS);
@@ -261,10 +250,9 @@ TEST_F(l2_triangular_solve_test, case_shape_boardcast_succ)
261 250 
262TEST_F(l2_triangular_solve_test, case_shape_boardcast_out_fail)251TEST_F(l2_triangular_solve_test, case_shape_boardcast_out_fail)
263{252{
264- auto A_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND)253+ auto A_desc = TensorDesc({3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
265- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});254+ auto b_desc =
266- auto b_desc = TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND)255+ TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
267- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
268 bool upper = true;256 bool upper = true;
269 bool transpose = false;257 bool transpose = false;
270 bool unitriangular = false;258 bool unitriangular = false;
@@ -272,8 +260,8 @@ TEST_F(l2_triangular_solve_test, case_shape_boardcast_out_fail)
272 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);260 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
273 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);261 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
274 262 
275- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),263+ auto ut =
276- OUTPUT(X_desc, M_desc));264+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
277 uint64_t workspaceSize = 0;265 uint64_t workspaceSize = 0;
278 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);266 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
279 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);267 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
@@ -282,8 +270,8 @@ TEST_F(l2_triangular_solve_test, case_shape_boardcast_out_fail)
282TEST_F(l2_triangular_solve_test, case_empty)270TEST_F(l2_triangular_solve_test, case_empty)
283{271{
284 auto A_desc = TensorDesc({1, 0, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND);272 auto A_desc = TensorDesc({1, 0, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND);
285- auto b_desc = TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND)273+ auto b_desc =
286- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}); 274+ TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
287 bool upper = true;275 bool upper = true;
288 bool transpose = false;276 bool transpose = false;
289 bool unitriangular = false;277 bool unitriangular = false;
@@ -291,8 +279,8 @@ TEST_F(l2_triangular_solve_test, case_empty)
291 auto X_desc = TensorDesc({1, 0, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);279 auto X_desc = TensorDesc({1, 0, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);
292 auto M_desc = TensorDesc({1, 0, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);280 auto M_desc = TensorDesc({1, 0, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Precision(0.0001, 0.0001);
293 281 
294- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),282+ auto ut =
295- OUTPUT(X_desc, M_desc));283+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
296 uint64_t workspaceSize = 0;284 uint64_t workspaceSize = 0;
297 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);285 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
298 EXPECT_EQ(aclRet, ACLNN_SUCCESS);286 EXPECT_EQ(aclRet, ACLNN_SUCCESS);
@@ -300,10 +288,9 @@ TEST_F(l2_triangular_solve_test, case_empty)
300 288 
301TEST_F(l2_triangular_solve_test, case_transpose_true)289TEST_F(l2_triangular_solve_test, case_transpose_true)
302{290{
303- auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND)291+ auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
304- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});292+ auto b_desc =
305- auto b_desc = TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND)293+ TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
306- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
307 bool upper = true;294 bool upper = true;
308 bool transpose = true;295 bool transpose = true;
309 bool unitriangular = false;296 bool unitriangular = false;
@@ -311,8 +298,8 @@ TEST_F(l2_triangular_solve_test, case_transpose_true)
311 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);298 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
312 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);299 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
313 300 
314- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),301+ auto ut =
315- OUTPUT(X_desc, M_desc));302+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
316 uint64_t workspaceSize = 0;303 uint64_t workspaceSize = 0;
317 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);304 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
318 EXPECT_EQ(aclRet, ACLNN_SUCCESS);305 EXPECT_EQ(aclRet, ACLNN_SUCCESS);
@@ -320,10 +307,9 @@ TEST_F(l2_triangular_solve_test, case_transpose_true)
320 307 
321TEST_F(l2_triangular_solve_test, case_unitriangular_true)308TEST_F(l2_triangular_solve_test, case_unitriangular_true)
322{309{
323- auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND)310+ auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
324- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});311+ auto b_desc =
325- auto b_desc = TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND)312+ TensorDesc({1, 1, 3, 4}, ACL_FLOAT, ACL_FORMAT_ND).Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
326- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
327 bool upper = true;313 bool upper = true;
328 bool transpose = false;314 bool transpose = false;
329 bool unitriangular = true;315 bool unitriangular = true;
@@ -331,8 +317,8 @@ TEST_F(l2_triangular_solve_test, case_unitriangular_true)
331 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);317 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
332 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);318 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
333 319 
334- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),320+ auto ut =
335- OUTPUT(X_desc, M_desc));321+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
336 uint64_t workspaceSize = 0;322 uint64_t workspaceSize = 0;
337 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);323 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
338 EXPECT_EQ(aclRet, ACLNN_SUCCESS);324 EXPECT_EQ(aclRet, ACLNN_SUCCESS);
@@ -340,10 +326,9 @@ TEST_F(l2_triangular_solve_test, case_unitriangular_true)
340 326 
341TEST_F(l2_triangular_solve_test, case_unitriangular_faile)327TEST_F(l2_triangular_solve_test, case_unitriangular_faile)
342{328{
343- auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_DOUBLE, ACL_FORMAT_ND)329+ auto A_desc = TensorDesc({1, 1, 3, 3}, ACL_DOUBLE, ACL_FORMAT_ND).Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});
344- .Value(vector<float>{1, 2, 3, 4, 5, 6, 7, 8, 9});330+ auto b_desc =
345- auto b_desc = TensorDesc({1, 1, 3, 4}, ACL_DOUBLE, ACL_FORMAT_ND)331+ TensorDesc({1, 1, 3, 4}, ACL_DOUBLE, ACL_FORMAT_ND).Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
346- .Value(vector<float>{2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
347 bool upper = true;332 bool upper = true;
348 bool transpose = false;333 bool transpose = false;
349 bool unitriangular = true;334 bool unitriangular = true;
@@ -351,15 +336,9 @@ TEST_F(l2_triangular_solve_test, case_unitriangular_faile)
351 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);336 auto X_desc = TensorDesc(b_desc).Precision(0.0001, 0.0001);
352 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);337 auto M_desc = TensorDesc(A_desc).Precision(0.0001, 0.0001);
353 338 
354- auto ut = OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular),339+ auto ut =
355- OUTPUT(X_desc, M_desc));340+ OP_API_UT(aclnnTriangularSolve, INPUT(b_desc, A_desc, upper, transpose, unitriangular), OUTPUT(X_desc, M_desc));
356 uint64_t workspaceSize = 0;341 uint64_t workspaceSize = 0;
357 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);342 aclnnStatus aclRet = ut.TestGetWorkspaceSize(&workspaceSize);
358 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);343 EXPECT_EQ(aclRet, ACLNN_ERR_PARAM_INVALID);
359}344}
360- 
361- 
362- 
363- 
364- 
365-