// [Fact]
        public void ResultSelectorNullNoComparer()
        {
            CustomerRec[] outer = new CustomerRec[]
            {
                new CustomerRec {
                    name = "Tim", custID = 1234
                },
                new CustomerRec {
                    name = "Bob", custID = 9865
                },
                new CustomerRec {
                    name = "Robert", custID = 9895
                }
            };
            AnagramRec[] inner = new AnagramRec[]
            {
                new AnagramRec {
                    name = "Robert", orderID = 93483, total = 19
                },
                new AnagramRec {
                    name = "miT", orderID = 93489, total = 45
                }
            };

            Assert.Throws <ArgumentNullException>("resultSelector", () => outer.GroupJoin(inner, e => e.name, e => e.name, (Func <CustomerRec, IEnumerable <AnagramRec>, JoinRec>)null));
        }
Beispiel #2
0
            // Overload-2: Test when IEqualityComparer is null
            public static int Test9()
            {
                CustomerRec[] outer = new CustomerRec[] { new CustomerRec {
                                                              name = "Tim", custID = 1234
                                                          },
                                                          new CustomerRec {
                                                              name = "Bob", custID = 9865
                                                          },
                                                          new CustomerRec {
                                                              name = "Robert", custID = 9895
                                                          } };
                AnagramRec[] inner = new AnagramRec[] { new AnagramRec {
                                                            name = "Robert", orderID = 93483, total = 19
                                                        },
                                                        new AnagramRec {
                                                            name = "miT", orderID = 93489, total = 45
                                                        } };
                JoinRec[] expected = new JoinRec[] { new JoinRec {
                                                         name = "Tim", orderID = new int?[] {}, total = new int?[] {}
                                                     },
                                                     new JoinRec {
                                                         name = "Bob", orderID = new int?[] {}, total = new int?[] {}
                                                     },
                                                     new JoinRec {
                                                         name = "Robert", orderID = new int?[] { 93483 }, total = new int?[] { 19 }
                                                     } };
                Func <CustomerRec, IEnumerable <AnagramRec>, JoinRec> resultSelector = Helper.createJoinRec;

                var actual = outer.GroupJoin(inner, (e) => e.name, (o) => o.name, resultSelector, null);

                return(Helper.DataEqual(expected, actual));
            }
        // [Fact]
        public void InnerKeySelectorNullNoComparer()
        {
            CustomerRec[] outer = new CustomerRec[]
            {
                new CustomerRec {
                    name = "Tim", custID = 1234
                },
                new CustomerRec {
                    name = "Bob", custID = 9865
                },
                new CustomerRec {
                    name = "Robert", custID = 9895
                }
            };
            AnagramRec[] inner = new AnagramRec[]
            {
                new AnagramRec {
                    name = "Robert", orderID = 93483, total = 19
                },
                new AnagramRec {
                    name = "miT", orderID = 93489, total = 45
                }
            };

            Assert.Throws <ArgumentNullException>("innerKeySelector", () => outer.GroupJoin(inner, e => e.name, null, createJoinRec));
        }
Beispiel #4
0
        public void InnerKeySelectorNullNoComparer()
        {
            CustomerRec[] outer = new CustomerRec[]
            {
                new CustomerRec {
                    name = "Tim", custID = 1234
                },
                new CustomerRec {
                    name = "Bob", custID = 9865
                },
                new CustomerRec {
                    name = "Robert", custID = 9895
                }
            };
            AnagramRec[] inner = new AnagramRec[]
            {
                new AnagramRec {
                    name = "Robert", orderID = 93483, total = 19
                },
                new AnagramRec {
                    name = "miT", orderID = 93489, total = 45
                }
            };

            Assert.Throws <ArgumentNullException>("innerKeySelector", () => outer.AsQueryable().GroupJoin(inner.AsQueryable(), e => e.name, null, (cr, arIE) => new JoinRec {
                name = cr.name, orderID = arIE.Select(o => o.orderID).ToArray(), total = arIE.Select(o => o.total).ToArray()
            }));
        }
Beispiel #5
0
        public void ResultSelectorNull()
        {
            CustomerRec[] outer = new CustomerRec[]
            {
                new CustomerRec {
                    name = "Tim", custID = 1234
                },
                new CustomerRec {
                    name = "Bob", custID = 9865
                },
                new CustomerRec {
                    name = "Robert", custID = 9895
                }
            };
            AnagramRec[] inner = new AnagramRec[]
            {
                new AnagramRec {
                    name = "Robert", orderID = 93483, total = 19
                },
                new AnagramRec {
                    name = "miT", orderID = 93489, total = 45
                }
            };

            AssertExtensions.Throws <ArgumentNullException>("resultSelector", () => outer.AsNaturalQueryable().GroupJoin(inner.AsNaturalQueryable(), e => e.name, e => e.name, (Expression <Func <CustomerRec, IEnumerable <AnagramRec>, JoinRec> >)null, new AnagramEqualityComparer()));
        }
Beispiel #6
0
            // Overload-2: Test when resultSelector is null
            public static int Test11e()
            {
                CustomerRec[] outer = new CustomerRec[] { new CustomerRec {
                                                              name = "Tim", custID = 1234
                                                          },
                                                          new CustomerRec {
                                                              name = "Bob", custID = 9865
                                                          },
                                                          new CustomerRec {
                                                              name = "Robert", custID = 9895
                                                          } };
                AnagramRec[] inner = new AnagramRec[] { new AnagramRec {
                                                            name = "Robert", orderID = 93483, total = 19
                                                        },
                                                        new AnagramRec {
                                                            name = "miT", orderID = 93489, total = 45
                                                        } };
                Func <CustomerRec, IEnumerable <AnagramRec>, JoinRec> resultSelector = Helper.createJoinRec;

                try
                {
                    resultSelector = null;
                    var actual = outer.GroupJoin(inner, (e) => e.name, (o) => o.name, resultSelector, new AnagramEqualityComparer());
                    return(1);
                }
                catch (ArgumentNullException ane)
                {
                    if (!ane.CompareParamName("resultSelector"))
                    {
                        return(1);
                    }
                    return(0);
                }
            }
Beispiel #7
0
            // Overload-2: Test when resultSelector=null
            public static int Test13e()
            {
                CustomerRec[] outer = new CustomerRec[] { new CustomerRec {
                                                              name = "Prakash", custID = 98022
                                                          },
                                                          new CustomerRec {
                                                              name = "Tim", custID = 99021
                                                          },
                                                          new CustomerRec {
                                                              name = "Robert", custID = 99022
                                                          } };
                AnagramRec[] inner = new AnagramRec[] { new AnagramRec {
                                                            name = "miT", orderID = 43455, total = 10
                                                        },
                                                        new AnagramRec {
                                                            name = "Prakash", orderID = 323232, total = 9
                                                        } };
                Func <CustomerRec, AnagramRec, JoinRec> resultSelector = Helper.createJoinRec;

                try
                {
                    resultSelector = null;
                    var actual = outer.Join(inner, (e) => e.name, (o) => o.name, resultSelector, new AnagramEqualityComparer());
                    return(1);
                }
                catch (ArgumentNullException ane)
                {
                    if (!ane.CompareParamName("resultSelector"))
                    {
                        return(1);
                    }
                    return(0);
                }
            }
Beispiel #8
0
            // Overload-2: Test when IEqualityComparer is not-null
            public static int Test12()
            {
                CustomerRec[] outer = new CustomerRec[] { new CustomerRec {
                                                              name = "Prakash", custID = 98022
                                                          },
                                                          new CustomerRec {
                                                              name = "Tim", custID = 99021
                                                          },
                                                          new CustomerRec {
                                                              name = "Robert", custID = 99022
                                                          } };
                AnagramRec[] inner = new AnagramRec[] { new AnagramRec {
                                                            name = "miT", orderID = 43455, total = 10
                                                        },
                                                        new AnagramRec {
                                                            name = "Prakash", orderID = 323232, total = 9
                                                        } };
                JoinRec[] expected = new JoinRec[] { new JoinRec {
                                                         name = "Prakash", orderID = 323232, total = 9
                                                     },
                                                     new JoinRec {
                                                         name = "Tim", orderID = 43455, total = 10
                                                     } };
                Func <CustomerRec, AnagramRec, JoinRec> resultSelector = Helper.createJoinRec;

                var actual = outer.Join(inner, (e) => e.name, (o) => o.name, resultSelector, new AnagramEqualityComparer());

                return(Verification.Allequal(expected, actual));
            }
Beispiel #9
0
            public static JoinRec createJoinRec(CustomerRec cr, AnagramRec or)
            {
                JoinRec jr = new JoinRec();

                jr.name    = cr.name;
                jr.orderID = or.orderID;
                jr.total   = or.total;

                return(jr);
            }
        // [Fact]
        public void OuterNullNoComparer()
        {
            CustomerRec[] outer = null;
            AnagramRec[]  inner = new AnagramRec[]
            {
                new AnagramRec {
                    name = "Robert", orderID = 93483, total = 19
                },
                new AnagramRec {
                    name = "miT", orderID = 93489, total = 45
                }
            };

            Assert.Throws <ArgumentNullException>("outer", () => outer.GroupJoin(inner, e => e.name, e => e.name, createJoinRec));
        }
Beispiel #11
0
        public void OuterNullNoComparer()
        {
            IQueryable <CustomerRec> outer = null;

            AnagramRec[] inner = new AnagramRec[]
            {
                new AnagramRec {
                    name = "Robert", orderID = 93483, total = 19
                },
                new AnagramRec {
                    name = "miT", orderID = 93489, total = 45
                }
            };

            Assert.Throws <ArgumentNullException>("outer", () => outer.GroupJoin(inner.AsQueryable(), e => e.name, e => e.name, (cr, arIE) => new JoinRec {
                name = cr.name, orderID = arIE.Select(o => o.orderID).ToArray(), total = arIE.Select(o => o.total).ToArray()
            }));
        }
Beispiel #12
0
 public static JoinRec createJoinRec(CustomerRec cr, AnagramRec or)
 {
     return(new JoinRec {
         name = cr.name, orderID = or.orderID, total = or.total
     });
 }
Beispiel #13
0
 public static JoinRec createJoinRec(CustomerRec cr, AnagramRec or)
 {
     return new JoinRec { name = cr.name, orderID = or.orderID, total = or.total };
 }