Beispiel #1
0
        public void Test_VariantEqualOp()
        {
            LispVariant variant1 = new LispVariant(4.3);
            LispVariant variant2 = new LispVariant(56.1);

            Assert.IsFalse(LispVariant.EqualOp(variant1, variant2));
            Assert.IsTrue(LispVariant.EqualOp(variant1, variant1));
        }
Beispiel #2
0
        public void Test_VariantCastError()
        {
            LispVariant variant = new LispVariant(4.3);

            Assert.IsNotNull(variant);
            int value = variant.IntValue;

            Assert.AreEqual(4, value);      // will not be evaluated because of expected exception !
        }
Beispiel #3
0
        public void Test_VariantOperations()
        {
            LispVariant variant1 = new LispVariant(4.3);
            LispVariant variant2 = new LispVariant(56.1);
            LispVariant variant3 = new LispVariant(42);
            LispVariant variant4 = new LispVariant(45);

            Assert.AreEqual(1890, (variant3 * variant4).ToInt());
            Assert.AreEqual(60.4, (variant1 + variant2).ToDouble());
        }
Beispiel #4
0
        static void ExecuteFuelScript(string script)
        {
            var model = new TestModel("fuel");

            // create a dictionary with name <--> object pairs
            // the objects will be registered under the name in the fuel interpreter
            var nativeItems = new Dictionary <string, object>();

            nativeItems["model"] = model;

            LispVariant result = Lisp.Eval(script, nativeItems: nativeItems);

            Console.WriteLine("Script result={0}", result);
        }
Beispiel #5
0
        public void Test_VariantCompare()
        {
            LispVariant variant1 = new LispVariant(4.3);
            LispVariant variant2 = new LispVariant(56.1);
            LispVariant variant3 = new LispVariant(42);
            LispVariant variant4 = new LispVariant("abc");

            Assert.IsTrue(variant1.CompareTo(variant2) < 0);
            Assert.IsTrue(variant2.CompareTo(variant1) > 0);
            Assert.IsTrue(variant1.CompareTo(1.23) > 0);
            Assert.IsTrue(variant1.CompareTo(-5) > 0);
            Assert.IsTrue(variant3.CompareTo(42) == 0);
            Assert.IsTrue(variant4.CompareTo("abc") == 0);
            Assert.IsTrue(variant4.CompareTo("xyz") < 0);
        }
Beispiel #6
0
        public void Test_VariantConvert()
        {
            LispVariant variant1 = new LispVariant(4.3);
            LispVariant variant2 = new LispVariant(56.1);
            LispVariant variant3 = new LispVariant(42);
            LispVariant variant4 = new LispVariant("4.5");
            LispVariant variant5 = new LispVariant(true);
            LispVariant variant6 = new LispVariant(LispType.Int, (object)0);

            Assert.AreEqual(true, variant1.ToBool());
            Assert.AreEqual(true, variant3.ToBool());
            Assert.AreEqual(false, variant6.ToBool());
            Assert.AreEqual(4.5, variant4.ToDouble());
            Assert.AreEqual(1.0, variant5.ToDouble());
            Assert.AreEqual(56, variant2.ToInt());
            Assert.AreEqual(true, variant2.ToBool());
        }
Beispiel #7
0
        public void Test_CreateVariant()
        {
            LispVariant variant = new LispVariant();

            Assert.IsNotNull(variant);

            variant = new LispVariant(3);
            Assert.IsTrue(variant.IsInt);
            Assert.AreEqual(3, variant.IntValue);

            variant = new LispVariant(3.1415);
            Assert.IsTrue(variant.IsDouble);
            Assert.AreEqual(3.1415, variant.DoubleValue);

            variant = new LispVariant("text");
            Assert.IsTrue(variant.IsString);
        }