Beispiel #1
0
        public void Evaluate(string input, string expected)
        {
            var parser      = new ExpressionEngine(Lookup);
            var original    = parser.Parse(input);
            var dnf         = original.DisjunctiveNormalForm();
            var expectedDnf = parser.Parse(expected);

            Assert.IsTrue(dnf.DeepEquals(expectedDnf), $"{original} is {dnf}, not {expectedDnf}");
        }
Beispiel #2
0
        public override Task <DialogTurnResult> BeginDialogAsync(DialogContext dc, object options = null, CancellationToken cancellationToken = default(CancellationToken))
        {
            var engine = new ExpressionEngine();

            var(arg1, err1) = engine.Parse(Arg1).TryEvaluate(dc.State);
            var(arg2, err2) = engine.Parse(Arg2).TryEvaluate(dc.State);

            var result = Convert.ToInt32(arg1) * Convert.ToInt32(arg2);

            if (this.ResultProperty != null)
            {
                dc.State.SetValue(this.ResultProperty, result);
            }

            return(dc.EndDialogAsync(result: result, cancellationToken: cancellationToken));
        }
Beispiel #3
0
        public void TestAccumulatePath()
        {
            var memory = new SimpleObjectMemory(new
            {
                f = "foo",
                b = "bar",
                z = new
                {
                    z = "zar"
                },
                n = 2
            });

            var parser = new ExpressionEngine();

            // normal case, note, we doesn't append a " yet
            var exp = parser.Parse("a[f].b[n].z");

            var(path, left, err) = BuiltInFunctions.TryAccumulatePath(exp, memory);
            Assert.AreEqual(path, "a['foo'].b[2].z");

            // normal case
            exp = parser.Parse("a[z.z][z.z].y");
            (path, left, err) = BuiltInFunctions.TryAccumulatePath(exp, memory);
            Assert.AreEqual(path, "a['zar']['zar'].y");

            // normal case
            exp = parser.Parse("a.b[z.z]");
            (path, left, err) = BuiltInFunctions.TryAccumulatePath(exp, memory);
            Assert.AreEqual(path, "a.b['zar']");

            // stop evaluate at middle
            exp = parser.Parse("json(x).b");
            (path, left, err) = BuiltInFunctions.TryAccumulatePath(exp, memory);
            Assert.AreEqual(path, "b");
        }
Beispiel #4
0
 public virtual void ValidateReply(Activity activity)
 {
     if (this.Assertions != null)
     {
         var engine = new ExpressionEngine();
         foreach (var assertion in this.Assertions)
         {
             var(result, error) = engine.Parse(assertion).TryEvaluate(activity);
             if ((bool)result != true)
             {
                 throw new Exception($"{this.Description} {assertion}");
             }
         }
     }
 }
Beispiel #5
0
 private void expressionEditor_TextChanged(Object sender, EventArgs e)
 {
     try
     {
         var memory = JsonConvert.DeserializeObject <Dictionary <string, object> >(dataEditor.Text);
         var(result, err)             = engine.Parse(expressionEditor.Text).TryEvaluate(memory);
         this.errorMessage.Text       = err;
         this.errorMessage.Visibility = err == null ? Visibility.Collapsed : Visibility.Visible;
         outputEditor.Text            = JsonConvert.SerializeObject(result, new JsonSerializerSettings()
         {
             Formatting = Formatting.Indented, NullValueHandling = NullValueHandling.Ignore
         });
     }
     catch (Exception err)
     {
         this.errorMessage.Text       = err.Message;
         this.errorMessage.Visibility = err == null ? Visibility.Collapsed : Visibility.Visible;
         outputEditor.Text            = string.Empty;
     }
 }