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: 28 MindDataTestTensorRowDE() {} 29 void SetUp() { GlobalInit(); } 30 }; 31 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 220 TEST_F(MindDataTestTensorRowDE, ConvertFromTensorRowEmptyInputTest) { 221 TensorRow input_tensor_row; 222 double output; 223 ASSERT_FALSE(TensorRow::ConvertFromTensorRow(input_tensor_row, &output).IsOk()); 224 }