Merge remote-tracking branch 'refs/remotes/mongodb/master' into force…

…_bsonclassmaps
mongodb · Oct 19, 2015 · 059ce9b · 059ce9b
2 parents b6288d2 + f1ec471
commit 059ce9b
Show file tree

Hide file tree

Showing 11 changed files with 386 additions and 21 deletions.
diff --git a/Docs/reference/content/reference/driver/expressions.md b/Docs/reference/content/reference/driver/expressions.md
@@ -29,6 +29,8 @@ class Person
 	public HashSet<string> FavoriteNames { get; set; }
 
 	public DateTime CreatedAtUtc { get; set; }
+
+	public int PermissionFlags { get; set; }
 }
 
 class Pet
@@ -139,6 +141,42 @@ Find(p => !localAges.Contains(p.Age));
 { Age: { $nin: [10, 20, 30] } }
 ```
 
+#### $bitsAllClear
+
+```csharp
+Find(p => (p.PermissionFlags & 7) == 0);
+```
+```json
+{ PermissionFlags: { $bitsAllClear: 7 } }
+```
+
+#### $bitsAllSet
+
+```csharp
+Find(p => (p.PermissionFlags & 7) == 7);
+```
+```json
+{ PermissionFlags: { $bitsAllSet: 7 } }
+```
+
+#### $bitsAnyClear
+
+```csharp
+Find(p => (p.PermissionFlags & 7) != 7);
+```
+```json
+{ PermissionFlags: { $bitsAnyClear: 7 } }
+```
+
+#### $bitsAnySet
+
+```csharp
+Find(p => (p.PermissionFlags & 7) != 0);
+```
+```json
+{ PermissionFlags: { $bitsAnySet: 7 } }
+```
+
 ### Logical
 
 See the [MongoDB documentation]({{< docsref "reference/operator/query/#logical" >}}) for more information on each operator.

diff --git a/src/MongoDB.Driver.Legacy.Tests/Operations/CurrentOpUsingFindOperationTests.cs b/src/MongoDB.Driver.Legacy.Tests/Operations/CurrentOpUsingFindOperationTests.cs
@@ -72,7 +72,7 @@ public void CreateOperation_should_return_expected_result()
         }
 
         [Test]
-        [RequiresServer(VersionLessThan = "3.0.0")]
+        [RequiresServer(ClusterTypes = ClusterTypes.StandaloneOrReplicaSet, StorageEngines = "mmapv1")]
         public void Execute_should_return_expected_result()
         {
             var subject = new CurrentOpUsingFindOperation(_adminDatabaseNamespace, _messageEncoderSettings);

diff --git a/src/MongoDB.Driver.Tests/FilterDefinitionBuilderTests.cs b/src/MongoDB.Driver.Tests/FilterDefinitionBuilderTests.cs
@@ -127,6 +127,70 @@ public void And_with_a_nested_and_and_clashing_keys_using_ampersand()
             Assert(filter, "{$and: [{a: 1}, {a: 2}, {c: 3}]}");
         }
 
+        [Test]
+        public void BitsAllClear()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAllClear("a", 43), "{a: {$bitsAllClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAllClear_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAllClear(x => x.Age, 43), "{age: {$bitsAllClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAllSet()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAllSet("a", 43), "{a: {$bitsAllSet: 43}}");
+        }
+
+        [Test]
+        public void BitsAllSet_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAllSet(x => x.Age, 43), "{age: {$bitsAllSet: 43}}");
+        }
+
+        [Test]
+        public void BitsAnyClear()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAnyClear("a", 43), "{a: {$bitsAnyClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAnyClear_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAnyClear(x => x.Age, 43), "{age: {$bitsAnyClear: 43}}");
+        }
+
+        [Test]
+        public void BitsAnySet()
+        {
+            var subject = CreateSubject<BsonDocument>();
+
+            Assert(subject.BitsAnySet("a", 43), "{a: {$bitsAnySet: 43}}");
+        }
+
+        [Test]
+        public void BitsAnySet_Typed()
+        {
+            var subject = CreateSubject<Person>();
+
+            Assert(subject.BitsAnySet(x => x.Age, 43), "{age: {$bitsAnySet: 43}}");
+        }
+
         [Test]
         public void ElemMatch()
         {

diff --git a/src/MongoDB.Driver.Tests/Linq/MongoQueryableTests.cs b/src/MongoDB.Driver.Tests/Linq/MongoQueryableTests.cs
@@ -123,6 +123,14 @@ public void Count_with_predicate()
             result.Should().Be(1);
         }
 
+        [Test]
+        public void Count_with_no_matches()
+        {
+            var result = CreateQuery().Count(x => x.C.E.F == 13151235);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         public async Task CountAsync()
         {
@@ -139,6 +147,14 @@ public async Task CountAsync_with_predicate()
             result.Should().Be(1);
         }
 
+        [Test]
+        public async Task CountAsync_with_no_matches()
+        {
+            var result = await CreateQuery().CountAsync(x => x.C.E.F == 123412523);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         [RequiresServer(MinimumVersion = "2.6.0")]
         public void Distinct_followed_by_where()
@@ -364,6 +380,14 @@ public void LongCount_with_predicate()
             result.Should().Be(1);
         }
 
+        [Test]
+        public void LongCount_with_no_results()
+        {
+            var result = CreateQuery().LongCount(x => x.C.E.F == 123452135);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         public async Task LongCountAsync()
         {
@@ -380,6 +404,14 @@ public async Task LongCountAsync_with_predicate()
             result.Should().Be(1);
         }
 
+        [Test]
+        public async Task LongCountAsync_with_no_results()
+        {
+            var result = await CreateQuery().LongCountAsync(x => x.C.E.F == 12351235);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         public void Max()
         {
@@ -1039,6 +1071,14 @@ public void Sum_with_selector()
             result.Should().Be(122);
         }
 
+        [Test]
+        public void Sum_with_no_results()
+        {
+            var result = CreateQuery().Where(x => x.C.E.F == 12341235).Sum(x => x.C.E.F);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         public async Task SumAsync()
         {
@@ -1055,6 +1095,14 @@ public async Task SumAsync_with_selector()
             result.Should().Be(122);
         }
 
+        [Test]
+        public async Task SumAsync_with_no_results()
+        {
+            var result = await CreateQuery().Where(x => x.C.E.F == 21341235).SumAsync(x => x.C.E.F);
+
+            result.Should().Be(0);
+        }
+
         [Test]
         public void Take()
         {

diff --git a/src/MongoDB.Driver.Tests/Linq/Translators/PredicateTranslatorTests.cs b/src/MongoDB.Driver.Tests/Linq/Translators/PredicateTranslatorTests.cs
@@ -165,6 +165,56 @@ public void Any_with_local_contains_on_a_scalar_array()
                 "{\"C.E.I\": { $in: [\"itchy\" ] } }");
         }
 
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.9")]
+        public void BitsAllClear_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 20) == 0,
+                1,
+                "{'C.E.F': { $bitsAllClear: 20 } }");
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.9")]
+        public void BitsAllSet_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 7) == 7,
+                1,
+                "{'C.E.F': { $bitsAllSet: 7 } }");
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.9")]
+        public void BitsAllSet_with_HasFlag()
+        {
+            Assert(
+                x => x.Q.HasFlag(Q.One),
+                1,
+                "{Q: { $bitsAllSet: 1 } }");
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.9")]
+        public void BitsAnyClear_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 7) != 7,
+                1,
+                "{'C.E.F': { $bitsAnyClear: 7 } }");
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.9")]
+        public void BitsAnySet_with_bitwise_operators()
+        {
+            Assert(
+                x => (x.C.E.F & 20) != 0,
+                1,
+                "{'C.E.F': { $bitsAnySet: 20 } }");
+        }
+
         [Test]
         public void LocalIListContains()
         {

diff --git a/src/MongoDB.Driver/FilterDefinitionBuilder.cs b/src/MongoDB.Driver/FilterDefinitionBuilder.cs
@@ -290,6 +290,94 @@ public FilterDefinition<TDocument> AnyNin<TItem>(Expression<Func<TDocument, IEnu
             return AnyNin(new ExpressionFieldDefinition<TDocument>(field), values);
         }
 
+        /// <summary>
+        /// Creates a bits all clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAllClear(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAllClear", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits all clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAllClear(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAllClear(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits all set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all set filter.</returns>
+        public FilterDefinition<TDocument> BitsAllSet(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAllSet", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits all set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits all set filter.</returns>
+        public FilterDefinition<TDocument> BitsAllSet(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAllSet(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAnyClear(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAnyClear", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any clear filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any clear filter.</returns>
+        public FilterDefinition<TDocument> BitsAnyClear(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAnyClear(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any set filter.</returns>
+        public FilterDefinition<TDocument> BitsAnySet(FieldDefinition<TDocument> field, long bitmask)
+        {
+            return new OperatorFilterDefinition<TDocument>("$bitsAnySet", field, bitmask);
+        }
+
+        /// <summary>
+        /// Creates a bits any set filter.
+        /// </summary>
+        /// <param name="field">The field.</param>
+        /// <param name="bitmask">The bitmask.</param>
+        /// <returns>A bits any set filter.</returns>
+        public FilterDefinition<TDocument> BitsAnySet(Expression<Func<TDocument, object>> field, long bitmask)
+        {
+            return BitsAnySet(new ExpressionFieldDefinition<TDocument>(field), bitmask);
+        }
+
         /// <summary>
         /// Creates an element match filter for an array field.
         /// </summary>