1 /**
2 * Copyright 2020 Huawei Technologies Co., Ltd
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "minddata/dataset/core/client.h"
17 #include "common/common.h"
18 #include "gtest/gtest.h"
19 #include "minddata/dataset/core/tensor.h"
20 #include "minddata/dataset/core/tensor_row.h"
21
22 using namespace mindspore::dataset;
23
24 namespace py = pybind11;
25
26 class MindDataTestTensorRowDE : public UT::Common {
27 public:
MindDataTestTensorRowDE()28 MindDataTestTensorRowDE() {}
SetUp()29 void SetUp() { GlobalInit(); }
30 };
31
TEST_F(MindDataTestTensorRowDE,ConvertToTensorRowBoolTest)32 TEST_F(MindDataTestTensorRowDE, ConvertToTensorRowBoolTest) {
33 Status s;
34
35 TensorRow bool_output;
36 bool bool_value = true;
37 s = TensorRow::ConvertToTensorRow(bool_value, &bool_output);
38 ASSERT_EQ(s, Status::OK());
39 TensorRow expected_bool;
40 std::shared_ptr<Tensor> expected_tensor;
41 Tensor::CreateScalar(bool_value, &expected_tensor);
42 expected_bool.push_back(expected_tensor);
43 ASSERT_EQ(*(bool_output.at(0)) == *(expected_bool.at(0)), true);
44 }
45
TEST_F(MindDataTestTensorRowDE,ConvertToTensorRowIntTest)46 TEST_F(MindDataTestTensorRowDE, ConvertToTensorRowIntTest) {
47 Status s;
48 TensorRow int_output;
49 int32_t int_value = 12;
50 TensorRow expected_int;
51 s = TensorRow::ConvertToTensorRow(int_value, &int_output);
52 ASSERT_EQ(s, Status::OK());
53 std::shared_ptr<Tensor> expected_tensor;
54 Tensor::CreateScalar(int_value, &expected_tensor);
55 expected_int.push_back(expected_tensor);
56 ASSERT_EQ(*(int_output.at(0)) == *(expected_int.at(0)), true);
57 }
58
TEST_F(MindDataTestTensorRowDE,ConvertToTensorRowFloatTest)59 TEST_F(MindDataTestTensorRowDE, ConvertToTensorRowFloatTest) {
60 Status s;
61 TensorRow expected_bool;
62 TensorRow float_output;
63 float float_value = 12.57;
64 TensorRow expected_float;
65 s = TensorRow::ConvertToTensorRow(float_value, &float_output);
66 ASSERT_EQ(s, Status::OK());
67 std::shared_ptr<Tensor> expected_tensor;
68 Tensor::CreateScalar(float_value, &expected_tensor);
69 expected_float.push_back(expected_tensor);
70 ASSERT_EQ(*(float_output.at(0)) == *(expected_float.at(0)), true);
71 }
72
TEST_F(MindDataTestTensorRowDE,ConvertToTensorRowBoolVectorTest)73 TEST_F(MindDataTestTensorRowDE, ConvertToTensorRowBoolVectorTest) {
74 Status s;
75 TensorRow bool_output;
76 std::vector<bool> bool_value = {true, false};
77 s = TensorRow::ConvertToTensorRow(bool_value, &bool_output);
78 ASSERT_EQ(s, Status::OK());
79 TensorRow expected_bool;
80 std::shared_ptr<Tensor> expected_tensor;
81 Tensor::CreateFromVector<bool>(bool_value, &expected_tensor);
82 expected_bool.push_back(expected_tensor);
83 ASSERT_EQ(*(bool_output.at(0)) == *(expected_bool.at(0)), true);
84 }
85
TEST_F(MindDataTestTensorRowDE,ConvertToTensorRowIntVectorTest)86 TEST_F(MindDataTestTensorRowDE, ConvertToTensorRowIntVectorTest) {
87 Status s;
88 TensorRow int_output;
89 std::vector<uint64_t> int_value = {12, 16};
90 TensorRow expected_int;
91 s = TensorRow::ConvertToTensorRow(int_value, &int_output);
92 ASSERT_EQ(s, Status::OK());
93 std::shared_ptr<Tensor> expected_tensor;
94 Tensor::CreateFromVector(int_value, &expected_tensor);
95 expected_int.push_back(expected_tensor);
96 ASSERT_EQ(*(int_output.at(0)) == *(expected_int.at(0)), true);
97 }
98
TEST_F(MindDataTestTensorRowDE,ConvertToTensorRowFloatVectorTest)99 TEST_F(MindDataTestTensorRowDE, ConvertToTensorRowFloatVectorTest) {
100 Status s;
101 TensorRow float_output;
102 std::vector<double> float_value = {12.57, 0.264};
103 TensorRow expected_float;
104 s = TensorRow::ConvertToTensorRow(float_value, &float_output);
105 ASSERT_EQ(s, Status::OK());
106 std::shared_ptr<Tensor> expected_tensor;
107 Tensor::CreateFromVector(float_value, &expected_tensor);
108 expected_float.push_back(expected_tensor);
109 ASSERT_EQ(*(float_output.at(0)) == *(expected_float.at(0)), true);
110 }
111
TEST_F(MindDataTestTensorRowDE,ConvertFromTensorRowBoolTest)112 TEST_F(MindDataTestTensorRowDE, ConvertFromTensorRowBoolTest) {
113 Status s;
114 bool bool_value = true;
115 bool result;
116 TensorRow input_tensor_row;
117 std::shared_ptr<Tensor> input_tensor;
118 Tensor::CreateScalar(bool_value, &input_tensor);
119 input_tensor_row.push_back(input_tensor);
120 s = TensorRow::ConvertFromTensorRow(input_tensor_row, &result);
121 ASSERT_EQ(s, Status::OK());
122 ASSERT_EQ(bool_value, result);
123 }
124
TEST_F(MindDataTestTensorRowDE,ConvertFromTensorRowIntTest)125 TEST_F(MindDataTestTensorRowDE, ConvertFromTensorRowIntTest) {
126 Status s;
127 int32_t int_value = 12;
128 int32_t result;
129 TensorRow input_tensor_row;
130 std::shared_ptr<Tensor> input_tensor;
131 Tensor::CreateScalar(int_value, &input_tensor);
132 input_tensor_row.push_back(input_tensor);
133 s = TensorRow::ConvertFromTensorRow(input_tensor_row, &result);
134 ASSERT_EQ(s, Status::OK());
135 ASSERT_EQ(int_value, result);
136 }
137
TEST_F(MindDataTestTensorRowDE,ConvertFromTensorRowFloatTest)138 TEST_F(MindDataTestTensorRowDE, ConvertFromTensorRowFloatTest) {
139 Status s;
140 float float_value = 12.57;
141 float result;
142 TensorRow input_tensor_row;
143 std::shared_ptr<Tensor> input_tensor;
144 Tensor::CreateScalar(float_value, &input_tensor);
145 input_tensor_row.push_back(input_tensor);
146 s = TensorRow::ConvertFromTensorRow(input_tensor_row, &result);
147 ASSERT_EQ(s, Status::OK());
148 ASSERT_EQ(float_value, result);
149 }
150
TEST_F(MindDataTestTensorRowDE,ConvertFromTensorRowBoolVectorTest)151 TEST_F(MindDataTestTensorRowDE, ConvertFromTensorRowBoolVectorTest) {
152 Status s;
153 std::vector<bool> bool_value = {true, false};
154 std::vector<bool> result;
155 TensorRow input_tensor_row;
156 std::shared_ptr<Tensor> input_tensor;
157 Tensor::CreateFromVector<bool>(bool_value, &input_tensor);
158 input_tensor_row.push_back(input_tensor);
159 s = TensorRow::ConvertFromTensorRow(input_tensor_row, &result);
160 ASSERT_EQ(s, Status::OK());
161 ASSERT_EQ(result, bool_value);
162 }
163
TEST_F(MindDataTestTensorRowDE,ConvertFromTensorRowIntVectorTest)164 TEST_F(MindDataTestTensorRowDE, ConvertFromTensorRowIntVectorTest) {
165 Status s;
166 std::vector<uint64_t> int_value = {12, 16};
167 std::vector<uint64_t> result;
168 TensorRow input_tensor_row;
169 std::shared_ptr<Tensor> input_tensor;
170 Tensor::CreateFromVector(int_value, &input_tensor);
171 input_tensor_row.push_back(input_tensor);
172 s = TensorRow::ConvertFromTensorRow(input_tensor_row, &result);
173 ASSERT_EQ(s, Status::OK());
174 ASSERT_EQ(result, int_value);
175 }
176
TEST_F(MindDataTestTensorRowDE,ConvertFromTensorRowFloatVectorTest)177 TEST_F(MindDataTestTensorRowDE, ConvertFromTensorRowFloatVectorTest) {
178 Status s;
179 std::vector<double> float_value = {12.57, 0.264};
180 std::vector<double> result;
181 TensorRow input_tensor_row;
182 std::shared_ptr<Tensor> input_tensor;
183 Tensor::CreateFromVector(float_value, &input_tensor);
184 input_tensor_row.push_back(input_tensor);
185 s = TensorRow::ConvertFromTensorRow(input_tensor_row, &result);
186 ASSERT_EQ(s, Status::OK());
187 ASSERT_EQ(result, float_value);
188 }
189
TEST_F(MindDataTestTensorRowDE,ConvertToTensorRowInvalidDataTest)190 TEST_F(MindDataTestTensorRowDE, ConvertToTensorRowInvalidDataTest) {
191 TensorRow output;
192 std::string string_input = "Bye";
193 ASSERT_FALSE(TensorRow::ConvertToTensorRow(string_input, &output).IsOk());
194 std::vector<std::string> string_vector_input = {"Hello"};
195 ASSERT_FALSE(TensorRow::ConvertToTensorRow(string_vector_input, &output).IsOk());
196 }
197
TEST_F(MindDataTestTensorRowDE,ConvertFromTensorRowTypeMismatchTest)198 TEST_F(MindDataTestTensorRowDE, ConvertFromTensorRowTypeMismatchTest) {
199 TensorRow input_tensor_row;
200 std::shared_ptr<Tensor> input_tensor1;
201 Tensor::CreateScalar(false, &input_tensor1);
202 input_tensor_row.push_back(input_tensor1);
203 double output;
204 ASSERT_FALSE(TensorRow::ConvertFromTensorRow(input_tensor_row, &output).IsOk());
205 std::vector<double> output_vector;
206 ASSERT_FALSE(TensorRow::ConvertFromTensorRow(input_tensor_row, &output_vector).IsOk());
207 }
208
TEST_F(MindDataTestTensorRowDE,ConvertFromTensorRowInvalidShapeTest)209 TEST_F(MindDataTestTensorRowDE, ConvertFromTensorRowInvalidShapeTest) {
210 TensorRow input_tensor_row;
211 std::shared_ptr<Tensor> input_tensor1;
212 Tensor::CreateEmpty(TensorShape({2, 2}), DataType(DataType::DE_FLOAT64), &input_tensor1);
213 input_tensor_row.push_back(input_tensor1);
214 std::vector<double> output;
215 ASSERT_FALSE(TensorRow::ConvertFromTensorRow(input_tensor_row, &output).IsOk());
216 std::vector<double> output_vector;
217 ASSERT_FALSE(TensorRow::ConvertFromTensorRow(input_tensor_row, &output_vector).IsOk());
218 }
219
TEST_F(MindDataTestTensorRowDE,ConvertFromTensorRowEmptyInputTest)220 TEST_F(MindDataTestTensorRowDE, ConvertFromTensorRowEmptyInputTest) {
221 TensorRow input_tensor_row;
222 double output;
223 ASSERT_FALSE(TensorRow::ConvertFromTensorRow(input_tensor_row, &output).IsOk());
224 }