/
akulovz
/
FreeCAD
GigaCode
beta
ОбзорЦентр заботыВойти

FreeCAD

Форк
0
Ветки: 15Коммиты: 38768Теги: 27
FreeCAD
/tests
/src
/Mod
/Material
/App
/
TestMaterialValue.cpp 
286 строк · 10.8 Кб
1
// SPDX-License-Identifier: LGPL-2.1-or-later
2
/***************************************************************************
3
 *   Copyright (c) 2023 David Carter <dcarter@david.carter.ca>             *
4
 *                                                                         *
5
 *   This file is part of FreeCAD.                                         *
6
 *                                                                         *
7
 *   FreeCAD is free software: you can redistribute it and/or modify it    *
8
 *   under the terms of the GNU Lesser General Public License as           *
9
 *   published by the Free Software Foundation, either version 2.1 of the  *
10
 *   License, or (at your option) any later version.                       *
11
 *                                                                         *
12
 *   FreeCAD is distributed in the hope that it will be useful, but        *
13
 *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
14
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      *
15
 *   Lesser General Public License for more details.                       *
16
 *                                                                         *
17
 *   You should have received a copy of the GNU Lesser General Public      *
18
 *   License along with FreeCAD. If not, see                               *
19
 *   <https://www.gnu.org/licenses/>.                                      *
20
 *                                                                         *
21
 **************************************************************************/
22


23
#include <gtest/gtest.h>
24


25
#include <Mod/Material/App/PreCompiled.h>
26
#ifndef _PreComp_
27
#endif
28


29
#include <QMetaType>
30
#include <QString>
31


32
#include <App/Application.h>
33
#include <Gui/MetaTypes.h>
34


35
#include <Mod/Material/App/MaterialManager.h>
36
#include <Mod/Material/App/Model.h>
37
#include <Mod/Material/App/ModelManager.h>
38
#include <Mod/Material/App/ModelUuids.h>
39


40
// clang-format off
41


42
class TestMaterialValue : public ::testing::Test {
43
 protected:
44
  static void SetUpTestSuite() {
45
  }
46
};
47


48
TEST_F(TestMaterialValue, TestNoneType)
49
{
50
    auto mat1 = Materials::MaterialValue();
51
    EXPECT_EQ(mat1.getType(), Materials::MaterialValue::None);
52
    EXPECT_TRUE(mat1.isNull());
53
    auto variant = mat1.getValue();
54
    EXPECT_TRUE(variant.isNull());
55
    EXPECT_FALSE(variant.canConvert<QString>());
56
    EXPECT_TRUE(variant.toString().isNull());
57
    EXPECT_TRUE(variant.toString().isEmpty());
58
    EXPECT_EQ(variant.toString().size(), 0);
59
}
60


61
TEST_F(TestMaterialValue, TestStringType)
62
{
63
    auto mat1 = Materials::MaterialValue(Materials::MaterialValue::String);
64
    EXPECT_EQ(mat1.getType(), Materials::MaterialValue::String);
65
    EXPECT_TRUE(mat1.isNull());
66
    auto variant = mat1.getValue();
67
    EXPECT_TRUE(variant.isNull());
68
    EXPECT_TRUE(variant.canConvert<QString>());
69
    EXPECT_TRUE(variant.toString().isNull());
70
    EXPECT_TRUE(variant.toString().isEmpty());
71
    EXPECT_EQ(variant.toString().size(), 0);
72
}
73


74
TEST_F(TestMaterialValue, TestBooleanType)
75
{
76
    auto mat1 = Materials::MaterialValue(Materials::MaterialValue::Boolean);
77
    EXPECT_EQ(mat1.getType(), Materials::MaterialValue::Boolean);
78
    EXPECT_TRUE(mat1.isNull());
79
    auto variant = mat1.getValue();
80
    EXPECT_TRUE(variant.isNull());
81
    EXPECT_TRUE(variant.canConvert<bool>());
82
    EXPECT_FALSE(variant.toString().isNull());
83
    EXPECT_FALSE(variant.toString().isEmpty());
84
    EXPECT_EQ(variant.toString().size(), 5);
85
    EXPECT_EQ(variant.toString(), QString::fromStdString("false"));
86
    EXPECT_EQ(variant.toBool(), false);
87
}
88


89
TEST_F(TestMaterialValue, TestIntegerType)
90
{
91
    auto mat1 = Materials::MaterialValue(Materials::MaterialValue::Integer);
92
    EXPECT_EQ(mat1.getType(), Materials::MaterialValue::Integer);
93
    EXPECT_TRUE(mat1.isNull());
94
    auto variant = mat1.getValue();
95
    EXPECT_TRUE(variant.isNull());
96
    EXPECT_TRUE(variant.canConvert<int>());
97
    EXPECT_FALSE(variant.toString().isNull());
98
    EXPECT_FALSE(variant.toString().isEmpty());
99
    EXPECT_EQ(variant.toString().size(), 1);
100
    EXPECT_EQ(variant.toString(), QString::fromStdString("0"));
101
    EXPECT_EQ(variant.toInt(), 0);
102
}
103


104
TEST_F(TestMaterialValue, TestFloatType)
105
{
106
    auto mat1 = Materials::MaterialValue(Materials::MaterialValue::Float);
107
    EXPECT_EQ(mat1.getType(), Materials::MaterialValue::Float);
108
    EXPECT_TRUE(mat1.isNull());
109
    auto variant = mat1.getValue();
110
    EXPECT_TRUE(variant.isNull());
111
    EXPECT_TRUE(variant.canConvert<float>());
112
    EXPECT_FALSE(variant.toString().isNull());
113
    EXPECT_FALSE(variant.toString().isEmpty());
114
    EXPECT_EQ(variant.toString().size(), 1);
115
    EXPECT_EQ(variant.toString(), QString::fromStdString("0"));
116
    EXPECT_EQ(variant.toFloat(), 0);
117
}
118


119
TEST_F(TestMaterialValue, TestQuantityType)
120
{
121
    auto mat1 = Materials::MaterialValue(Materials::MaterialValue::Quantity);
122
    EXPECT_EQ(mat1.getType(), Materials::MaterialValue::Quantity);
123
    EXPECT_TRUE(mat1.isNull());
124


125
    auto variant = mat1.getValue();
126
    EXPECT_FALSE(variant.isNull());
127
    EXPECT_TRUE(variant.canConvert<Base::Quantity>());
128
    EXPECT_TRUE(variant.toString().isNull());
129
    EXPECT_TRUE(variant.toString().isEmpty());
130
    EXPECT_EQ(variant.toString().size(), 0);
131
    auto quantity = variant.value<Base::Quantity>();
132
    EXPECT_FALSE(quantity.isValid());
133
    EXPECT_EQ(quantity.getUserString(), QString::fromStdString("nan "));
134
    EXPECT_TRUE(std::isnan(quantity.getValue()));
135


136
    // Test a copy
137
    auto mat2 = Materials::MaterialValue(mat1);
138
    EXPECT_EQ(mat2.getType(), Materials::MaterialValue::Quantity);
139
    EXPECT_TRUE(mat2.isNull());
140


141
    variant = mat2.getValue();
142
    EXPECT_FALSE(variant.isNull());
143
    EXPECT_TRUE(variant.canConvert<Base::Quantity>());
144
    EXPECT_TRUE(variant.toString().isNull());
145
    EXPECT_TRUE(variant.toString().isEmpty());
146
    EXPECT_EQ(variant.toString().size(), 0);
147
    quantity = variant.value<Base::Quantity>();
148
    EXPECT_FALSE(quantity.isValid());
149
    EXPECT_EQ(quantity.getUserString(), QString::fromStdString("nan "));
150
    EXPECT_TRUE(std::isnan(quantity.getValue()));
151
}
152


153
TEST_F(TestMaterialValue, TestListType)
154
{
155
    auto mat1 = Materials::MaterialValue(Materials::MaterialValue::List);
156
    EXPECT_EQ(mat1.getType(), Materials::MaterialValue::List);
157
    EXPECT_TRUE(mat1.isNull());
158
    auto variant = mat1.getValue();
159
    EXPECT_TRUE(variant.value<QList<QVariant>>().isEmpty());
160
    EXPECT_EQ(variant.value<QList<QVariant>>().size(), 0);
161
    EXPECT_FALSE(variant.isNull());
162
    EXPECT_FALSE(variant.canConvert<QVariant>());
163
    EXPECT_TRUE(variant.toString().isNull());
164
    EXPECT_TRUE(variant.toString().isEmpty());
165
    EXPECT_EQ(variant.toString().size(), 0);
166
    auto list = mat1.getList();
167
    EXPECT_TRUE(list.isEmpty());
168
    EXPECT_EQ(list.size(), 0);
169
}
170


171
TEST_F(TestMaterialValue, TestArray2DType)
172
{
173
    EXPECT_THROW(auto mat1 = Materials::MaterialValue(Materials::MaterialValue::Array2D), Materials::InvalidMaterialType);
174


175
    auto mat2 = Materials::Material2DArray();
176
    EXPECT_EQ(mat2.getType(), Materials::MaterialValue::Array2D);
177
    EXPECT_TRUE(mat2.isNull());
178
    EXPECT_EQ(mat2.rows(), 0);
179
}
180


181
TEST_F(TestMaterialValue, TestArray3DType)
182
{
183
    EXPECT_THROW(auto mat1 = Materials::MaterialValue(Materials::MaterialValue::Array3D), Materials::InvalidMaterialType);
184


185
    auto mat2 = Materials::Material3DArray();
186
    mat2.setColumns(2);
187
    EXPECT_EQ(mat2.getType(), Materials::MaterialValue::Array3D);
188
    EXPECT_TRUE(mat2.isNull());
189


190
    EXPECT_EQ(mat2.depth(), 0);
191
    EXPECT_EQ(mat2.rows(), 0);
192
    EXPECT_EQ(mat2.rows(0), 0);
193
    EXPECT_THROW(mat2.rows(1), Materials::InvalidIndex);
194


195
    Base::Quantity quantity;
196
    quantity.setInvalid();
197


198
    EXPECT_EQ(mat2.addDepth(0, quantity), 0);
199
    EXPECT_EQ(mat2.depth(), 1);
200
    EXPECT_EQ(mat2.rows(0), 0);
201
    EXPECT_THROW(mat2.rows(1), Materials::InvalidIndex);
202


203
    EXPECT_EQ(mat2.addDepth(quantity), 1);
204
    EXPECT_EQ(mat2.depth(), 2);
205
    EXPECT_EQ(mat2.rows(1), 0);
206


207
    EXPECT_THROW(mat2.addDepth(99, quantity), Materials::InvalidIndex);
208
    EXPECT_EQ(mat2.addDepth(2, quantity), 2);
209
    EXPECT_EQ(mat2.depth(), 3);
210
    EXPECT_EQ(mat2.rows(2), 0);
211


212
    // Add rows
213
    auto row = std::make_shared<QList<Base::Quantity>>();
214
    row->push_back(quantity);
215
    row->push_back(quantity);
216


217
    EXPECT_EQ(mat2.rows(0), 0);
218
    EXPECT_EQ(mat2.rows(1), 0);
219
    EXPECT_EQ(mat2.rows(2), 0);
220


221
    mat2.addRow(0, row);
222
    EXPECT_EQ(mat2.rows(0), 1);
223
    EXPECT_EQ(mat2.rows(1), 0);
224
    EXPECT_EQ(mat2.rows(2), 0);
225


226
    mat2.addRow(1, row);
227
    EXPECT_EQ(mat2.rows(0), 1);
228
    EXPECT_EQ(mat2.rows(1), 1);
229
    EXPECT_EQ(mat2.rows(2), 0);
230


231
    mat2.addRow(2, row);
232
    EXPECT_EQ(mat2.rows(0), 1);
233
    EXPECT_EQ(mat2.rows(1), 1);
234
    EXPECT_EQ(mat2.rows(2), 1);
235


236
    EXPECT_EQ(mat2.currentDepth(), 0);
237
    mat2.addRow(row);
238
    EXPECT_EQ(mat2.rows(0), 2);
239
    EXPECT_EQ(mat2.rows(1), 1);
240
    EXPECT_EQ(mat2.rows(2), 1);
241


242
    mat2.setCurrentDepth(2);
243
    EXPECT_EQ(mat2.currentDepth(), 2);
244
    mat2.addRow(row);
245
    EXPECT_EQ(mat2.rows(0), 2);
246
    EXPECT_EQ(mat2.rows(1), 1);
247
    EXPECT_EQ(mat2.rows(2), 2);
248


249
    quantity = Base::Quantity::parse(QString::fromStdString("32 C"));
250
    mat2.setDepthValue(quantity);
251
    EXPECT_FALSE(mat2.getDepthValue(0).isValid());
252
    EXPECT_FALSE(mat2.getDepthValue(1).isValid());
253
    EXPECT_TRUE(mat2.getDepthValue(2).isValid());
254
    EXPECT_EQ(mat2.getDepthValue(2), Base::Quantity::parse(QString::fromStdString("32 C")));
255


256
    mat2.setDepthValue(0, Base::Quantity::parse(QString::fromStdString("9.8 m/s/s")));
257
    EXPECT_TRUE(mat2.getDepthValue(0).isValid());
258
    EXPECT_FALSE(mat2.getDepthValue(1).isValid());
259
    EXPECT_TRUE(mat2.getDepthValue(2).isValid());
260
    EXPECT_EQ(mat2.getDepthValue(0), Base::Quantity::parse(QString::fromStdString("9.8 m/s/s")));
261
    EXPECT_EQ(mat2.getDepthValue(2), Base::Quantity::parse(QString::fromStdString("32 C")));
262


263
    mat2.setDepthValue(1, Base::Quantity::parse(QString::fromStdString("120 MPa")));
264
    EXPECT_TRUE(mat2.getDepthValue(0).isValid());
265
    EXPECT_TRUE(mat2.getDepthValue(1).isValid());
266
    EXPECT_TRUE(mat2.getDepthValue(2).isValid());
267
    EXPECT_EQ(mat2.getDepthValue(0), Base::Quantity::parse(QString::fromStdString("9.8 m/s/s")));
268
    EXPECT_EQ(mat2.getDepthValue(1), Base::Quantity::parse(QString::fromStdString("120 MPa")));
269
    EXPECT_EQ(mat2.getDepthValue(2), Base::Quantity::parse(QString::fromStdString("32 C")));
270


271
    // Rows are currently empty
272
    EXPECT_THROW(mat2.getValue(2, 0), Materials::InvalidIndex);
273
    EXPECT_NO_THROW(mat2.getValue(0, 0));
274
    EXPECT_FALSE(mat2.getValue(0, 0).isValid());
275
    EXPECT_FALSE(mat2.getValue(0, 1).isValid());
276


277
    // set to a valid quantity
278
    mat2.setValue(0, 0, Base::Quantity::parse(QString::fromStdString("120 MPa")));
279
    EXPECT_TRUE(mat2.getValue(0, 0).isValid());
280
    mat2.setValue(0, 1, Base::Quantity::parse(QString::fromStdString("9.8 m/s/s")));
281
    EXPECT_TRUE(mat2.getValue(0, 1).isValid());
282
    EXPECT_THROW(mat2.setValue(0, 2, Base::Quantity::parse(QString::fromStdString("32 C"))), Materials::InvalidIndex);
283


284
}
285


286
// clang-format on
287

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.