More tests for QueryableTests.FirstOrDefault #71

StefH · StefH · commit 5a3be946dacc · 2017-04-09T21:43:52.000+02:00
diff --git a/src/System.Linq.Dynamic.Core/ExpressionParser.cs b/src/System.Linq.Dynamic.Core/ExpressionParser.cs
@@ -417,7 +417,7 @@ Expression ParseNullCoalescingOperator()
         // => operator - Added Support for projection operator
         Expression ParseLambdaOperator()
         {
-            Expression expr = ParseConditionalOr();
+            Expression expr = ParseOrOperator();
             if (_textParser.CurrentToken.Id == TokenId.Lambda && _it.Type == expr.Type)
             {
                 _textParser.NextToken();
@@ -445,29 +445,29 @@ Expression ParseIsNull()
         }
 
         // ||, or operator
-        Expression ParseConditionalOr()
+        Expression ParseOrOperator()
         {
-            Expression left = ParseConditionalAnd();
+            Expression left = ParseAndOperator();
             while (_textParser.CurrentToken.Id == TokenId.DoubleBar || TokenIdentifierIs("or"))
             {
                 Token op = _textParser.CurrentToken;
                 _textParser.NextToken();
-                Expression right = ParseConditionalAnd();
+                Expression right = ParseAndOperator();
                 CheckAndPromoteOperands(typeof(ILogicalSignatures), op.Text, ref left, ref right, op.Pos);
                 left = Expression.OrElse(left, right);
             }
             return left;
         }
 
         // &&, and operator
-        Expression ParseConditionalAnd()
+        Expression ParseAndOperator()
         {
             Expression left = ParseIn();
             while (_textParser.CurrentToken.Id == TokenId.DoubleAmphersand || TokenIdentifierIs("and"))
             {
                 Token op = _textParser.CurrentToken;
                 _textParser.NextToken();
-                Expression right = ParseComparison();
+                Expression right = ParseComparisonOperator();
                 CheckAndPromoteOperands(typeof(ILogicalSignatures), op.Text, ref left, ref right, op.Pos);
                 left = Expression.AndAlso(left, right);
             }
@@ -479,7 +479,7 @@ Expression ParseConditionalAnd()
         // Adapted from ticket submitted by github user mlewis9548 
         Expression ParseIn()
         {
-            Expression left = ParseLogicalAndOr();
+            Expression left = ParseLogicalAndOrOperator();
             Expression accumulate = left;
 
             while (TokenIdentifierIs("in"))
@@ -557,14 +557,14 @@ Expression ParseIn()
         }
 
         // &, | bitwise operators
-        Expression ParseLogicalAndOr()
+        Expression ParseLogicalAndOrOperator()
         {
-            Expression left = ParseComparison();
+            Expression left = ParseComparisonOperator();
             while (_textParser.CurrentToken.Id == TokenId.Amphersand || _textParser.CurrentToken.Id == TokenId.Bar)
             {
                 Token op = _textParser.CurrentToken;
                 _textParser.NextToken();
-                Expression right = ParseComparison();
+                Expression right = ParseComparisonOperator();
 
                 if (left.Type.GetTypeInfo().IsEnum)
                 {
@@ -600,9 +600,9 @@ Expression ParseLogicalAndOr()
         }
 
         // =, ==, !=, <>, >, >=, <, <= operators
-        Expression ParseComparison()
+        Expression ParseComparisonOperator()
         {
-            Expression left = ParseShift();
+            Expression left = ParseShiftOperator();
             while (_textParser.CurrentToken.Id == TokenId.Equal || _textParser.CurrentToken.Id == TokenId.DoubleEqual ||
                    _textParser.CurrentToken.Id == TokenId.ExclamationEqual || _textParser.CurrentToken.Id == TokenId.LessGreater ||
                    _textParser.CurrentToken.Id == TokenId.GreaterThan || _textParser.CurrentToken.Id == TokenId.GreaterThanEqual ||
@@ -612,7 +612,7 @@ Expression ParseComparison()
                 TypeConverter typeConverter;
                 Token op = _textParser.CurrentToken;
                 _textParser.NextToken();
-                Expression right = ParseShift();
+                Expression right = ParseShiftOperator();
                 bool isEquality = op.Id == TokenId.Equal || op.Id == TokenId.DoubleEqual || op.Id == TokenId.ExclamationEqual;
 
                 if (isEquality && (!left.Type.GetTypeInfo().IsValueType && !right.Type.GetTypeInfo().IsValueType || left.Type == typeof(Guid) && right.Type == typeof(Guid)))
@@ -728,7 +728,7 @@ private object ParseConstantExpressionToEnum(int pos, Type leftType, ConstantExp
         }
 
         // <<, >> operators
-        Expression ParseShift()
+        Expression ParseShiftOperator()
         {
             Expression left = ParseAdditive();
             while (_textParser.CurrentToken.Id == TokenId.DoubleLessThan || _textParser.CurrentToken.Id == TokenId.DoubleGreaterThan)
@@ -1113,6 +1113,7 @@ Expression ParseIif()
             Expression[] args = ParseArgumentList();
             if (args.Length != 3)
                 throw ParseError(errorPos, Res.IifRequiresThreeArgs);
+
             return GenerateConditional(args[0], args[1], args[2], errorPos);
         }
 
@@ -1138,6 +1139,7 @@ Expression GenerateConditional(Expression test, Expression expr1, Expression exp
                     string type2 = expr2 != NullLiteral ? expr2.Type.Name : "null";
                     if (expr1As2 != null)
                         throw ParseError(errorPos, Res.BothTypesConvertToOther, type1, type2);
+
                     throw ParseError(errorPos, Res.NeitherTypeConvertsToOther, type1, type2);
                 }
             }
@@ -1257,6 +1259,7 @@ Expression ParseLambdaInvocation(LambdaExpression lambda)
             MethodBase method;
             if (FindMethod(lambda.Type, "Invoke", false, args, out method) != 1)
                 throw ParseError(errorPos, Res.ArgsIncompatibleWithLambda);
+
             return Expression.Invoke(lambda, args);
         }
 
@@ -1268,6 +1271,7 @@ Expression ParseTypeAccess(Type type)
             {
                 if (!type.GetTypeInfo().IsValueType || IsNullableType(type))
                     throw ParseError(errorPos, Res.TypeHasNoNullableForm, GetTypeName(type));
+
                 type = typeof(Nullable<>).MakeGenericType(type);
                 _textParser.NextToken();
             }
diff --git a/src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.csproj b/src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.csproj
@@ -11,7 +11,7 @@
     <SignAssembly>true</SignAssembly>
     <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
     <PackageTags>system;linq;dynamic;core;NETStandard</PackageTags>
-    <PackageReleaseNotes>Upgraded to VS2017 structure.</PackageReleaseNotes>
+    <PackageReleaseNotes>Bugfixes</PackageReleaseNotes>
     <PackageProjectUrl>https://github.com/StefH/System.Linq.Dynamic.Core</PackageProjectUrl>
     <PackageLicenseUrl>https://github.com/StefH/System.Linq.Dynamic.Core/blob/master/licence.txt</PackageLicenseUrl>
     <RepositoryType>git</RepositoryType>
@@ -28,6 +28,10 @@
     <DefaultLanguage>en-us</DefaultLanguage>
     <DebugType>full</DebugType>
   </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'net20' ">
+    <DefineConstants>NET35</DefineConstants>
+  </PropertyGroup>
   
   <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard1.3' ">
     <DefineConstants>NETSTANDARD</DefineConstants>
@@ -53,13 +57,16 @@
     <LanguageTargets>$(MSBuildProgramFiles32)\MSBuild\Microsoft\Silverlight\v5.0\Microsoft.Silverlight.CSharp.targets</LanguageTargets>
   </PropertyGroup>
   
-  <PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Debug|net35|AnyCPU'">
-    <DefineConstants>TRACE;DEBUG;NET35</DefineConstants>
-  </PropertyGroup>
-  
   <ItemGroup>
     <PackageReference Include="JetBrains.Annotations" Version="10.4.0" PrivateAssets="All" />
   </ItemGroup>
+
+  <ItemGroup Condition=" '$(TargetFramework)' == 'net20' ">
+    <PackageReference Include="NetLegacySupport.ConcurrentDictionary">
+      <Version>1.1.1</Version>
+    </PackageReference>
+    <Reference Include="System" />
+  </ItemGroup>
   
   <ItemGroup Condition=" '$(TargetFramework)' == 'net35' ">
     <PackageReference Include="NetLegacySupport.ConcurrentDictionary">
diff --git a/src/System.Linq.Dynamic.Core/bugs and todo.txt b/src/System.Linq.Dynamic.Core/bugs and todo.txt
diff --git a/test/System.Linq.Dynamic.Core.Tests/QueryableTests.FirstOrDefault.cs b/test/System.Linq.Dynamic.Core.Tests/QueryableTests.FirstOrDefault.cs
@@ -1,4 +1,5 @@
-﻿using System.Linq.Dynamic.Core.Tests.Helpers.Models;
+﻿using NFluent;
+using System.Linq.Dynamic.Core.Tests.Helpers.Models;
 using Xunit;
 
 namespace System.Linq.Dynamic.Core.Tests
@@ -8,20 +9,68 @@ public partial class QueryableTests
         [Fact]
         public void FirstOrDefault()
         {
-            //Arrange
+            // Arrange
             var testList = User.GenerateSampleModels(100);
             var queryable = testList.AsQueryable();
 
-            //Act
+            // Act
             var expected = Queryable.FirstOrDefault(queryable);
             var expectedDefault = Queryable.FirstOrDefault(Enumerable.Empty<User>().AsQueryable());
 
             var result = (queryable as IQueryable).FirstOrDefault();
             var resultDefault = (Enumerable.Empty<User>().AsQueryable() as IQueryable).FirstOrDefault();
 
-            Assert.Equal(expected, result);
+            // Assert
+            Check.That(result).Equals(expected);
             Assert.Null(expectedDefault);
             Assert.Null(resultDefault);
         }
+
+        [Fact]
+        public void FirstOrDefault_Predicate()
+        {
+            //Arrange
+            var testList = User.GenerateSampleModels(100);
+            var queryable = testList.AsQueryable();
+
+            // Act
+            var expected = queryable.FirstOrDefault(u => u.Income > 1000);
+            var result = queryable.FirstOrDefault("Income > 1000");
+
+            // Assert
+            Check.That(result).Equals(expected);
+        }
+
+        [Fact]
+        public void FirstOrDefault_Predicate_WithArgs()
+        {
+            const int value = 1000;
+
+            // Arrange
+            var testList = User.GenerateSampleModels(100);
+            var queryable = testList.AsQueryable();
+
+            // Act
+            var expected = queryable.FirstOrDefault(u => u.Income > value);
+            var result = queryable.FirstOrDefault("Income > @0", value);
+
+            // Assert
+            Check.That(result).Equals(expected);
+        }
+
+        [Fact]
+        public void FirstOrDefault_Dynamic()
+        {
+            // Arrange
+            var testList = User.GenerateSampleModels(100);
+            IQueryable testListQry = testList.AsQueryable();
+
+            // Act
+            var realResult = testList.OrderBy(x => x.Roles.First().Name).Select(x => x.Id).ToArray();
+            var result = testListQry.OrderBy("Roles.FirstOrDefault().Name").Select("Id");
+
+            // Assert
+            Check.That(result.ToDynamicArray().Cast<Guid>()).ContainsExactly(realResult);
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -417,7 +417,7 @@ Expression ParseNullCoalescingOperator()`
`417`	`417`	`// => operator - Added Support for projection operator`
`418`	`418`	`Expression ParseLambdaOperator()`
`419`	`419`	`{`
`420`		`- Expression expr = ParseConditionalOr();`
	`420`	`+ Expression expr = ParseOrOperator();`
`421`	`421`	`if (_textParser.CurrentToken.Id == TokenId.Lambda && _it.Type == expr.Type)`
`422`	`422`	`{`
`423`	`423`	`_textParser.NextToken();`
`@@ -445,29 +445,29 @@ Expression ParseIsNull()`
`445`	`445`	`}`
`446`	`446`
`447`	`447`	`// \|\|, or operator`
`448`		`- Expression ParseConditionalOr()`
	`448`	`+ Expression ParseOrOperator()`
`449`	`449`	`{`
`450`		`- Expression left = ParseConditionalAnd();`
	`450`	`+ Expression left = ParseAndOperator();`
`451`	`451`	`while (_textParser.CurrentToken.Id == TokenId.DoubleBar \|\| TokenIdentifierIs("or"))`
`452`	`452`	`{`
`453`	`453`	`Token op = _textParser.CurrentToken;`
`454`	`454`	`_textParser.NextToken();`
`455`		`- Expression right = ParseConditionalAnd();`
	`455`	`+ Expression right = ParseAndOperator();`
`456`	`456`	`CheckAndPromoteOperands(typeof(ILogicalSignatures), op.Text, ref left, ref right, op.Pos);`
`457`	`457`	`left = Expression.OrElse(left, right);`
`458`	`458`	`}`
`459`	`459`	`return left;`
`460`	`460`	`}`
`461`	`461`
`462`	`462`	`// &&, and operator`
`463`		`- Expression ParseConditionalAnd()`
	`463`	`+ Expression ParseAndOperator()`
`464`	`464`	`{`
`465`	`465`	`Expression left = ParseIn();`
`466`	`466`	`while (_textParser.CurrentToken.Id == TokenId.DoubleAmphersand \|\| TokenIdentifierIs("and"))`
`467`	`467`	`{`
`468`	`468`	`Token op = _textParser.CurrentToken;`
`469`	`469`	`_textParser.NextToken();`
`470`		`- Expression right = ParseComparison();`
	`470`	`+ Expression right = ParseComparisonOperator();`
`471`	`471`	`CheckAndPromoteOperands(typeof(ILogicalSignatures), op.Text, ref left, ref right, op.Pos);`
`472`	`472`	`left = Expression.AndAlso(left, right);`
`473`	`473`	`}`
`@@ -479,7 +479,7 @@ Expression ParseConditionalAnd()`
`479`	`479`	`// Adapted from ticket submitted by github user mlewis9548`
`480`	`480`	`Expression ParseIn()`
`481`	`481`	`{`
`482`		`- Expression left = ParseLogicalAndOr();`
	`482`	`+ Expression left = ParseLogicalAndOrOperator();`
`483`	`483`	`Expression accumulate = left;`
`484`	`484`
`485`	`485`	`while (TokenIdentifierIs("in"))`
`@@ -557,14 +557,14 @@ Expression ParseIn()`
`557`	`557`	`}`
`558`	`558`
`559`	`559`	`// &, \| bitwise operators`
`560`		`- Expression ParseLogicalAndOr()`
	`560`	`+ Expression ParseLogicalAndOrOperator()`
`561`	`561`	`{`
`562`		`- Expression left = ParseComparison();`
	`562`	`+ Expression left = ParseComparisonOperator();`
`563`	`563`	`while (_textParser.CurrentToken.Id == TokenId.Amphersand \|\| _textParser.CurrentToken.Id == TokenId.Bar)`
`564`	`564`	`{`
`565`	`565`	`Token op = _textParser.CurrentToken;`
`566`	`566`	`_textParser.NextToken();`
`567`		`- Expression right = ParseComparison();`
	`567`	`+ Expression right = ParseComparisonOperator();`
`568`	`568`
`569`	`569`	`if (left.Type.GetTypeInfo().IsEnum)`
`570`	`570`	`{`
`@@ -600,9 +600,9 @@ Expression ParseLogicalAndOr()`
`600`	`600`	`}`
`601`	`601`
`602`	`602`	`// =, ==, !=, <>, >, >=, <, <= operators`
`603`		`- Expression ParseComparison()`
	`603`	`+ Expression ParseComparisonOperator()`
`604`	`604`	`{`
`605`		`- Expression left = ParseShift();`
	`605`	`+ Expression left = ParseShiftOperator();`
`606`	`606`	`while (_textParser.CurrentToken.Id == TokenId.Equal \|\| _textParser.CurrentToken.Id == TokenId.DoubleEqual \|\|`
`607`	`607`	`_textParser.CurrentToken.Id == TokenId.ExclamationEqual \|\| _textParser.CurrentToken.Id == TokenId.LessGreater \|\|`
`608`	`608`	`_textParser.CurrentToken.Id == TokenId.GreaterThan \|\| _textParser.CurrentToken.Id == TokenId.GreaterThanEqual \|\|`
`@@ -612,7 +612,7 @@ Expression ParseComparison()`
`612`	`612`	`TypeConverter typeConverter;`
`613`	`613`	`Token op = _textParser.CurrentToken;`
`614`	`614`	`_textParser.NextToken();`
`615`		`- Expression right = ParseShift();`
	`615`	`+ Expression right = ParseShiftOperator();`
`616`	`616`	`bool isEquality = op.Id == TokenId.Equal \|\| op.Id == TokenId.DoubleEqual \|\| op.Id == TokenId.ExclamationEqual;`
`617`	`617`
`618`	`618`	`if (isEquality && (!left.Type.GetTypeInfo().IsValueType && !right.Type.GetTypeInfo().IsValueType \|\| left.Type == typeof(Guid) && right.Type == typeof(Guid)))`
`@@ -728,7 +728,7 @@ private object ParseConstantExpressionToEnum(int pos, Type leftType, ConstantExp`
`728`	`728`	`}`
`729`	`729`
`730`	`730`	`// <<, >> operators`
`731`		`- Expression ParseShift()`
	`731`	`+ Expression ParseShiftOperator()`
`732`	`732`	`{`
`733`	`733`	`Expression left = ParseAdditive();`
`734`	`734`	`while (_textParser.CurrentToken.Id == TokenId.DoubleLessThan \|\| _textParser.CurrentToken.Id == TokenId.DoubleGreaterThan)`
`@@ -1113,6 +1113,7 @@ Expression ParseIif()`
`1113`	`1113`	`Expression[] args = ParseArgumentList();`
`1114`	`1114`	`if (args.Length != 3)`
`1115`	`1115`	`throw ParseError(errorPos, Res.IifRequiresThreeArgs);`
	`1116`	`+`
`1116`	`1117`	`return GenerateConditional(args[0], args[1], args[2], errorPos);`
`1117`	`1118`	`}`
`1118`	`1119`
`@@ -1138,6 +1139,7 @@ Expression GenerateConditional(Expression test, Expression expr1, Expression exp`
`1138`	`1139`	`string type2 = expr2 != NullLiteral ? expr2.Type.Name : "null";`
`1139`	`1140`	`if (expr1As2 != null)`
`1140`	`1141`	`throw ParseError(errorPos, Res.BothTypesConvertToOther, type1, type2);`
	`1142`	`+`
`1141`	`1143`	`throw ParseError(errorPos, Res.NeitherTypeConvertsToOther, type1, type2);`
`1142`	`1144`	`}`
`1143`	`1145`	`}`
`@@ -1257,6 +1259,7 @@ Expression ParseLambdaInvocation(LambdaExpression lambda)`
`1257`	`1259`	`MethodBase method;`
`1258`	`1260`	`if (FindMethod(lambda.Type, "Invoke", false, args, out method) != 1)`
`1259`	`1261`	`throw ParseError(errorPos, Res.ArgsIncompatibleWithLambda);`
	`1262`	`+`
`1260`	`1263`	`return Expression.Invoke(lambda, args);`
`1261`	`1264`	`}`
`1262`	`1265`
`@@ -1268,6 +1271,7 @@ Expression ParseTypeAccess(Type type)`
`1268`	`1271`	`{`
`1269`	`1272`	`if (!type.GetTypeInfo().IsValueType \|\| IsNullableType(type))`
`1270`	`1273`	`throw ParseError(errorPos, Res.TypeHasNoNullableForm, GetTypeName(type));`
	`1274`	`+`
`1271`	`1275`	`type = typeof(Nullable<>).MakeGenericType(type);`
`1272`	`1276`	`_textParser.NextToken();`
`1273`	`1277`	`}`