Clean up Operators and Deployment

.appveyor.yml

@@ -8,4 +8,7 @@ build_script:
 
 test: off
 
+artifacts:
+  - path: '**\bin\*\*.nupkg'
+
 skip_branch_with_pr: true

Dynamitey/Dynamic.cs

@@ -284,14 +284,10 @@ public static dynamic InvokeUnaryOpartor(ExpressionType op, dynamic arg)
                     return !arg;
                 case ExpressionType.Negate:
                     return -arg;
-                case ExpressionType.PreDecrementAssign:
+                case ExpressionType.Decrement:
                     return --arg;
-                case ExpressionType.PreIncrementAssign:
+                case ExpressionType.Increment:
                     return ++arg;
-                case ExpressionType.PostDecrementAssign:
-                    return arg--;
-                case ExpressionType.PostIncrementAssign:
-                    return arg++;
                 default:
                     throw new ArgumentException("Unsupported Operator", "op");
             }

Dynamitey/Dynamitey.csproj

@@ -6,8 +6,8 @@
     <Company>Ekon Benefits</Company>
     <Authors />
     <Copyright>Copyright 2017 Ekon Benefits</Copyright>
-    <AssemblyVersion>2.0.1.0</AssemblyVersion>
-    <FileVersion>2.0.1.0</FileVersion>
+    <AssemblyVersion>2.0.2.0</AssemblyVersion>
+    <FileVersion>2.0.2.0</FileVersion>
     <PackageProjectUrl>https://github.com/ekonbenefits/dynamitey</PackageProjectUrl>
     <PackageLicenseUrl>http://www.apache.org/licenses/LICENSE-2.0</PackageLicenseUrl>
     <PackageTags>dynamic metaprogramming dlr reflection currying tuples expando latetypes</PackageTags>
@@ -18,7 +18,7 @@
     <SignAssembly>True</SignAssembly>
     <AssemblyOriginatorKeyFile>sn.snk</AssemblyOriginatorKeyFile>
     <DelaySign>False</DelaySign>
-    <Version>2.0.1-alpha</Version>
+    <Version>2.0.2-alpha</Version>
 
   </PropertyGroup>
 

Tests/Invoke.cs

@@ -1360,9 +1360,9 @@ private DynamicObject CreateMock(ExpressionType op)
             return tMock.Object;
         }
 
-        public class BinaryTestDynObject:DynamicObject{
+        public class OperatorTestDynObject:DynamicObject{
             ExpressionType _type;
-            public BinaryTestDynObject(ExpressionType type){
+            public OperatorTestDynObject(ExpressionType type){
                 _type = type;
             }
 
@@ -1372,28 +1372,68 @@ public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg
                 return true;
             }
 
+            public override bool TryUnaryOperation(UnaryOperationBinder binder, out object result){
+                Assert.AreEqual(_type, binder.Operation);
+                result = _type;
+                return true;
+            }
+
         }
-         private void RunMockTests(ExpressionType type){
-            var mock = new BinaryTestDynObject(type);
+         private void RunBinaryMockTests(ExpressionType type){
+            var mock = new OperatorTestDynObject(type);
             var dummy = new Object();
             Dynamic.InvokeBinaryOperator(mock, type, dummy);
         }
 
+        private void RunUnaryMockTests(ExpressionType type){
+            var mock = new OperatorTestDynObject(type);
+            Dynamic.InvokeUnaryOpartor(type,mock);
+        }
+
         [Test]
         public void TestInvokeAdd()
         {
             Assert.AreEqual(Dynamic.InvokeBinaryOperator(1, ExpressionType.Add, 2), 3);
         }
 
-
+        [Test]
+        public void TestInvokeBasicUnaryOperatorsDynamic()
+        {
+            RunUnaryMockTests(ExpressionType.Not);
+            RunUnaryMockTests(ExpressionType.Negate);
+            RunUnaryMockTests(ExpressionType.Increment);
+            RunUnaryMockTests(ExpressionType.Decrement);
+
+
+
+        }
 
         [Test]
         public void TestInvokeBasicBinaryOperatorsDynamic()
         {
-            RunMockTests(ExpressionType.Add);
-            RunMockTests(ExpressionType.Subtract);
-            RunMockTests(ExpressionType.Divide);
-            RunMockTests(ExpressionType.Multiply);
+            RunBinaryMockTests(ExpressionType.Add);
+            RunBinaryMockTests(ExpressionType.Subtract);
+            RunBinaryMockTests(ExpressionType.Divide);
+            RunBinaryMockTests(ExpressionType.Multiply);
+            RunBinaryMockTests(ExpressionType.Modulo);
+
+            RunBinaryMockTests(ExpressionType.And);
+            RunBinaryMockTests(ExpressionType.Or);
+            RunBinaryMockTests(ExpressionType.ExclusiveOr);
+            RunBinaryMockTests(ExpressionType.LeftShift);
+            RunBinaryMockTests(ExpressionType.RightShift);
+
+            RunBinaryMockTests(ExpressionType.AddAssign);
+            RunBinaryMockTests(ExpressionType.SubtractAssign);
+            RunBinaryMockTests(ExpressionType.DivideAssign);
+            RunBinaryMockTests(ExpressionType.MultiplyAssign);
+            RunBinaryMockTests(ExpressionType.ModuloAssign);
+
+            RunBinaryMockTests(ExpressionType.AndAssign);
+            RunBinaryMockTests(ExpressionType.OrAssign);
+            RunBinaryMockTests(ExpressionType.ExclusiveOrAssign);
+            RunBinaryMockTests(ExpressionType.LeftShiftAssign);
+            RunBinaryMockTests(ExpressionType.RightShiftAssign);
         }