Example #1
0
    public static void Main () {
        var ints = new[] { 1, 2, 3, 4 };

        Console.WriteLine(ints.Last());

        Console.WriteLine(ints.Last((i) => i < 3));

        // Test the non-IList path
        Console.WriteLine(ints.Skip(1).Last());

        Console.WriteLine(ints.Skip(1).Last((i) => i < 3));
    }
Example #2
0
        public void EmptySequenceIsReturnedWhenSourceContainsFewerThanCountElements()
        {
            var source = new[] { 1 };
            var result = source.Skip(2);

            Assert.That(result, Is.EqualTo(Enumerable.Empty<Int32>()));
        }
 public void AdjacentElements()
 {
     IEnumerableWithCount<string> elements = new[] { "a", "b", "c", "d", "e" }.AsEnumerableWithCount();
     IEnumerableWithCount<string> query = elements.Zip(elements.Skip(1), (x, y) => x + y);
     Assert.AreEqual(4, query.Count);
     query.AssertSequenceEqual("ab", "bc", "cd", "de");
 }
Example #4
0
        public void E_SlicingArrays()
        {
            var array = new[] { "peanut", "butter", "and", "jelly" };

            Assert.AreEqual(new string[] { (string)FILL_ME_IN, (string)FILL_ME_IN }, array.Take(2).ToArray());
            Assert.AreEqual(new string[] { (string)FILL_ME_IN, (string)FILL_ME_IN }, array.Skip(1).Take(2).ToArray());
        }
Example #5
0
    public static void Main () {
        var ints = new[] { 1, 2, 3, 4 };

        foreach (var i in ints.Skip(2))
            Console.WriteLine(i);

    }
 private void ReadSubItems(System.Xml.XmlReader reader, ArrayList result, bool securityTrimmingEnabled)
 {
     int depth = reader.Depth + 1;
     while (reader.Read())
     {
         if (reader.Depth == depth)
         {
             if (reader.NodeType == System.Xml.XmlNodeType.Element)
             {
                 var aResult = ReadResult(reader, securityTrimmingEnabled);
                 if (aResult != null)
                     result.Add(aResult);
             }
             else if (reader.NodeType == XmlNodeType.EndElement)
             {
             }
         }
         else if (reader.Depth > depth)
         {
             reader.Skip();
         }
         else if (reader.Depth < depth)
         {
             break;
         }
     }
 }
Example #7
0
File: Auth.cs Project: liquidboy/X
        void IFlickrParsable.Load(System.Xml.XmlReader reader)
        {
            reader.Read();

            while (reader.LocalName != "auth")
            {
                switch (reader.LocalName)
                {
                    case "token":
                        Token = reader.ReadElementContentAsString();
                        break;
                    case "perms":
                        Permissions = (AuthLevel)Enum.Parse(typeof(AuthLevel), reader.ReadElementContentAsString(), true);
                        break;
                    case "user":
                        User = new FoundUser();
                        ((IFlickrParsable)User).Load(reader);
                        break;
                    default:
                        UtilityMethods.CheckParsingException(reader);
                        reader.Skip();
                        break;
                }
            }
        }
Example #8
0
        void IFlickrParsable.Load(System.Xml.XmlReader reader)
        {
            Load(reader, false);

            if (reader.LocalName != "stats")
            {
                UtilityMethods.CheckParsingException(reader);
            }

            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                    case "views":
                        StatViews = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                        break;
                    case "comments":
                        StatComments = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                        break;
                    case "favorites":
                        StatFavorites = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                        break;
                    default:
                        UtilityMethods.CheckParsingException(reader);
                        break;
                }
            }

            reader.Read();

            if (reader.LocalName == "description")
                Description = reader.ReadElementContentAsString();

            reader.Skip();
        }
Example #9
0
        public void ReadFromStreamWithDefaultColumnsShouldHandleFirstRowAsRowData()
        {
            DataTableBuilder builder = new DataTableBuilder();
            var stream = new MemoryStream();
            var sw = new StreamWriter(stream);
            var rows = new[] { "first,row,is,data", "second,row,is,johnny", "second,row,was,laura", };
            foreach (var row in rows)
            {
                sw.WriteLine(row);
            }

            sw.Flush();
            stream.Seek(0, SeekOrigin.Begin);
            try
            {
                var lazy = builder.ReadLazy(stream, rows[0].Split(','));
                Assert.Equal(rows[0].Split(','), lazy.ColumnNames);
                var rowEnumerator = rows.Skip(0).GetEnumerator();
                rowEnumerator.MoveNext();
                var rowCount = 0;
                foreach (var row in lazy.Rows)
                {
                    Assert.Equal(rowEnumerator.Current, string.Join(",", row.Values));
                    rowEnumerator.MoveNext();
                    rowCount++;
                }

                Assert.Equal(rows.Length, rowCount);
            }
            finally
            {
                sw.Dispose();
                stream.Dispose();
            }
        }
Example #10
0
        void IFlickrParsable.Load(System.Xml.XmlReader reader)
        {
            if (reader.LocalName != "referrer")
                UtilityMethods.CheckParsingException(reader);

            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                    case "url":
                        Url = reader.Value;
                        break;
                    case "searchterm":
                        SearchTerm = reader.Value;
                        break;
                    case "views":
                        Views = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                        break;
                    default:
                        UtilityMethods.CheckParsingException(reader);
                        break;
                }
            }

            reader.Skip();
        }
Example #11
0
File: Stats.cs Project: liquidboy/X
        void IFlickrParsable.Load(System.Xml.XmlReader reader)
        {
            if (reader.LocalName != "stats")
            {
                UtilityMethods.CheckParsingException(reader);
            }

            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                    case "views":
                        Views = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                        break;
                    case "comments":
                        Comments = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                        break;
                    case "favorites":
                        Favorites = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                        break;
                    default:
                        UtilityMethods.CheckParsingException(reader);
                        break;
                }
            }

            reader.Skip();
        }
Example #12
0
        void IFlickrParsable.Load(System.Xml.XmlReader reader)
        {
            if (reader.LocalName != "place_type")
                UtilityMethods.CheckParsingException(reader);

            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                    case "place_type_id":
                    case "id":
                        Id = reader.ReadContentAsInt();
                        break;
                    default:
                        UtilityMethods.CheckParsingException(reader);
                        break;
                }
            }

            reader.Read();

            Name = reader.ReadContentAsString();

            reader.Skip();
        }
 public void Skip_SkipsItems()
 {
     var orderedQueryable = new[] { "1", "3", "6", "2", "8" }.AsQueryable().OrderBy(i => i);
     var orderedSource = new OrderedSource<string>(orderedQueryable);
     var expected = orderedQueryable.Skip(2).ToList();
     var actual = orderedSource.Skip(2).ToList();
     CollectionAssert.AreEquivalent(expected, actual);
 }
Example #14
0
        public void AllElementsOfSourceAreYieldedWhenCountIsLessThanOrEqualToZero()
        {
            var source = new[] { 1 };
            var result = source.Skip(0);
            var expected = new[] { 1 };

            Assert.That(result, Is.EqualTo(expected));
        }
Example #15
0
        public void ElementsBeforeCountAreSkipped()
        {
            var source = new[] { 1, 2, 3, 4, 5 };
            var result = source.Skip(3);
            var expected = new[] { 4, 5 };

            Assert.That(result, Is.EqualTo(expected));
        }
        void IFlickrParsable.Load(System.Xml.XmlReader reader)
        {
            FavoriteThumbnailUrl = reader.GetAttribute("thumb");
            FavoriteUrl = reader.GetAttribute("url");

            Load(reader, true);

            reader.Skip();
        }
Example #17
0
 private void Example()
 {
     var input = new[] { 1, 2, 3, 4, 5 };
     var result = input.First();
     foreach (var item in input.Skip(1))
     {
         if (result < item)
         {
             result = item;
         }
     }
 }
        public static IList<Drawing.Point> ToVAPoints(MG.Core.Layout.Edge edge)
        {

            if (edge.Curve is MG.Core.Geometry.Curves.Curve)
            {
                var curve = (MG.Core.Geometry.Curves.Curve)edge.Curve;

                var final_bez_points = new List<Drawing.Point> { MsaglUtil.ToVAPoint(edge.Curve.Start) };

                foreach (var cur_seg in curve.Segments)
                {
                    if (cur_seg is MG.Core.Geometry.Curves.CubicBezierSegment)
                    {
                        var bezier_seg = (MG.Core.Geometry.Curves.CubicBezierSegment)cur_seg;

                        var bez_points =
                            new[] { 0, 1, 2, 3 }
                                .Select(bezier_seg.B)
                                .Select(MsaglUtil.ToVAPoint)
                                .ToArray();

                        final_bez_points.AddRange(bez_points.Skip(1));
                    }
                    else if (cur_seg is MG.Core.Geometry.Curves.LineSegment)
                    {
                        var line_seg = (MG.Core.Geometry.Curves.LineSegment)cur_seg;
                        final_bez_points.Add(MsaglUtil.ToVAPoint(line_seg.Start));
                        final_bez_points.Add(MsaglUtil.ToVAPoint(line_seg.End));
                        final_bez_points.Add(MsaglUtil.ToVAPoint(line_seg.End));
                    }
                    else
                    {
                        throw new InvalidOperationException("Unsupported Curve Segment type");
                    }
                }

                return final_bez_points;
                
            }
            else if (edge.Curve is MG.Core.Geometry.Curves.LineSegment)
            {
                var final_bez_points = new List<Drawing.Point> { MsaglUtil.ToVAPoint(edge.Curve.Start) };
                var line_seg = (MG.Core.Geometry.Curves.LineSegment)edge.Curve;
                final_bez_points.Add(MsaglUtil.ToVAPoint(line_seg.Start));
                final_bez_points.Add(MsaglUtil.ToVAPoint(line_seg.End));
                final_bez_points.Add(MsaglUtil.ToVAPoint(line_seg.End));
                return final_bez_points;
                
            }

            throw new Exception();
        }
Example #19
0
        void IFlickrParsable.Load(System.Xml.XmlReader reader)
        {
            if (reader.LocalName != "photoset")
                UtilityMethods.CheckParsingException(reader);

            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                    case "id":
                        PhotosetId = reader.Value;
                        break;
                    case "primary":
                        PrimaryPhotoId = reader.Value;
                        break;
                    case "owner":
                        OwnerId = reader.Value;
                        break;
                    case "ownername":
                        OwnerName = reader.Value;
                        break;
                    case "page":
                        Page = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                        break;
                    case "total":
                        Total = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                        break;
                    case "pages":
                        Pages = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                        break;
                    case "perpage":
                    case "per_page":
                        PerPage = int.Parse(reader.Value, System.Globalization.NumberFormatInfo.InvariantInfo);
                        break;
                    default:
                        UtilityMethods.CheckParsingException(reader);
                        break;
                }
            }

            reader.Read();

            while (reader.LocalName == "photo")
            {
                Photo photo = new Photo();
                ((IFlickrParsable)photo).Load(reader);
                if (String.IsNullOrEmpty(photo.UserId)) photo.UserId = OwnerId;
                Add(photo);
            }

            reader.Skip();
        }
Example #20
0
        void IFlickrParsable.Load(System.Xml.XmlReader reader)
        {
            Load(reader, false);

            if (reader.LocalName == "comment")
                Comment = reader.ReadElementContentAsString();

            if (reader.LocalName == "description")
                Description = reader.ReadElementContentAsString();

            if (reader.NodeType == System.Xml.XmlNodeType.EndElement && reader.LocalName == "photo")
                reader.Skip();
        }
Example #21
0
 public void OrderBy_DoesNotSort_WhenExpressionsIsNull()
 {
     var data = new[]
     {
         new User { Name = "user2" },
         new User { Name = "user3" },
         new User { Name = "user1" },
     };
     var orderedQueryable = data.AsQueryable().OrderBy(null);
     orderedQueryable.Count().ShouldEqual(3);
     orderedQueryable.First().ShouldEqual(data.First());
     orderedQueryable.Skip(1).First().ShouldEqual(data.Skip(1).First());
     orderedQueryable.Last().ShouldEqual(data.Last());
 }
Example #22
0
 public Quadrangle(int s1, int s2, int s3, int s4)
 {
     int[] nSides = new[] {s1, s2, s3, s4};
     if (nSides.Any(x_ => x_ <= 0))
         throw new GeometryException(nSides, "Отрицательная сторона прямоугольника");
     for (int i = 0; i < 4; i++)
     {
         if (nSides[i] >= nSides.Skip(i).Sum())
             throw new GeometryException(nSides, "Сторона больше суммы трёх других");
     }
     for (int i = 0; i < nSides.Length; i++)
     {
         _sides[i] = nSides[i];
     }
 }
Example #23
0
        public void should_get_unmatched_nodes(string name, StringComparison comparison, int count)
        {
            var results = new[] { new Node("oh"), new Node("hai") }
                .GetUnmatchedNodes(new[] { new Node(name), new Node("crap") },
                                    comparison);

            results.ShouldTotal(count);

            if (count == 1) results.First().Name.ShouldEqual("hai");
            else
            {
                results.First().Name.ShouldEqual("oh");
                results.Skip(1).First().Name.ShouldEqual("hai");
            }
        }
        public void CleanupAutosaves()
        {
            var zipFileNames = new[] {"2703165731_2703170058.zip", "2703165731_2703170118.zip", "2703165731_2703170408.zip", "2703165731_2703170434.zip", "2703165731_2703170633.zip"};

            foreach (var zipFileName in zipFileNames)
                File.Copy(Path.Combine(testFileFolderPath, zipFileName), Path.Combine(autosaveFolderPath, zipFileName));

            SettingsAutosaver.CleanupAutosaves(autosaveFolderPath, 4);

            var residualFiles = Directory.GetFiles(autosaveFolderPath);
            Assert.AreEqual(4, residualFiles.Length);

            foreach (var residualFile in residualFiles)
                if (!zipFileNames.Skip(1).Contains(residualFile.Split('\\').Last()))
                    Assert.Fail("файл с именем {0} не должен был быть удалён", residualFile);
        }
        static void Main(string[] args)
        {
            var points = new[] {1,2,3,4,5,6};

            //start at point 1, end at point 6

            var solutions = new List<int[]>();

            var pointsToEnumerate = points.Skip(1).Take(4).ToArray();

            foreach (var point in pointsToEnumerate)
            {
                var pointsToSpan = pointsToEnumerate.Where(p => p != point).ToArray();
                var solution = new List<int>(point);
            }
        }
Example #26
0
        void IFlickrParsable.Load(System.Xml.XmlReader reader)
        {
            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                    case "label":
                        Label = reader.Value;
                        break;
                    case "offset":
                        Offset = reader.Value;
                        break;
                }
            }

            reader.Skip();
        }
Example #27
0
 public void OrderBy_SortsSimpleQueryable_Ascending()
 {
     var data = new[]
     {
         new User { Name = "user2" },
         new User { Name = "user3" },
         new User { Name = "user1" },
     };
     var orderBy = new Dictionary<Expression<Func<User, object>>, OrderByDirection>
     {
         { x => x.Name, OrderByDirection.Ascending },
     };
     var orderedQueryable = data.AsQueryable().OrderBy(orderBy);
     orderedQueryable.Count().ShouldEqual(3);
     orderedQueryable.First().ShouldEqual(data.Last());
     orderedQueryable.Skip(1).First().ShouldEqual(data.First());
     orderedQueryable.Last().ShouldEqual(data.Skip(1).First());
 }
        public async Task Can_scale_out()
        {
            var servers = new[]
            {
                new SampleSignalRServer(8100, 18100, new[] {18101, 18102}),
                new SampleSignalRServer(8101, 18101, new[] {18100, 18102}),
                new SampleSignalRServer(8102, 18102, new[] {18100, 18101})
            };

            var cients = new[]
            {
                new SampleSignalRClient(8100),
                new SampleSignalRClient(8101),
                new SampleSignalRClient(8102)
            };

            const string message = "Hello";

            var messagesReceived = Task.WhenAll(cients
                .Skip(1)
                .Select(s =>
                {
                    var tcs = new TaskCompletionSource<string>();
                    s.Messages.Subscribe(tcs.SetResult);
                    return tcs.Task;
                })
                .ToArray());

            var stopwatch = Stopwatch.StartNew();
            await cients[0].Send(message);

            var timeoutTask = Task.Delay(3000);

            if(await Task.WhenAny(messagesReceived, timeoutTask) == timeoutTask)
            {
                throw new TimeoutException("Timed out waiting for message");
            }
            Console.WriteLine(stopwatch.ElapsedMilliseconds);

            foreach (var server in servers)
            {
                server.Dispose();
            }
        }
Example #29
0
        public void ReadFromTextReaderWithDefaultColumnsShouldHandleFirstRowAsRowData()
        {
            // arrange
            var tmpFile = Path.GetTempFileName();

            var rows = new[] { "first,row,is,data", "second,row,is,johnny", "second,row,was,laura", };

            using (var sw = new StreamWriter(tmpFile))
            {
                foreach (var row in rows)
                {
                    sw.WriteLine(row);
                }

                sw.Flush();
            }

            // act
            try
            {
                var builder = new DataTableBuilder();
                var lazy = builder.ReadLazy(tmpFile, rows[0].Split(','));
                Assert.Equal(rows[0].Split(','), lazy.ColumnNames);
                var rowEnumerator = rows.Skip(0).GetEnumerator();
                rowEnumerator.MoveNext();
                var rowCount = 0;

                // assert
                foreach (var row in lazy.Rows)
                {
                    Assert.Equal(rowEnumerator.Current, string.Join(",", row.Values));
                    rowEnumerator.MoveNext();
                    rowCount++;
                }

                Assert.Equal(rows.Length, rowCount);
            }
            finally
            {
                // cleanup
                File.Delete(tmpFile);
            }
        }
        public void WhenNameSpecified_FiltersListByWildcard()
        {
            // Arrange
            GetPackageSourceCommand cmd = new GetPackageSourceCommand().AutoConfigure();
            var mockService = new Mock<PackageSourceService>() { CallBase = true };
            cmd.SourceService = mockService.Object;
            cmd.Name = "*ar";

            PackageSource[] expected = new[] {
                new PackageSource("http://foo.bar", "Foo"),
                new PackageSource("http://bar.baz", "Bar"),
                new PackageSource("http://baz.boz", "Qar")
            };
            mockService.Setup(s => s.AllSources).Returns(expected);

            // Act
            PackageSource[] actual = cmd.Execute().ObjectStream.Cast<PackageSource>().ToArray();

            // Assert
            Assert.Equal(expected.Skip(1).ToArray(), actual);
        }