Пример #1
0
        public void TestParameterisedCtors()
        {
            var fm = new ParameterizedEnumDelegateMap <LongFlags, string, int>(new Dictionary <LongFlags, Func <LongFlags, string, int> >
            {
                {
                    LongFlags.Two,
                    (flags, s) =>
                    {
                        s.ShouldBeEquivalentTo("testString");
                        return(42);
                    }
                }
            });

            fm.ExecuteExactMatch(LongFlags.Two, "testString").ShouldBeEquivalentTo(42);
            fm.ExecuteExactMatch(LongFlags.Three, "doesn't matter").ShouldBeEquivalentTo(default(LongFlags));

            fm = new ParameterizedEnumDelegateMap <LongFlags, string, int>(new Dictionary <LongFlags, Func <LongFlags, string, int> >
            {
                {
                    LongFlags.Two,
                    (flags, s) =>
                    {
                        s.ShouldBeEquivalentTo("testString");
                        return(42);
                    }
                }
            },
                                                                           (f, s) => 13);
            fm.ExecuteExactMatch(LongFlags.Two, "testString").ShouldBeEquivalentTo(42);
            fm.ExecuteExactMatch(LongFlags.Three, "doesn't mater").ShouldBeEquivalentTo(13);
        }
Пример #2
0
        public void TestParameterised()
        {
            var fm = new ParameterizedEnumDelegateMap <LongFlags, string, int>();

            fm.AssignToExactValue(LongFlags.Two, (f, s) =>
            {
                s.ShouldBeEquivalentTo("testString");
                f.ShouldBeEquivalentTo(LongFlags.Two);
                return(42);
            });
            fm.ExecuteExactMatch(LongFlags.Two, "testString").ShouldBeEquivalentTo(42);
            fm.ExecuteExactMatch(LongFlags.Three, "noTestString").ShouldBeEquivalentTo(default(int));
        }
Пример #3
0
        public void TestParameterisedCanExecuteFlags()
        {
            var fm  = new ParameterizedEnumDelegateMap <LongFlags, string, int>();
            var fm1 = new ParameterizedEnumDelegateMap <LongFlags, string, string, int>((a, b, c) =>
            {
                b.ShouldBeEquivalentTo("b");
                c.ShouldBeEquivalentTo("c");
                return(42);
            });

            fm1.ExecuteExactMatch(LongFlags.Five, "b", "c").ShouldBeEquivalentTo(42);

            fm.AssignToEachFlag(LongFlags.Eight | LongFlags.Five, (f, s) =>
            {
                s.ShouldBeEquivalentTo("testString");
                return(42);
            });

            var dic = fm.ExecuteFlagsMatches(LongFlags.Five, "testString");

            dic.Count.ShouldBeEquivalentTo(1);
            dic[LongFlags.Five].ShouldBeEquivalentTo(42);
            dic = fm.ExecuteFlagsMatches(LongFlags.Eight | LongFlags.Five, "testString");
            dic.Count.ShouldBeEquivalentTo(2);
            dic[LongFlags.Five].ShouldBeEquivalentTo(42);
            dic[LongFlags.Eight].ShouldBeEquivalentTo(42);

            LongFlags.Nine.EqualsAny(LongFlags.Five, LongFlags.Eight).Should().BeFalse();
            fm.AssignToExactValue(LongFlags.Nine, (f, s) =>
            {
                f.ShouldBeEquivalentTo(LongFlags.Eight | LongFlags.Five | LongFlags.Nine);
                s.ShouldBeEquivalentTo("testString");
                return(41);
            });
            dic = fm.ExecuteFlagsMatches(LongFlags.Eight | LongFlags.Five | LongFlags.Nine, "testString");
            dic.Count.ShouldBeEquivalentTo(3);
            dic[LongFlags.Five].ShouldBeEquivalentTo(42);
            dic[LongFlags.Eight].ShouldBeEquivalentTo(42);
            dic[LongFlags.Nine].ShouldBeEquivalentTo(41);
            fm.ExecuteExactMatch(LongFlags.Four, "testString").ShouldBeEquivalentTo(default(LongFlags));
        }
        public void TestParameterisedCanExecuteFlags()
        {
            var fm = new ParameterizedEnumDelegateMap<LongFlags, string, int>();
            var fm1 = new ParameterizedEnumDelegateMap<LongFlags, string, string, int>((a, b, c) =>
                                                                                        {
                                                                                            b.ShouldBeEquivalentTo("b");
                                                                                            c.ShouldBeEquivalentTo("c");
                                                                                            return 42;
                                                                                        });
            fm1.ExecuteExactMatch(LongFlags.Five, "b", "c").ShouldBeEquivalentTo(42);

            fm.AssignToEachFlag(LongFlags.Eight | LongFlags.Five, (f, s) =>
                                {
                                    s.ShouldBeEquivalentTo("testString");
                                    return 42;
                                });

            var dic = fm.ExecuteFlagsMatches(LongFlags.Five, "testString");
            dic.Count.ShouldBeEquivalentTo(1);
            dic[LongFlags.Five].ShouldBeEquivalentTo(42);
            dic = fm.ExecuteFlagsMatches(LongFlags.Eight | LongFlags.Five, "testString");
            dic.Count.ShouldBeEquivalentTo(2);
            dic[LongFlags.Five].ShouldBeEquivalentTo(42);
            dic[LongFlags.Eight].ShouldBeEquivalentTo(42);

            LongFlags.Nine.EqualsAny(LongFlags.Five, LongFlags.Eight).Should().BeFalse();
            fm.AssignToExactValue(LongFlags.Nine, (f,s) =>
                                  {
                                      f.ShouldBeEquivalentTo(LongFlags.Eight | LongFlags.Five | LongFlags.Nine);
                                      s.ShouldBeEquivalentTo("testString");
                                      return 41;
                                  });
            dic = fm.ExecuteFlagsMatches(LongFlags.Eight | LongFlags.Five | LongFlags.Nine, "testString");
            dic.Count.ShouldBeEquivalentTo(3);
            dic[LongFlags.Five].ShouldBeEquivalentTo(42);
            dic[LongFlags.Eight].ShouldBeEquivalentTo(42);
            dic[LongFlags.Nine].ShouldBeEquivalentTo(41);
            fm.ExecuteExactMatch(LongFlags.Four, "testString").ShouldBeEquivalentTo(default(LongFlags));
        }
 public void TestParameterisedCtors()
 {
     var fm = new ParameterizedEnumDelegateMap<LongFlags, string, int>(new Dictionary<LongFlags, Func<LongFlags, string, int>>
                                                                       {
         {
             LongFlags.Two,
             (flags, s) => 
             {
                 s.ShouldBeEquivalentTo("testString");
             return 42;
             }
         }
                                                                       });
     fm.ExecuteExactMatch(LongFlags.Two, "testString").ShouldBeEquivalentTo(42);
     fm.ExecuteExactMatch(LongFlags.Three, "doesn't matter").ShouldBeEquivalentTo(default(LongFlags));
     
     fm = new ParameterizedEnumDelegateMap<LongFlags, string, int>(new Dictionary<LongFlags, Func<LongFlags, string, int>>
                                                                   {
                                                                       {
                                                                           LongFlags.Two,
                                                                           (flags, s) =>
                                                                           {
                                                                               s.ShouldBeEquivalentTo("testString");
                                                                               return 42;
                                                                           }
                                                                       }
                                                                   },
                                                                   (f, s) => 13);
     fm.ExecuteExactMatch(LongFlags.Two, "testString").ShouldBeEquivalentTo(42);
     fm.ExecuteExactMatch(LongFlags.Three, "doesn't mater").ShouldBeEquivalentTo(13);
 }
 public void TestParameterisedWithDefaults()
 {
     var fm = new ParameterizedEnumDelegateMap<LongFlags, string, int>((f, s) =>
                                                                       {
                                                                           s.ShouldBeEquivalentTo("noTestString");
                                                                           f.ShouldBeEquivalentTo(LongFlags.Three);
                                                                           return 1;
                                                                       });
     fm.AssignToExactValue(LongFlags.Two, (f, s) =>
                           {
                               s.ShouldBeEquivalentTo("testString");
                               f.ShouldBeEquivalentTo(LongFlags.Two);
                               return 42;
                           });
     fm.ExecuteExactMatch(LongFlags.Two, "testString").ShouldBeEquivalentTo(42);
     fm.ExecuteExactMatch(LongFlags.Three, "noTestString").ShouldBeEquivalentTo(1);
 }