FreeCAD

TestMaterials.cpp
380 строк · 20.0 Кб
Перенос по словам
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 <QLocale>
30
#include <QMetaType>
31
#include <QString>
32

33
#include <App/Application.h>
34
#include <Base/Quantity.h>
35
#include <Base/Interpreter.h>
36
#include <Gui/MetaTypes.h>
37
#include <src/App/InitApplication.h>
38

39
#include <Mod/Material/App/MaterialManager.h>
40
#include <Mod/Material/App/Model.h>
41
#include <Mod/Material/App/ModelManager.h>
42
#include <Mod/Material/App/ModelUuids.h>
43

44
#ifdef _MSC_VER
45
#pragma warning(disable : 4834)
46
#endif
47

48
// clang-format off
49

50
class TestMaterial : public ::testing::Test {
51
 protected:
52
  static void SetUpTestSuite() {
53
    if (App::Application::GetARGC() == 0) {
54
        tests::initApplication();
55
    }
56
  }
57

58
  void SetUp() override {
59
    Base::Interpreter().runString("import Part");
60
    _modelManager = new Materials::ModelManager();
61
    _materialManager = new Materials::MaterialManager();
62
  }
63

64
  // void TearDown() override {}
65
  Materials::ModelManager* _modelManager;
66
  Materials::MaterialManager* _materialManager;
67
};
68

69
TEST_F(TestMaterial, TestInstallation)
70
{
71
    ASSERT_NE(_modelManager, nullptr);
72

73
    // We should have loaded at least the system library
74
    auto libraries = _materialManager->getMaterialLibraries();
75
    ASSERT_GT(libraries->size(), 0);
76

77
    // We should have at least one material
78
    auto materials = _materialManager->getMaterials();
79
    ASSERT_GT(materials->size(), 0);
80
}
81

82
TEST_F(TestMaterial, TestMaterialsWithModel)
83
{
84
    ASSERT_NE(_materialManager, nullptr);
85

86
    auto materials = _materialManager->materialsWithModel(
87
        QString::fromStdString("f6f9e48c-b116-4e82-ad7f-3659a9219c50")); // IsotropicLinearElastic
88
    EXPECT_GT(materials->size(), 0);
89

90
    auto materialsComplete = _materialManager->materialsWithModelComplete(
91
        QString::fromStdString("f6f9e48c-b116-4e82-ad7f-3659a9219c50"));  // IsotropicLinearElastic
92
    EXPECT_LE(materialsComplete->size(), materials->size());
93

94
    auto materialsLinearElastic = _materialManager->materialsWithModel(
95
        QString::fromStdString("7b561d1d-fb9b-44f6-9da9-56a4f74d7536")); // LinearElastic
96

97
    // All LinearElastic models should be in IsotropicLinearElastic since it is inherited
98
    EXPECT_LE(materialsLinearElastic->size(), materials->size());
99
    for (auto itp : *materialsLinearElastic) {
100
        auto mat = itp.first;
101
        EXPECT_NO_THROW(materials->at(mat));
102
    }
103
}
104

105
TEST_F(TestMaterial, TestMaterialByPath)
106
{
107
    ASSERT_NE(_materialManager, nullptr);
108

109
    auto steel = _materialManager->getMaterialByPath(
110
        QString::fromStdString("Standard/Metal/Steel/CalculiX-Steel.FCMat"),
111
        QString::fromStdString("System"));
112
    EXPECT_NE(&steel, nullptr);
113
    EXPECT_EQ(steel->getName(), QString::fromStdString("CalculiX-Steel"));
114
    EXPECT_EQ(steel->getUUID(), QString::fromStdString("92589471-a6cb-4bbc-b748-d425a17dea7d"));
115

116
    // The same but with a leading '/'
117
    auto steel2 = _materialManager->getMaterialByPath(
118
        QString::fromStdString("/Standard/Metal/Steel/CalculiX-Steel.FCMat"),
119
        QString::fromStdString("System"));
120
    EXPECT_NE(&steel2, nullptr);
121
    EXPECT_EQ(steel2->getName(), QString::fromStdString("CalculiX-Steel"));
122
    EXPECT_EQ(steel2->getUUID(), QString::fromStdString("92589471-a6cb-4bbc-b748-d425a17dea7d"));
123

124
    // Same with the library name as a prefix
125
    auto steel3 = _materialManager->getMaterialByPath(
126
        QString::fromStdString("/System/Standard/Metal/Steel/CalculiX-Steel.FCMat"),
127
        QString::fromStdString("System"));
128
    EXPECT_NE(&steel3, nullptr);
129
    EXPECT_EQ(steel3->getName(), QString::fromStdString("CalculiX-Steel"));
130
    EXPECT_EQ(steel3->getUUID(), QString::fromStdString("92589471-a6cb-4bbc-b748-d425a17dea7d"));
131
}
132

133
TEST_F(TestMaterial, TestAddPhysicalModel)
134
{
135
    // Start with an empty material
136
    Materials::Material material;
137
    auto models = material.getPhysicalModels();
138
    EXPECT_NE(&models, nullptr);
139
    EXPECT_EQ(models->size(), 0);
140

141
    // Add a model
142
    material.addPhysical(Materials::ModelUUIDs::ModelUUID_Electromagnetic_Default);
143
    models = material.getPhysicalModels();
144
    EXPECT_EQ(models->size(), 1);
145

146
    // Add a second model
147
    material.addPhysical(Materials::ModelUUIDs::ModelUUID_Mechanical_LinearElastic);
148
    models = material.getPhysicalModels();
149
    EXPECT_EQ(models->size(), 2);
150

151
    // Add an inherited model
152
    material.addPhysical(Materials::ModelUUIDs::ModelUUID_Mechanical_IsotropicLinearElastic);
153
    models = material.getPhysicalModels();
154
    EXPECT_EQ(models->size(), 2);
155

156
    // Add a super model
157
    material.clearModels();
158
    EXPECT_EQ(models->size(), 0);
159

160
    material.addPhysical(Materials::ModelUUIDs::ModelUUID_Mechanical_IsotropicLinearElastic);
161
    models = material.getPhysicalModels();
162
    EXPECT_EQ(models->size(), 1);
163
    material.addPhysical(Materials::ModelUUIDs::ModelUUID_Mechanical_LinearElastic);
164
    models = material.getPhysicalModels();
165
    EXPECT_EQ(models->size(), 1);
166

167
    // Remove the inherited model
168
    material.removePhysical(Materials::ModelUUIDs::ModelUUID_Mechanical_IsotropicLinearElastic);
169
    models = material.getPhysicalModels();
170
    EXPECT_EQ(models->size(), 1);
171

172
    // Remove the super model
173
    material.removePhysical(Materials::ModelUUIDs::ModelUUID_Mechanical_LinearElastic);
174
    models = material.getPhysicalModels();
175
    EXPECT_EQ(models->size(), 0);
176
}
177

178
TEST_F(TestMaterial, TestAddAppearanceModel)
179
{
180
    // Start with an empty material
181
    Materials::Material material;
182
    auto models = material.getAppearanceModels();
183
    EXPECT_NE(models, nullptr);
184
    EXPECT_EQ(models->size(), 0);
185

186
    // Add a model
187
    material.addAppearance(Materials::ModelUUIDs::ModelUUID_Rendering_Vector);
188
    models = material.getAppearanceModels();
189
    EXPECT_EQ(models->size(), 1);
190

191
    // Add a second model
192
    material.addAppearance(Materials::ModelUUIDs::ModelUUID_Rendering_Advanced);
193
    models = material.getAppearanceModels();
194
    EXPECT_EQ(models->size(), 2);
195

196
    // Add an inherited model
197
    material.addAppearance(Materials::ModelUUIDs::ModelUUID_Rendering_Basic);
198
    models = material.getAppearanceModels();
199
    EXPECT_EQ(models->size(), 2);
200

201
    // Add a super model
202
    material.clearModels();
203
    EXPECT_EQ(models->size(), 0);
204

205
    material.addAppearance(Materials::ModelUUIDs::ModelUUID_Rendering_Basic);
206
    models = material.getAppearanceModels();
207
    EXPECT_EQ(models->size(), 1);
208
    material.addAppearance(Materials::ModelUUIDs::ModelUUID_Rendering_Advanced);
209
    models = material.getAppearanceModels();
210
    EXPECT_EQ(models->size(), 1);
211

212
    // Remove the inherited model
213
    material.removeAppearance(Materials::ModelUUIDs::ModelUUID_Rendering_Basic);
214
    models = material.getAppearanceModels();
215
    EXPECT_EQ(models->size(), 1);
216

217
    // Remove the super model
218
    material.removeAppearance(Materials::ModelUUIDs::ModelUUID_Rendering_Advanced);
219
    models = material.getAppearanceModels();
220
    EXPECT_EQ(models->size(), 0);
221
}
222

223
QString parseQuantity(const char *string)
224
{
225
    QString value = QString::fromStdString(string);
226
    return Base::Quantity::parse(value).getUserString();
227
}
228

229
TEST_F(TestMaterial, TestCalculiXSteel)
230
{
231
    ASSERT_NE(_materialManager, nullptr);
232

233
    auto steel = _materialManager->getMaterial(QString::fromStdString("92589471-a6cb-4bbc-b748-d425a17dea7d"));
234
    EXPECT_EQ(steel->getName(), QString::fromStdString("CalculiX-Steel"));
235
    EXPECT_EQ(steel->getUUID(), QString::fromStdString("92589471-a6cb-4bbc-b748-d425a17dea7d"));
236

237
    EXPECT_TRUE(steel->hasPhysicalModel(Materials::ModelUUIDs::ModelUUID_Mechanical_Density)); // Density
238
    EXPECT_TRUE(steel->hasPhysicalModel(Materials::ModelUUIDs::ModelUUID_Mechanical_IsotropicLinearElastic)); // IsotropicLinearElastic
239
    EXPECT_TRUE(steel->hasPhysicalModel(Materials::ModelUUIDs::ModelUUID_Thermal_Default)); // Thermal
240
    EXPECT_FALSE(steel->hasPhysicalModel(Materials::ModelUUIDs::ModelUUID_Mechanical_LinearElastic)); // Legacy linear elastic - Not in the model
241
    EXPECT_TRUE(steel->hasAppearanceModel(Materials::ModelUUIDs::ModelUUID_Rendering_Basic)); // BasicRendering - inherited from Steel.FCMat
242

243
    EXPECT_TRUE(steel->isPhysicalModelComplete(Materials::ModelUUIDs::ModelUUID_Mechanical_Density)); // Density
244
    EXPECT_FALSE(steel->isPhysicalModelComplete(Materials::ModelUUIDs::ModelUUID_Mechanical_IsotropicLinearElastic)); // IsotropicLinearElastic - incomplete
245
    EXPECT_FALSE(steel->isPhysicalModelComplete(Materials::ModelUUIDs::ModelUUID_Thermal_Default)); // Thermal
246
    EXPECT_FALSE(steel->isPhysicalModelComplete(Materials::ModelUUIDs::ModelUUID_Mechanical_LinearElastic)); // Legacy linear elastic - Not in the model
247
    EXPECT_TRUE(steel->isAppearanceModelComplete(Materials::ModelUUIDs::ModelUUID_Rendering_Basic)); // BasicRendering - inherited from Steel.FCMat
248

249
    EXPECT_TRUE(steel->hasPhysicalProperty(QString::fromStdString("Density")));
250
    EXPECT_TRUE(steel->hasPhysicalProperty(QString::fromStdString("BulkModulus")));
251
    EXPECT_TRUE(steel->hasPhysicalProperty(QString::fromStdString("PoissonRatio")));
252
    EXPECT_TRUE(steel->hasPhysicalProperty(QString::fromStdString("YoungsModulus")));
253
    EXPECT_TRUE(steel->hasPhysicalProperty(QString::fromStdString("ShearModulus")));
254
    EXPECT_TRUE(steel->hasPhysicalProperty(QString::fromStdString("SpecificHeat")));
255
    EXPECT_TRUE(steel->hasPhysicalProperty(QString::fromStdString("ThermalConductivity")));
256
    EXPECT_TRUE(steel->hasPhysicalProperty(QString::fromStdString("ThermalExpansionCoefficient")));
257
    EXPECT_TRUE(steel->hasAppearanceProperty(QString::fromStdString("AmbientColor")));
258
    EXPECT_TRUE(steel->hasAppearanceProperty(QString::fromStdString("DiffuseColor")));
259
    EXPECT_TRUE(steel->hasAppearanceProperty(QString::fromStdString("EmissiveColor")));
260
    EXPECT_TRUE(steel->hasAppearanceProperty(QString::fromStdString("Shininess")));
261
    EXPECT_TRUE(steel->hasAppearanceProperty(QString::fromStdString("SpecularColor")));
262
    EXPECT_TRUE(steel->hasAppearanceProperty(QString::fromStdString("Transparency")));
263

264
    auto& properties = steel->getPhysicalProperties();
265
    EXPECT_NO_THROW(properties.at(QString::fromStdString("Density")));
266
    EXPECT_NO_THROW(properties.at(QString::fromStdString("BulkModulus"))); // This is different from the Python behaviour
267
    EXPECT_NO_THROW(properties.at(QString::fromStdString("PoissonRatio")));
268
    EXPECT_NO_THROW(properties.at(QString::fromStdString("YoungsModulus")));
269
    EXPECT_NO_THROW(properties.at(QString::fromStdString("ShearModulus")));
270
    EXPECT_NO_THROW(properties.at(QString::fromStdString("SpecificHeat")));
271
    EXPECT_NO_THROW(properties.at(QString::fromStdString("ThermalConductivity")));
272
    EXPECT_NO_THROW(properties.at(QString::fromStdString("ThermalExpansionCoefficient")));
273
    EXPECT_THROW(properties.at(QString::fromStdString("AmbientColor")), std::out_of_range);
274
    EXPECT_THROW(properties.at(QString::fromStdString("DiffuseColor")), std::out_of_range);
275
    EXPECT_THROW(properties.at(QString::fromStdString("EmissiveColor")), std::out_of_range);
276
    EXPECT_THROW(properties.at(QString::fromStdString("Shininess")), std::out_of_range);
277
    EXPECT_THROW(properties.at(QString::fromStdString("SpecularColor")), std::out_of_range);
278
    EXPECT_THROW(properties.at(QString::fromStdString("Transparency")), std::out_of_range);
279

280
    auto& properties1 = steel->getAppearanceProperties();
281
    EXPECT_THROW(properties1.at(QString::fromStdString("Density")), std::out_of_range);
282
    EXPECT_THROW(properties1.at(QString::fromStdString("BulkModulus")), std::out_of_range);
283
    EXPECT_THROW(properties1.at(QString::fromStdString("PoissonRatio")), std::out_of_range);
284
    EXPECT_THROW(properties1.at(QString::fromStdString("YoungsModulus")), std::out_of_range);
285
    EXPECT_THROW(properties1.at(QString::fromStdString("ShearModulus")), std::out_of_range);
286
    EXPECT_THROW(properties1.at(QString::fromStdString("SpecificHeat")), std::out_of_range);
287
    EXPECT_THROW(properties1.at(QString::fromStdString("ThermalConductivity")), std::out_of_range);
288
    EXPECT_THROW(properties1.at(QString::fromStdString("ThermalExpansionCoefficient")), std::out_of_range);
289
    EXPECT_NO_THROW(properties1.at(QString::fromStdString("AmbientColor")));
290
    EXPECT_NO_THROW(properties1.at(QString::fromStdString("DiffuseColor")));
291
    EXPECT_NO_THROW(properties1.at(QString::fromStdString("EmissiveColor")));
292
    EXPECT_NO_THROW(properties1.at(QString::fromStdString("Shininess")));
293
    EXPECT_NO_THROW(properties1.at(QString::fromStdString("SpecularColor")));
294
    EXPECT_NO_THROW(properties1.at(QString::fromStdString("Transparency")));
295

296
    EXPECT_FALSE(properties[QString::fromStdString("Density")]->isNull());
297
    EXPECT_TRUE(properties[QString::fromStdString("BulkModulus")]->isNull());
298
    EXPECT_FALSE(properties[QString::fromStdString("PoissonRatio")]->isNull());
299
    EXPECT_FALSE(properties[QString::fromStdString("YoungsModulus")]->isNull());
300
    EXPECT_TRUE(properties[QString::fromStdString("ShearModulus")]->isNull());
301
    EXPECT_FALSE(properties[QString::fromStdString("SpecificHeat")]->isNull());
302
    EXPECT_FALSE(properties[QString::fromStdString("ThermalConductivity")]->isNull());
303
    EXPECT_FALSE(properties[QString::fromStdString("ThermalExpansionCoefficient")]->isNull());
304
    EXPECT_FALSE(properties1[QString::fromStdString("AmbientColor")]->isNull());
305
    EXPECT_FALSE(properties1[QString::fromStdString("DiffuseColor")]->isNull());
306
    EXPECT_FALSE(properties1[QString::fromStdString("EmissiveColor")]->isNull());
307
    EXPECT_FALSE(properties1[QString::fromStdString("Shininess")]->isNull());
308
    EXPECT_FALSE(properties1[QString::fromStdString("SpecularColor")]->isNull());
309
    EXPECT_FALSE(properties1[QString::fromStdString("Transparency")]->isNull());
310

311
    QLocale locale;
312
    EXPECT_EQ(properties[QString::fromStdString("Density")]->getString(), parseQuantity("7900.00 kg/m^3"));
313
    EXPECT_EQ(properties[QString::fromStdString("PoissonRatio")]->getString(), locale.toString(0.3));
314
    EXPECT_EQ(properties[QString::fromStdString("YoungsModulus")]->getString(), parseQuantity("210.00 GPa"));
315
    EXPECT_EQ(properties[QString::fromStdString("SpecificHeat")]->getString(), parseQuantity("590.00 J/kg/K"));
316
    EXPECT_EQ(properties[QString::fromStdString("ThermalConductivity")]->getString(), parseQuantity("43.00 W/m/K"));
317
    EXPECT_EQ(properties[QString::fromStdString("ThermalExpansionCoefficient")]->getString(), parseQuantity("12.00 µm/m/K"));
318
    EXPECT_EQ(properties1[QString::fromStdString("AmbientColor")]->getString(), QString::fromStdString("(0.0020, 0.0020, 0.0020, 1.0)"));
319
    EXPECT_EQ(properties1[QString::fromStdString("DiffuseColor")]->getString(), QString::fromStdString("(0.0000, 0.0000, 0.0000, 1.0)"));
320
    EXPECT_EQ(properties1[QString::fromStdString("EmissiveColor")]->getString(), QString::fromStdString("(0.0000, 0.0000, 0.0000, 1.0)"));
321
    EXPECT_EQ(properties1[QString::fromStdString("Shininess")]->getString(), locale.toString(0.06));
322
    EXPECT_EQ(properties1[QString::fromStdString("SpecularColor")]->getString(), QString::fromStdString("(0.9800, 0.9800, 0.9800, 1.0)"));
323
    EXPECT_EQ(properties1[QString::fromStdString("Transparency")]->getString(), QString::fromStdString("0"));
324

325
    EXPECT_TRUE(properties[QString::fromStdString("BulkModulus")]->getString().isEmpty());
326
    EXPECT_TRUE(properties[QString::fromStdString("ShearModulus")]->getString().isEmpty());
327

328
    // These are the preferred method of access
329
    //
330
    EXPECT_DOUBLE_EQ(steel->getPhysicalQuantity(QString::fromStdString("Density")).getValue(), 7.9e-06);
331
    EXPECT_NEAR(steel->getPhysicalValue(QString::fromStdString("PoissonRatio")).toDouble(), 0.3, 1e-6);
332
    EXPECT_DOUBLE_EQ(steel->getPhysicalQuantity(QString::fromStdString("YoungsModulus")).getValue(), 210000000.0);
333
    EXPECT_DOUBLE_EQ(steel->getPhysicalQuantity(QString::fromStdString("SpecificHeat")).getValue(), 590000000.0);
334
    EXPECT_DOUBLE_EQ(steel->getPhysicalQuantity(QString::fromStdString("ThermalConductivity")).getValue(), 43000.0);
335
    EXPECT_DOUBLE_EQ(steel->getPhysicalQuantity(QString::fromStdString("ThermalExpansionCoefficient")).getValue(), 1.2e-05);
336
    EXPECT_EQ(steel->getAppearanceValue(QString::fromStdString("AmbientColor")), QString::fromStdString("(0.0020, 0.0020, 0.0020, 1.0)"));
337
    EXPECT_EQ(steel->getAppearanceValue(QString::fromStdString("DiffuseColor")), QString::fromStdString("(0.0000, 0.0000, 0.0000, 1.0)"));
338
    EXPECT_EQ(steel->getAppearanceValue(QString::fromStdString("EmissiveColor")), QString::fromStdString("(0.0000, 0.0000, 0.0000, 1.0)"));
339
    EXPECT_NEAR(steel->getAppearanceValue(QString::fromStdString("Shininess")).toDouble(), 0.06, 1e-6);
340
    EXPECT_EQ(steel->getAppearanceValue(QString::fromStdString("SpecularColor")), QString::fromStdString("(0.9800, 0.9800, 0.9800, 1.0)"));
341
    EXPECT_DOUBLE_EQ(steel->getAppearanceValue(QString::fromStdString("Transparency")).toDouble(), 0.0);
342

343
    EXPECT_EQ(steel->getPhysicalQuantity(QString::fromStdString("Density")).getUserString(), parseQuantity("7900.00 kg/m^3"));
344
    EXPECT_EQ(steel->getPhysicalQuantity(QString::fromStdString("YoungsModulus")).getUserString(), parseQuantity("210.00 GPa"));
345
    EXPECT_EQ(steel->getPhysicalQuantity(QString::fromStdString("SpecificHeat")).getUserString(), parseQuantity("590.00 J/kg/K"));
346
    EXPECT_EQ(steel->getPhysicalQuantity(QString::fromStdString("ThermalConductivity")).getUserString(), parseQuantity("43.00 W/m/K"));
347
    EXPECT_EQ(steel->getPhysicalQuantity(QString::fromStdString("ThermalExpansionCoefficient")).getUserString(), parseQuantity("12.00 µm/m/K"));
348

349
}
350

351
TEST_F(TestMaterial, TestColumns)
352
{
353
    // Start with an empty material
354
    Materials::Material testMaterial;
355
    auto models = testMaterial.getPhysicalModels();
356
    EXPECT_NE(&models, nullptr);
357
    EXPECT_EQ(models->size(), 0);
358

359
    // Add a model
360
    testMaterial.addPhysical(Materials::ModelUUIDs::ModelUUID_Test_Model);
361
    models = testMaterial.getPhysicalModels();
362
    EXPECT_EQ(models->size(), 1);
363

364
    EXPECT_TRUE(testMaterial.hasPhysicalProperty(QString::fromStdString("TestArray2D")));
365
    auto array2d = testMaterial.getPhysicalProperty(QString::fromStdString("TestArray2D"))->getMaterialValue();
366
    EXPECT_TRUE(array2d);
367
    EXPECT_EQ(dynamic_cast<Materials::Material2DArray &>(*array2d).columns(), 2);
368

369
    EXPECT_TRUE(testMaterial.hasPhysicalProperty(QString::fromStdString("TestArray2D3Column")));
370
    auto array2d3Column = testMaterial.getPhysicalProperty(QString::fromStdString("TestArray2D3Column"))->getMaterialValue();
371
    EXPECT_TRUE(array2d3Column);
372
    EXPECT_EQ(dynamic_cast<Materials::Material2DArray &>(*array2d3Column).columns(), 3);
373

374
    EXPECT_TRUE(testMaterial.hasPhysicalProperty(QString::fromStdString("TestArray3D")));
375
    auto array3d = testMaterial.getPhysicalProperty(QString::fromStdString("TestArray3D"))->getMaterialValue();
376
    EXPECT_TRUE(array3d);
377
    EXPECT_EQ(dynamic_cast<Materials::Material3DArray &>(*array3d).columns(), 2);
378
}
379

380
// clang-format on
381
FreeCAD

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