TEST(InclusionProjectionExecutionTest, ComputedFieldReplacingExistingShouldAppearAfterInclusions) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("b" << wrapInLiteral("NEW") << "a" << true));
auto result = inclusion.applyProjection(Document{{"b", 1}, {"a", 1}});
auto expectedResult = Document{{"a", 1}, {"b", "NEW"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
result = inclusion.applyProjection(Document{{"a", 1}, {"b", 4}});
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldAddComputedTopLevelField) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("newField" << wrapInLiteral("computedVal")));
auto result = inclusion.applyProjection(Document{});
auto expectedResult = Document{{"newField", "computedVal"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Computed field should replace existing field.
result = inclusion.applyProjection(Document{{"newField", "preExisting"_sd}});
expectedResult = Document{{"newField", "computedVal"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldImplicitlyIncludeId) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a" << true));
auto result = inclusion.applyProjection(Document{{"_id", "ID"_sd}, {"a", 1}, {"b", 2}});
auto expectedResult = Document{{"_id", "ID"_sd}, {"a", 1}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Should leave the "_id" in the same place as in the original document.
result = inclusion.applyProjection(Document{{"a", 1}, {"b", 2}, {"_id", "ID"_sd}});
expectedResult = Document{{"a", 1}, {"_id", "ID"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldCreateSubDocIfDottedComputedFieldDoesntExist) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("sub.target" << wrapInLiteral("computedVal")));
// Should add the path if it doesn't exist.
auto result = inclusion.applyProjection(Document{});
auto expectedResult = Document{{"sub", Document{{"target", "computedVal"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Should replace non-documents with documents.
result = inclusion.applyProjection(Document{{"sub", "notADocument"_sd}});
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldCreateNestedSubDocumentsAllTheWayToComputedField) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a.b.c.d" << wrapInLiteral("computedVal")));
// Should add the path if it doesn't exist.
auto result = inclusion.applyProjection(Document{});
auto expectedResult =
Document{{"a", Document{{"b", Document{{"c", Document{{"d", "computedVal"_sd}}}}}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Should replace non-documents with documents.
result = inclusion.applyProjection(Document{{"a", Document{{"b", "other"_sd}}}});
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldNotCreateSubDocIfDottedIncludedFieldDoesNotExist) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("sub.target" << true));
// Should not add the path if it doesn't exist.
auto result = inclusion.applyProjection(Document{});
auto expectedResult = Document{};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Should not replace the first part of the path if that part exists.
result = inclusion.applyProjection(Document{{"sub", "notADocument"_sd}});
expectedResult = Document{};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldAddOrIncludeSubFieldsOfId) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("_id.X" << true << "_id.Z" << wrapInLiteral("NEW")));
auto result = inclusion.applyProjection(Document{{"_id", Document{{"X", 1}, {"Y", 2}}}});
auto expectedResult = Document{{"_id", Document{{"X", 1}, {"Z", "NEW"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldApplyInclusionsAndAdditionsToEachElementInArray) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a.inc" << true << "a.comp" << wrapInLiteral("COMPUTED")));
vector<Value> nestedValues = {Value(1),
Value(Document{}),
Value(Document{{"inc", 1}}),
Value(Document{{"inc", 1}, {"c", 2}}),
Value(Document{{"c", 2}, {"inc", 1}}),
Value(Document{{"inc", 1}, {"c", 2}, {"comp", "original"_sd}}),
Value(vector<Value>{}),
Value(vector<Value>{Value(1), Value(Document{{"inc", 1}})})};
vector<Value> expectedNestedValues = {
Value(Document{{"comp", "COMPUTED"_sd}}),
Value(Document{{"comp", "COMPUTED"_sd}}),
Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}),
Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}),
Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}),
Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}}),
Value(vector<Value>{}),
Value(vector<Value>{Value(Document{{"comp", "COMPUTED"_sd}}),
Value(Document{{"inc", 1}, {"comp", "COMPUTED"_sd}})})};
auto result = inclusion.applyProjection(Document{{"a", nestedValues}});
auto expectedResult = Document{{"a", expectedNestedValues}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ComputedFieldShouldReplaceNestedArrayForNoRecursePolicy) {
auto inclusion = makeInclusionProjectionWithNoArrayRecursion();
inclusion.parse(BSON("a.b" << wrapInLiteral("COMPUTED")));
// For kRecurseNestedArrays, the computed field (1) replaces any scalar values in the array with
// a subdocument containing the new field, and (2) is added to each element of the array and all
// nested arrays individually. With kDoNotRecurseNestedArrays, the nested arrays are replaced
// rather than being traversed, in exactly the same way as scalar values.
vector<Value> nestedValues = {Value(1),
Value(Document{}),
Value(Document{{"b", 1}}),
Value(Document{{"b", 1}, {"c", 2}}),
Value(vector<Value>{}),
Value(vector<Value>{Value(1), Value(Document{{"c", 1}})})};
vector<Value> expectedNestedValues = {Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}})};
auto result = inclusion.applyProjection(Document{{"a", nestedValues}});
auto expectedResult = Document{{"a", expectedNestedValues}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
void GLRenderer::render()
{
if (!m_valid)
return;
Vector4ub c = m_scene.backgroundColor();
glClearColor(c[0] / 255.0f, c[1] / 255.0f, c[2] / 255.0f, c[3] / 255.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
applyProjection();
GLRenderVisitor visitor(m_camera, m_textRenderStrategy);
// Setup for opaque geometry
visitor.setRenderPass(OpaquePass);
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
m_scene.rootNode().accept(visitor);
// Setup for transparent geometry
visitor.setRenderPass(TranslucentPass);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
m_scene.rootNode().accept(visitor);
// Setup for 3d overlay rendering
visitor.setRenderPass(Overlay3DPass);
glClear(GL_DEPTH_BUFFER_BIT);
m_scene.rootNode().accept(visitor);
// Setup for 2d overlay rendering
visitor.setRenderPass(Overlay2DPass);
visitor.setCamera(m_overlayCamera);
glDisable(GL_DEPTH_TEST);
m_scene.rootNode().accept(visitor);
}
TEST(InclusionProjectionExecutionTest, ShouldReplaceIdWithComputedId) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("_id" << wrapInLiteral("newId")));
auto result = inclusion.applyProjection(Document{{"a", 1}, {"b", 2}, {"_id", "ID"_sd}});
auto expectedResult = Document{{"_id", "newId"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldExcludeIdIfExplicitlyExcluded) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a" << true << "_id" << false));
auto result = inclusion.applyProjection(Document{{"a", 1}, {"b", 2}, {"_id", "ID"_sd}});
auto expectedResult = Document{{"a", 1}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldImplicitlyIncludeIdWithComputedFields) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("newField" << wrapInLiteral("computedVal")));
auto result = inclusion.applyProjection(Document{{"_id", "ID"_sd}, {"a", 1}});
auto expectedResult = Document{{"_id", "ID"_sd}, {"newField", "computedVal"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldIncludeFieldsInOrderOfInputDoc) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("first" << true << "second" << true << "third" << true));
auto inputDoc = Document{{"second", 1}, {"first", 0}, {"third", 2}};
auto result = inclusion.applyProjection(inputDoc);
ASSERT_DOCUMENT_EQ(result, inputDoc);
}
TEST(InclusionProjectionExecutionTest, ShouldApplyNestedComputedFieldsInOrderSpecified) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a" << wrapInLiteral("FIRST") << "b.c" << wrapInLiteral("SECOND")));
auto result = inclusion.applyProjection(Document{});
auto expectedResult = Document{{"a", "FIRST"_sd}, {"b", Document{{"c", "SECOND"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldApplyComputedFieldsInOrderSpecified) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("firstComputed" << wrapInLiteral("FIRST") << "secondComputed"
<< wrapInLiteral("SECOND")));
auto result = inclusion.applyProjection(Document{{"first", 0}, {"second", 1}, {"third", 2}});
auto expectedResult = Document{{"firstComputed", "FIRST"_sd}, {"secondComputed", "SECOND"_sd}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
Vector3& unproject(const Camera<T>& camera){
Matrix4<T> matrix;
matrix.multiplyMatricies(camera.matrixWorld, matrix.getInverse( camera.projectionMatrix ) );
return applyProjection(matrix);
}
TEST(InclusionProjectionExecutionTest, ShouldOverrideExcludePolicyWithExplicitIncludeIdSpec) {
auto inclusion = makeInclusionProjectionWithDefaultIdExclusion();
inclusion.parse(BSON("_id" << true << "a" << true));
auto result = inclusion.applyProjection(Document{{"_id", 2}, {"a", 3}});
auto expectedResult = Document{{"_id", 2}, {"a", 3}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldIncludeIdWithIncludePolicy) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a" << true));
auto result = inclusion.applyProjection(Document{{"_id", 2}, {"a", 3}});
auto expectedResult = Document{{"_id", 2}, {"a", 3}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldApplyComputedFieldsAfterAllInclusions) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("b.c" << wrapInLiteral("NEW") << "a" << true));
auto result = inclusion.applyProjection(Document{{"a", 1}});
auto expectedResult = Document{{"a", 1}, {"b", Document{{"c", "NEW"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
result = inclusion.applyProjection(Document{{"a", 1}, {"b", 4}});
ASSERT_DOCUMENT_EQ(result, expectedResult);
// In this case, the field 'b' shows up first and has a nested inclusion or computed field. Even
// though it is a computed field, it will appear first in the output document. This is
// inconsistent, but the expected behavior, and a consequence of applying the projection
// recursively to each sub-document.
result = inclusion.applyProjection(Document{{"b", 4}, {"a", 1}});
expectedResult = Document{{"b", Document{{"c", "NEW"_sd}}}, {"a", 1}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
void Camera::reshape(int _width, int _height) {
width = _width;
height = _height;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
applyProjection();
glViewport(0, 0, width, height);
}
void OpenGLSceneViewCore::setupViewportAndCamera()
{
reshapeViewport();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
applyProjection();
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(_camera->GetViewMatrix());
}
TEST(InclusionProjectionExecutionTest, ShouldAddComputedDottedFieldToSubDocument) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("sub.target" << wrapInLiteral("computedVal")));
// Other fields exist in sub document, one of which is the specified field.
auto result = inclusion.applyProjection(Document{{"sub", Document{{"target", 1}, {"c", 2}}}});
auto expectedResult = Document{{"sub", Document{{"target", "computedVal"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Specified field is not present in the sub document.
result = inclusion.applyProjection(Document{{"sub", Document{{"c", 1}}}});
expectedResult = Document{{"sub", Document{{"target", "computedVal"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// There are no fields in sub document.
result = inclusion.applyProjection(Document{{"sub", Document{}}});
expectedResult = Document{{"sub", Document{{"target", "computedVal"_sd}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldAllowInclusionOfIdSubfieldWithDefaultExcludePolicy) {
auto inclusion = makeInclusionProjectionWithDefaultIdExclusion();
inclusion.parse(BSON("_id.id1" << true << "a" << true));
auto result = inclusion.applyProjection(
Document{{"_id", Document{{"id1", 1}, {"id2", 2}}}, {"a", 3}, {"b", 4}});
auto expectedResult = Document{{"_id", Document{{"id1", 1}}}, {"a", 3}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldIncludeSimpleDottedFieldFromSubDoc) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a.b" << true));
// More than one field in sub document.
auto result = inclusion.applyProjection(Document{{"a", Document{{"b", 1}, {"c", 2}}}});
auto expectedResult = Document{{"a", Document{{"b", 1}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Specified field is the only field in the sub document.
result = inclusion.applyProjection(Document{{"a", Document{{"b", 1}}}});
expectedResult = Document{{"a", Document{{"b", 1}}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// Specified field is not present in the sub document.
result = inclusion.applyProjection(Document{{"a", Document{{"c", 1}}}});
expectedResult = Document{{"a", Document{}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
// There are no fields in sub document.
result = inclusion.applyProjection(Document{{"a", Document{}}});
expectedResult = Document{{"a", Document{}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldAlwaysKeepMetadataFromOriginalDoc) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a" << true));
MutableDocument inputDocBuilder(Document{{"a", 1}});
inputDocBuilder.setRandMetaField(1.0);
inputDocBuilder.setTextScore(10.0);
Document inputDoc = inputDocBuilder.freeze();
auto result = inclusion.applyProjection(inputDoc);
MutableDocument expectedDoc(inputDoc);
expectedDoc.copyMetaDataFrom(inputDoc);
ASSERT_DOCUMENT_EQ(result, expectedDoc.freeze());
}
TEST(InclusionProjectionExecutionTest, ShouldRetainNestedArraysIfNoRecursionNeeded) {
auto inclusion = makeInclusionProjectionWithNoArrayRecursion();
inclusion.parse(BSON("a" << true));
// {a: [1, {b: 2, c: 3}, [{b: 4, c: 5}], {d: 6}]} => [output doc identical to input]
const auto inputDoc =
Document{{"a",
vector<Value>{Value(1),
Value(Document{{"b", 2}, {"c", 3}}),
Value(vector<Value>{Value(Document{{"b", 4}, {"c", 5}})}),
Value(Document{{"d", 6}})}}};
auto result = inclusion.applyProjection(inputDoc);
const auto& expectedResult = inputDoc;
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
TEST(InclusionProjectionExecutionTest, ShouldNotRecurseNestedArraysForNoRecursePolicy) {
auto inclusion = makeInclusionProjectionWithNoArrayRecursion();
inclusion.parse(BSON("a.b" << true));
// {a: [1, {b: 2, c: 3}, [{b: 4, c: 5}], {d: 6}]} => {a: [{b: 2}, {}]}
auto result = inclusion.applyProjection(
Document{{"a",
vector<Value>{Value(1),
Value(Document{{"b", 2}, {"c", 3}}),
Value(vector<Value>{Value(Document{{"b", 4}, {"c", 5}})}),
Value(Document{{"d", 6}})}}});
auto expectedResult = Document{
{"a", vector<Value>{Value(), Value(Document{{"b", 2}}), Value(), Value(Document{})}}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}
Value ExclusionNode::applyProjectionToValue(Value val) const {
switch (val.getType()) {
case BSONType::Object:
return Value(applyProjection(val.getDocument()));
case BSONType::Array: {
// Apply exclusion to each element of the array. Note that numeric paths aren't treated
// specially, and we will always apply the projection to each element in the array.
//
// For example, applying the projection {"a.1": 0} to the document
// {a: [{b: 0, "1": 0}, {b: 1, "1": 1}]} will not result in {a: [{b: 0, "1": 0}]}, but
// instead will result in {a: [{b: 0}, {b: 1}]}.
std::vector<Value> values = val.getArray();
for (auto it = values.begin(); it != values.end(); it++) {
*it = applyProjectionToValue(*it);
}
return Value(std::move(values));
}
default:
return val;
}
}
TEST(InclusionProjectionExecutionTest, ComputedFieldIsAddedToNestedArrayElementsForRecursePolicy) {
auto inclusion = makeInclusionProjectionWithDefaultPolicies();
inclusion.parse(BSON("a.b" << wrapInLiteral("COMPUTED")));
vector<Value> nestedValues = {Value(1),
Value(Document{}),
Value(Document{{"b", 1}}),
Value(Document{{"b", 1}, {"c", 2}}),
Value(vector<Value>{}),
Value(vector<Value>{Value(1), Value(Document{{"c", 1}})})};
vector<Value> expectedNestedValues = {
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}}),
Value(vector<Value>{}),
Value(vector<Value>{Value(Document{{"b", "COMPUTED"_sd}}),
Value(Document{{"b", "COMPUTED"_sd}})})};
auto result = inclusion.applyProjection(Document{{"a", nestedValues}});
auto expectedResult = Document{{"a", expectedNestedValues}};
ASSERT_DOCUMENT_EQ(result, expectedResult);
}