Cr8-xyz/blender
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
236ca8fbe84575504f6ae80aec63c8059b875ef0
blender/tests/gtests/functions/FN_generic_vector_array_test.cc

102 lines
2.6 KiB
C++
Raw Normal View History

Cleanup: add correct license header to tests
2020-07-08 15:01:33 +02:00
/* Apache License, Version 2.0 */
Functions: Multi Function This adds the `MultiFunction` type and some smallish utility types that it uses. A `MultiFunction` encapsulates a function that is optimized for throughput by always processing many elements at once. This is an important part of the new particle system, because it allows us to execute user generated node trees for many particles efficiently. Reviewers: brecht Differential Revision: https://developer.blender.org/D8030
2020-06-16 16:35:57 +02:00
#include "FN_generic_vector_array.hh"
#include "testing/testing.h"
Cleanup: use nested namespaces
2020-07-03 14:25:20 +02:00
namespace blender::fn {
Functions: Multi Function This adds the `MultiFunction` type and some smallish utility types that it uses. A `MultiFunction` encapsulates a function that is optimized for throughput by always processing many elements at once. This is an important part of the new particle system, because it allows us to execute user generated node trees for many particles efficiently. Reviewers: brecht Differential Revision: https://developer.blender.org/D8030
2020-06-16 16:35:57 +02:00
TEST(generic_vector_array, Constructor)
{
Cleanup: avoid static initialization order issues when accessing CPPTypes Instead of depending on static initialization order of globals use static variables within functions. Those are initialized on first use. This is every so slighly less efficient, but avoids a full class of problems.
2020-07-17 14:15:06 +02:00
GVectorArray vectors{CPPType::get<int32_t>(), 3};
Functions: Multi Function This adds the `MultiFunction` type and some smallish utility types that it uses. A `MultiFunction` encapsulates a function that is optimized for throughput by always processing many elements at once. This is an important part of the new particle system, because it allows us to execute user generated node trees for many particles efficiently. Reviewers: brecht Differential Revision: https://developer.blender.org/D8030
2020-06-16 16:35:57 +02:00
EXPECT_EQ(vectors.size(), 3);
EXPECT_EQ(vectors.lengths().size(), 3);
EXPECT_EQ(vectors.starts().size(), 3);
EXPECT_EQ(vectors.lengths()[0], 0);
EXPECT_EQ(vectors.lengths()[1], 0);
EXPECT_EQ(vectors.lengths()[2], 0);
Cleanup: avoid static initialization order issues when accessing CPPTypes Instead of depending on static initialization order of globals use static variables within functions. Those are initialized on first use. This is every so slighly less efficient, but avoids a full class of problems.
2020-07-17 14:15:06 +02:00
EXPECT_EQ(vectors.type(), CPPType::get<int32_t>());
Functions: Multi Function This adds the `MultiFunction` type and some smallish utility types that it uses. A `MultiFunction` encapsulates a function that is optimized for throughput by always processing many elements at once. This is an important part of the new particle system, because it allows us to execute user generated node trees for many particles efficiently. Reviewers: brecht Differential Revision: https://developer.blender.org/D8030
2020-06-16 16:35:57 +02:00
}
TEST(generic_vector_array, Append)
{
Cleanup: avoid static initialization order issues when accessing CPPTypes Instead of depending on static initialization order of globals use static variables within functions. Those are initialized on first use. This is every so slighly less efficient, but avoids a full class of problems.
2020-07-17 14:15:06 +02:00
GVectorArray vectors{CPPType::get<std::string>(), 3};
Functions: Multi Function This adds the `MultiFunction` type and some smallish utility types that it uses. A `MultiFunction` encapsulates a function that is optimized for throughput by always processing many elements at once. This is an important part of the new particle system, because it allows us to execute user generated node trees for many particles efficiently. Reviewers: brecht Differential Revision: https://developer.blender.org/D8030
2020-06-16 16:35:57 +02:00
std::string value = "hello";
vectors.append(0, &value);
value = "world";
vectors.append(0, &value);
vectors.append(2, &value);
EXPECT_EQ(vectors.lengths()[0], 2);
EXPECT_EQ(vectors.lengths()[1], 0);
EXPECT_EQ(vectors.lengths()[2], 1);
EXPECT_EQ(vectors[0].size(), 2);
EXPECT_EQ(vectors[0].typed<std::string>()[0], "hello");
EXPECT_EQ(vectors[0].typed<std::string>()[1], "world");
EXPECT_EQ(vectors[2].typed<std::string>()[0], "world");
}
TEST(generic_vector_array, AsArraySpan)
{
Cleanup: avoid static initialization order issues when accessing CPPTypes Instead of depending on static initialization order of globals use static variables within functions. Those are initialized on first use. This is every so slighly less efficient, but avoids a full class of problems.
2020-07-17 14:15:06 +02:00
GVectorArray vectors{CPPType::get<int32_t>(), 3};
Functions: Multi Function This adds the `MultiFunction` type and some smallish utility types that it uses. A `MultiFunction` encapsulates a function that is optimized for throughput by always processing many elements at once. This is an important part of the new particle system, because it allows us to execute user generated node trees for many particles efficiently. Reviewers: brecht Differential Revision: https://developer.blender.org/D8030
2020-06-16 16:35:57 +02:00
int value = 3;
vectors.append(0, &value);
vectors.append(0, &value);
value = 5;
vectors.append(2, &value);
vectors.append(2, &value);
vectors.append(2, &value);
GVArraySpan span = vectors;
Cleanup: avoid static initialization order issues when accessing CPPTypes Instead of depending on static initialization order of globals use static variables within functions. Those are initialized on first use. This is every so slighly less efficient, but avoids a full class of problems.
2020-07-17 14:15:06 +02:00
EXPECT_EQ(span.type(), CPPType::get<int32_t>());
Functions: Multi Function This adds the `MultiFunction` type and some smallish utility types that it uses. A `MultiFunction` encapsulates a function that is optimized for throughput by always processing many elements at once. This is an important part of the new particle system, because it allows us to execute user generated node trees for many particles efficiently. Reviewers: brecht Differential Revision: https://developer.blender.org/D8030
2020-06-16 16:35:57 +02:00
EXPECT_EQ(span.size(), 3);
EXPECT_EQ(span[0].size(), 2);
EXPECT_EQ(span[1].size(), 0);
EXPECT_EQ(span[2].size(), 3);
EXPECT_EQ(span[0].typed<int>()[1], 3);
EXPECT_EQ(span[2].typed<int>()[0], 5);
}
TEST(generic_vector_array, TypedRef)
{
Cleanup: avoid static initialization order issues when accessing CPPTypes Instead of depending on static initialization order of globals use static variables within functions. Those are initialized on first use. This is every so slighly less efficient, but avoids a full class of problems.
2020-07-17 14:15:06 +02:00
GVectorArray vectors{CPPType::get<int32_t>(), 4};
Functions: Multi Function This adds the `MultiFunction` type and some smallish utility types that it uses. A `MultiFunction` encapsulates a function that is optimized for throughput by always processing many elements at once. This is an important part of the new particle system, because it allows us to execute user generated node trees for many particles efficiently. Reviewers: brecht Differential Revision: https://developer.blender.org/D8030
2020-06-16 16:35:57 +02:00
GVectorArrayRef<int> ref = vectors.typed<int>();
ref.append(0, 2);
ref.append(0, 6);
ref.append(0, 7);
ref.append(2, 1);
ref.append(2, 1);
ref.append(3, 5);
ref.append(3, 6);
EXPECT_EQ(ref[0].size(), 3);
EXPECT_EQ(vectors[0].size(), 3);
EXPECT_EQ(ref[0][0], 2);
EXPECT_EQ(ref[0][1], 6);
EXPECT_EQ(ref[0][2], 7);
EXPECT_EQ(ref[1].size(), 0);
EXPECT_EQ(ref[2][0], 1);
EXPECT_EQ(ref[2][1], 1);
EXPECT_EQ(ref[3][0], 5);
EXPECT_EQ(ref[3][1], 6);
}
Functions: Various improvements to the spans and generic data structures Most of this code is covered by unit tests.
2020-06-22 15:48:08 +02:00
TEST(generic_vector_array, Extend)
{
Cleanup: avoid static initialization order issues when accessing CPPTypes Instead of depending on static initialization order of globals use static variables within functions. Those are initialized on first use. This is every so slighly less efficient, but avoids a full class of problems.
2020-07-17 14:15:06 +02:00
GVectorArray vectors{CPPType::get<int32_t>(), 3};
Functions: Various improvements to the spans and generic data structures Most of this code is covered by unit tests.
2020-06-22 15:48:08 +02:00
GVectorArrayRef<int> ref = vectors;
ref.extend(1, {5, 6, 7});
ref.extend(0, {3});
EXPECT_EQ(vectors[0].size(), 1);
EXPECT_EQ(vectors[1].size(), 3);
EXPECT_EQ(vectors[2].size(), 0);
EXPECT_EQ(ref[1][0], 5);
EXPECT_EQ(ref[1][1], 6);
EXPECT_EQ(ref[1][2], 7);
EXPECT_EQ(ref[0][0], 3);
}
Cleanup: use nested namespaces
2020-07-03 14:25:20 +02:00
} // namespace blender::fn
Reference in New Issue Copy Permalink