public void AJson_JsonBuilding_CanBuildWithNullSimpleProperty()
        {
            Json json = JsonHelper.BuildJsonForObject(
                new NullTester <string>
            {
                NumberProp = 8,
                NullProp   = null
            }
                );

            Assert.IsNotNull(json);
            Assert.IsFalse(json.HasErrors, "Json parse errors:\n" + String.Join("\n\t", json.Errors));
            Assert.IsTrue(json.Data.IsDocument, "Json should have parsed an array");

            NullTester <string> created = JsonHelper.BuildObjectForJson <NullTester <string> >(json);

            Assert.IsNotNull(created);
            Assert.AreEqual(8, created.NumberProp);
            Assert.IsNull(created.NullProp);
        }
        private object ApplyOperation(Expr ast)
        {
            dynamic leftExec = Exec(ast.Left);

            var left = leftExec is ValueMemory ? (leftExec as ValueMemory).Value : leftExec;

            // short circuit
            if (ast.Token.TokenType == TokenType.Or)
            {
                if (left is bool && left == true)
                {
                    return(true);
                }
            }

            if (ast.Token.TokenType == TokenType.Compare)
            {
                if (left is bool && left == false)
                {
                    return(false);
                }
            }

            dynamic rightExec = Exec(ast.Right);


            var right = rightExec is ValueMemory ? (rightExec as ValueMemory).Value : rightExec;

            switch (ast.Token.TokenType)
            {
            case TokenType.Compare:
                if (left is TokenType || right is TokenType)
                {
                    return(NullTester.NullEqual(left, right));
                }

                return(left == right);

            case TokenType.NotCompare:
                if (left is TokenType || right is TokenType)
                {
                    return(!NullTester.NullEqual(left, right));
                }
                return(left != right);

            case TokenType.GreaterThan:
                return(left > right);

            case TokenType.LessThan:
                return(left < right);

            case TokenType.Plus:
                return(left + right);

            case TokenType.Minus:
                return(left - right);

            case TokenType.Slash:
                return(left / right);

            case TokenType.Carat:
                return(left ^ right);

            case TokenType.Ampersand:
                return(left && right);

            case TokenType.Or:
                return(left || right);
            }

            return(null);
        }