예제 #1
0
        public async Task ShouldFindAllPrices()
        {
            Dictionary <string, double> expected = new Dictionary <string, double>
            {
                ["bk101"] = 44.95,
                ["bk102"] = 5.95,
                ["bk103"] = 5.95,
                ["bk104"] = 5.95,
                ["bk105"] = 5.95,
                ["bk106"] = 4.95,
                ["bk107"] = 4.95,
                ["bk108"] = 4.95,
                ["bk109"] = 6.95,
                ["bk110"] = 36.95,
                ["bk111"] = 36.95,
                ["bk112"] = 49.95
            };

            using (Stream source = ResourceFactory.Open("Books"))
            {
                XenonReader reader = new XenonReader(source, "book");
                Dictionary <string, double?> found = new Dictionary <string, double?>();

                await reader.Process(document =>
                {
                    found.Add(document.Get("id").ToString(), document.Get("price").ToDouble());
                });

                Assert.That(found, Is.EquivalentTo(expected));
            }
        }
예제 #2
0
        public async Task ShouldFindAllTitles()
        {
            Dictionary <string, string> expected = new Dictionary <string, string>
            {
                ["bk101"] = "XML Developer's Guide",
                ["bk102"] = "Midnight Rain",
                ["bk103"] = "Maeve Ascendant",
                ["bk104"] = "Oberon's Legacy",
                ["bk105"] = "The Sundered Grail",
                ["bk106"] = "Lover Birds",
                ["bk107"] = "Splish Splash",
                ["bk108"] = "Creepy Crawlies",
                ["bk109"] = "Paradox Lost",
                ["bk110"] = "Microsoft .NET: The Programming Bible",
                ["bk111"] = "MSXML3: A Comprehensive Guide",
                ["bk112"] = "Visual Studio 7: A Comprehensive Guide"
            };

            using (Stream source = ResourceFactory.Open("Books"))
            {
                XenonReader reader = new XenonReader(source, "book");
                Dictionary <string, string> found = new Dictionary <string, string>();

                await reader.Process(document =>
                {
                    dynamic data = document.GetDynamic();

                    found.Add(data.id.ToString(), data.title.ToString());
                });

                Assert.That(found, Is.EquivalentTo(expected));
            }
        }
예제 #3
0
        public async Task ShouldFindAllDates()
        {
            Dictionary <string, DateTime> expected = new Dictionary <string, DateTime>
            {
                ["bk101"] = DateTime.Parse("2000-10-01"),
                ["bk102"] = DateTime.Parse("2000-12-16"),
                ["bk103"] = DateTime.Parse("2000-11-17"),
                ["bk104"] = DateTime.Parse("2001-03-10"),
                ["bk105"] = DateTime.Parse("2001-09-10"),
                ["bk106"] = DateTime.Parse("2000-09-02"),
                ["bk107"] = DateTime.Parse("2000-11-02"),
                ["bk108"] = DateTime.Parse("2000-12-06"),
                ["bk109"] = DateTime.Parse("2000-11-02"),
                ["bk110"] = DateTime.Parse("2000-12-09"),
                ["bk111"] = DateTime.Parse("2000-12-01"),
                ["bk112"] = DateTime.Parse("2001-04-16")
            };

            using (Stream source = ResourceFactory.Open("Books"))
            {
                XenonReader reader = new XenonReader(source, "book");
                Dictionary <string, DateTime?> found = new Dictionary <string, DateTime?>();

                await reader.Process(document =>
                {
                    found.Add(document.Get("id").ToString(), document.Get("publish_date").ToDateTime());
                });

                Assert.That(found, Is.EquivalentTo(expected));
            }
        }
예제 #4
0
        public async Task ShouldEnumerateAllRevisionsInAllPages()
        {
            HashSet <long> expected = new HashSet <long>
            {
                607051494, 607051522, 607082459, 609806417, 610782955, 615708849,
                607051549, 607053970, 607057294, 607057676, 607064502, 607064697,
                607065037, 616919844, 645443958, 645444002, 653021729, 653021968,
                653022435, 653783525, 674703256, 674719566, 675614952, 679157456,
                682724788, 682952438
            };

            using (Stream source = ResourceFactory.Open("History"))
            {
                HashSet <long?> found  = new HashSet <long?>();
                XenonReader     reader = new XenonReader(source, "page");

                await reader.Process(document =>
                {
                    foreach (XenonNode node in document.GetEnumerable("revision"))
                    {
                        found.Add(node.Get("id").ToInt64());
                    }
                });

                Assert.That(found, Is.EquivalentTo(expected));
            }
        }
예제 #5
0
        public async Task ShouldPreserveWhiteCharactersByDefault()
        {
            const string data = @"<data> 123 </data>";

            using (Stream source = ResourceFactory.Inline(data))
            {
                XenonReader reader = new XenonReader(source, "data");

                await reader.Process(document =>
                {
                    Assert.That(document.ToString(), Is.EqualTo(" 123 "));
                });
            }
        }
예제 #6
0
        public async Task ShouldHandleMissingProperty()
        {
            const string data = @"<data><first></first></data>";

            using (Stream source = ResourceFactory.Inline(data))
            {
                XenonReader reader = new XenonReader(source, "data");

                await reader.Process(document =>
                {
                    Assert.That(document.Get("second"), Is.Null);
                });
            }
        }
예제 #7
0
        public async Task ShouldDetectExistingProperty()
        {
            const string data = @"<data><first></first></data>";

            using (Stream source = ResourceFactory.Inline(data))
            {
                XenonReader reader = new XenonReader(source, "data");

                await reader.Process(document =>
                {
                    Assert.That(document.Has("first"), Is.True);
                });
            }
        }
예제 #8
0
파일: TestInvoke.cs 프로젝트: amacal/xenon
        public void BenchmarkDynamic(string scenario, string node, Action <dynamic> callback)
        {
            Stopwatch watch   = Stopwatch.StartNew();
            TimeSpan  started = Process.GetCurrentProcess().TotalProcessorTime;

            using (FileStream stream = File.OpenRead(path))
            {
                XenonReader reader = new XenonReader(stream, node, 4 * 1024 * 1024);

                reporter.Benchmarking(scenario, "xenon-dynamic");
                reader.Process(callback).Wait();
                reporter.Complete(scenario, "xenon-dynamic", watch.Elapsed, Process.GetCurrentProcess().TotalProcessorTime - started);
            }
        }
예제 #9
0
        public async Task ShouldParseDateTimeWithAdditionalWhiteCharacters()
        {
            const string data = "<data>\n 2007-12-31\n </data>";

            using (Stream source = ResourceFactory.Inline(data))
            {
                XenonReader reader = new XenonReader(source, "data");

                await reader.Process(document =>
                {
                    Assert.That(document.ToDateTime(), Is.InstanceOf <DateTime>());
                    Assert.That(document.ToDateTime(), Is.EqualTo(new DateTime(2007, 12, 31)));
                });
            }
        }
예제 #10
0
        public async Task ShouldParseDoubleWithAdditionalWhiteCharacters()
        {
            const string data = "<data>\n 123.45\n </data>";

            using (Stream source = ResourceFactory.Inline(data))
            {
                XenonReader reader = new XenonReader(source, "data");

                await reader.Process(document =>
                {
                    Assert.That(document.ToDouble(), Is.InstanceOf <Double>());
                    Assert.That(document.ToDouble(), Is.EqualTo(123.45d));
                });
            }
        }
예제 #11
0
        public async Task ShouldOmitWhiteCharacters()
        {
            const string data = @"<data> 123 </data>";

            using (Stream source = ResourceFactory.Inline(data))
            {
                XenonReader         reader = new XenonReader(source, "data");
                XenonWhiteCharacter mode   = XenonWhiteCharacter.Omit;

                await reader.Process(document =>
                {
                    Assert.That(document.ToString(mode), Is.EqualTo("123"));
                });
            }
        }
예제 #12
0
        public async Task ShouldParseInt64()
        {
            const string data = "<data>123</data>";

            using (Stream source = ResourceFactory.Inline(data))
            {
                XenonReader reader = new XenonReader(source, "data");

                await reader.Process(document =>
                {
                    Assert.That(document.ToInt64(), Is.InstanceOf <Int64>());
                    Assert.That(document.ToInt64(), Is.EqualTo(123));
                });
            }
        }
예제 #13
0
        public async Task ShouldFindOneCatalog()
        {
            using (Stream source = ResourceFactory.Open("Books"))
            {
                int         counter = 0;
                XenonReader reader  = new XenonReader(source, "catalog");

                await reader.Process(document =>
                {
                    counter++;
                });

                Assert.That(counter, Is.EqualTo(1));
            }
        }
예제 #14
0
        public async Task ShouldAccessNestedElement()
        {
            const string data = @"<data><first><second>abc</second></first></data>";

            using (Stream source = ResourceFactory.Inline(data))
            {
                XenonReader reader = new XenonReader(source, "data");

                await reader.Process(document =>
                {
                    Assert.That(document.Get("first"), Is.Not.Null);
                    Assert.That(document.Get("first").Get("second"), Is.Not.Null);
                    Assert.That(document.Get("first").Get("second").ToString(), Is.EqualTo("abc"));
                });
            }
        }
예제 #15
0
        public async Task ShouldEnumerateMissingProperty()
        {
            const string data = @"<data><first></first></data>";

            using (Stream source = ResourceFactory.Inline(data))
            {
                XenonReader reader = new XenonReader(source, "data");

                await reader.Process(document =>
                {
                    foreach (XenonNode node in document.GetEnumerable("second"))
                    {
                        Assert.Fail();
                    }
                });
            }
        }
예제 #16
0
        public async Task ShouldEnumerateMixedProperty()
        {
            const string data = "<data node=\"abc\"><node/><node/></data>";

            using (Stream source = ResourceFactory.Inline(data))
            {
                int         counter = 0;
                XenonReader reader  = new XenonReader(source, "data");

                await reader.Process(document =>
                {
                    foreach (XenonNode node in document.GetEnumerable("node"))
                    {
                        counter++;
                    }
                });

                Assert.That(counter, Is.EqualTo(3));
            }
        }
예제 #17
0
        public async Task ShouldEnumerateExistingPropertyOnce()
        {
            const string data = @"<data><first></first></data>";

            using (Stream source = ResourceFactory.Inline(data))
            {
                int         counter = 0;
                XenonReader reader  = new XenonReader(source, "data");

                await reader.Process(document =>
                {
                    foreach (XenonNode node in document.GetEnumerable("first"))
                    {
                        counter++;
                    }
                });

                Assert.That(counter, Is.EqualTo(1));
            }
        }
예제 #18
0
        public async Task ShouldFindAllIdentifiers()
        {
            HashSet <string> expected = new HashSet <string>
            {
                "bk101", "bk102", "bk103", "bk104", "bk105", "bk106",
                "bk107", "bk108", "bk109", "bk110", "bk111", "bk112",
            };

            using (Stream source = ResourceFactory.Open("Books"))
            {
                HashSet <string> found  = new HashSet <string>();
                XenonReader      reader = new XenonReader(source, "book");

                await reader.Process(document =>
                {
                    found.Add(document.GetDynamic().id.ToString());
                });

                Assert.That(found, Is.EquivalentTo(expected));
            }
        }
예제 #19
0
        public async Task ShouldEnumerateAllBooks()
        {
            HashSet <string> expected = new HashSet <string>
            {
                "bk101", "bk102", "bk103", "bk104", "bk105", "bk106",
                "bk107", "bk108", "bk109", "bk110", "bk111", "bk112",
            };

            using (Stream source = ResourceFactory.Open("Books"))
            {
                HashSet <string> found  = new HashSet <string>();
                XenonReader      reader = new XenonReader(source, "catalog");

                await reader.Process(document =>
                {
                    foreach (XenonNode node in document.GetEnumerable("book"))
                    {
                        found.Add(node.Get("id").ToString());
                    }
                });

                Assert.That(found, Is.EquivalentTo(expected));
            }
        }
예제 #20
0
        public async Task ShouldFindAllContributors()
        {
            HashSet <string> expected = new HashSet <string>
            {
                "Darkreason", "Invertzoo", "Auric", "Mx. Granger",
                "OccultZone", "Yserbius", "AnomieBOT"
            };

            using (Stream source = ResourceFactory.Open("History"))
            {
                HashSet <string> found  = new HashSet <string>();
                XenonReader      reader = new XenonReader(source, "contributor");

                await reader.Process(document =>
                {
                    if (document.Has("username"))
                    {
                        found.Add(document.Get("username").ToString());
                    }
                });

                Assert.That(found, Is.EquivalentTo(expected));
            }
        }