Exemplo n.º 1
0
        public void TestPatternMatch()
        {
            {
                Erlang.Object pattern = Erlang.Object.Format("{test, A, B, C}");
                Erlang.Object obj     = Erlang.Object.Format("{test, 10, a, [1,2,3]}");

                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Assert.IsTrue(pattern.match(obj, binding));
                Assert.AreEqual(3, binding.Count);
                Assert.AreEqual(10, binding["A"].longValue());
                Assert.AreEqual("a", binding["B"].atomValue());
                Assert.AreEqual("[1,2,3]", binding["C"].ToString());
            }
        }
Exemplo n.º 2
0
        public void TestMatchVariable()
        {
            var cases = new KeyValueList <string, Erlang.Object> {
                { "B", new Erlang.Int(1) },
                { "B", new Erlang.Atom("abc") },
                { "B", new Erlang.String("efg") },
                { "B", new Erlang.Double(10.0) },
                { "B::int()", new Erlang.Int(10) },
                { "B::integer()", new Erlang.Int(20) },
                { "B::string()", new Erlang.String("xxx") },
                { "B::atom()", new Erlang.Atom("xyz") },
                { "B::float()", new Erlang.Double(5.0) },
                { "B::double()", new Erlang.Double(3.0) },
                { "B::binary()", new Erlang.Binary(new byte[] { 1, 2, 3 }) },
                { "B::bool()", new Erlang.Boolean(true) },
                { "B::boolean()", new Erlang.Boolean(false) },
                { "B::byte()", new Erlang.Byte(1) },
                { "B::char()", new Erlang.Char('a') },
                { "B::list()", new Erlang.List(1, 2, 3) },
                { "B::tuple()", new Erlang.Tuple(new Erlang.Char('a'), 1, "aaa") },
                { "B::pid()", new Erlang.Pid("xxx", 1, 2, 3) },
                { "B::ref()", new Erlang.Ref("xxx", 1, 3) },
                { "B::reference()", new Erlang.Ref("xxx", 1, 3) },
                { "B::port()", new Erlang.Port("xxx", 1, 3) }
            };

            foreach (var p in cases)
            {
                {
                    Erlang.Object pat = Erlang.Object.Format(p.Key);
                    Erlang.Object obj = p.Value;

                    var binding = new Erlang.VarBind();
                    binding["B"] = obj;

                    Assert.IsTrue(pat.match(obj, binding));
                }

                {
                    Erlang.Object pat = Erlang.Object.Format(p.Key);
                    Erlang.Object obj = p.Value;

                    var binding = new Erlang.VarBind();

                    Assert.IsTrue(pat.match(obj, binding));

                    var b = binding["B"];

                    Assert.AreEqual(obj.Type, b.Type);
                    Assert.IsTrue(obj.Equals(b));
                }
            }

            var revCases = cases.Reverse <KeyValuePair <string, Erlang.Object> >().ToList();

            cases.Zip(revCases,
                      (p1, p2) => {
                Erlang.Var pat    = Erlang.Object.Format(p1.Key).AsVar();
                Erlang.Object obj = p2.Value;

                var binding = new Erlang.VarBind();

                if (pat.VarTermType == Erlang.TermType.Object || pat.VarTermType == obj.TermType)
                {
                    Assert.IsTrue(pat.match(obj, binding));
                }
                else
                {
                    Assert.IsFalse(pat.match(obj, binding));
                }

                return(false);
            }).ToList();
        }
Exemplo n.º 3
0
        public void TestPatternMatch()
        {
            {
                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Erlang.Object  obj     = Erlang.Object.Format("{snapshot, x12, []}");
                Erlang.Object  pat     = Erlang.Object.Format("{snapshot, N, L}");

                Assert.IsTrue(pat.match(obj, binding));
                Erlang.Atom n = binding.find("N") as Erlang.Atom;
                Erlang.List l = binding.find("L") as Erlang.List;
                Assert.IsNotNull(n);
                Assert.IsNotNull(l);
                Assert.IsTrue(l.Length == 0);
            }
            {
                Erlang.Object pat = Erlang.Object.Format("{test, A, B, C}");
                Erlang.Object obj = Erlang.Object.Format("{test, 10, a, [1,2,3]}");

                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Assert.IsTrue(pat.match(obj, binding));
                Assert.AreEqual(3, binding.Count);
                Assert.AreEqual(10, binding["A"].longValue());
                Assert.AreEqual("a", binding["B"].atomValue());
                Assert.AreEqual("[1,2,3]", binding["C"].ToString());
            }

            {
                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Erlang.Object  obj     = Erlang.Object.Format("[1,a,$b,\"xyz\",{1,10.0},[]]");
                Erlang.Object  pat     = Erlang.Object.Format("[A,B,C,D,E,F]");

                Assert.IsTrue(pat.match(obj, binding));
                Assert.IsNotNull(binding.find("A") as Erlang.Long);
                Assert.IsNotNull(binding.find("B") as Erlang.Atom);
                Assert.IsNotNull(binding.find("C") as Erlang.Char);
                Assert.IsNotNull(binding.find("D") as Erlang.String);
                Assert.IsNotNull(binding.find("E") as Erlang.Tuple);
                Assert.IsNotNull(binding.find("F") as Erlang.List);

                Assert.IsTrue(binding.find("E").Cast <Erlang.Tuple>().arity() == 2);
                Assert.IsTrue(binding.find("F").Cast <Erlang.List>().Length == 0);
            }

            Erlang.Object pattern = Erlang.Object.Format("{test, T}");
            string        exp     = "{test, ~w}";
            {
                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Erlang.Object  obj     = Erlang.Object.Format(exp, (int)3);
                Assert.IsTrue(pattern.match(obj, binding));
                Assert.AreEqual(3, binding.find("T").intValue());
            }
            {
                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Erlang.Object  obj     = Erlang.Object.Format(exp, (long)100);
                Assert.IsTrue(pattern.match(obj, binding));
                Assert.AreEqual(100, binding.find("T").longValue());
            }
            {
                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Erlang.Object  obj     = Erlang.Object.Format(exp, 100.0);
                Assert.IsTrue(pattern.match(obj, binding));
                Assert.AreEqual(100.0, binding.find("T").doubleValue());
            }
            {
                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Erlang.Object  obj     = Erlang.Object.Format(exp, "test");
                Assert.IsTrue(pattern.match(obj, binding));
                Assert.AreEqual("test", binding.find("T").stringValue());
            }
            {
                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Erlang.Object  obj     = Erlang.Object.Format(exp, true);
                Assert.IsTrue(pattern.match(obj, binding));
                Assert.AreEqual(true, binding.find("T").boolValue());
            }
            {
                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Erlang.Object  obj     = Erlang.Object.Format(exp, 'c');
                Assert.IsTrue(pattern.match(obj, binding));
                Assert.AreEqual('c', binding.find("T").charValue());
            }
            {
                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Erlang.Pid     pid     = new Erlang.Pid("tmp", 1, 2, 3);
                Erlang.Object  obj     = Erlang.Object.Format(exp, pid as Erlang.Object);
                Assert.IsTrue(pattern.match(obj, binding));
                Assert.AreEqual(pid, binding.find("T").pidValue());

                obj = Erlang.Object.Format(exp, pid);
                Assert.IsTrue(pattern.match(obj, binding));
                Assert.AreEqual(pid, binding.find("T").pidValue());
            }
            {
                Erlang.VarBind binding   = new Otp.Erlang.VarBind();
                Erlang.Ref     reference = new Erlang.Ref("tmp", 1, 2);
                Erlang.Object  obj       = Erlang.Object.Format(exp, reference);
                Assert.IsTrue(pattern.match(obj, binding));
                Assert.AreEqual(reference, binding.find("T").refValue());
            }
            {
                Erlang.VarBind binding = new Otp.Erlang.VarBind();
                Erlang.List    obj     = new Erlang.List(new Erlang.Int(10), new Erlang.Double(30.0),
                                                         new Erlang.String("abc"), new Erlang.Atom("a"),
                                                         new Erlang.Binary(new byte[] { 1, 2, 3 }), false, new Erlang.Boolean(true));
                Erlang.Object pat = Erlang.Object.Format("T");
                Assert.IsTrue(pat.match(obj, binding));
                Erlang.Object expected = Erlang.Object.Format("[10, 30.0, \"abc\", 'a', ~w, \'false\', true]",
                                                              new Erlang.Binary(new byte[] { 1, 2, 3 }));
                Erlang.Object result = binding.find("T");
                Assert.IsTrue(expected.Equals(result));
            }
        }