public void ReverseInvertsTheOrderOfElementsInASequence() { var source = new[] { 1, 2, 3 }; var result = source.Reverse(); var expected = new[] { 3, 2, 1 }; Assert.That(result, Is.EqualTo(expected)); }
public void TestWith9LinesInRevertedOrder() { var data = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; var input = string.Join(Environment.NewLine, data.Reverse()); var expectedOutput = string.Join(Environment.NewLine, data) + Environment.NewLine; var visitor = new SortAndTrimLinesVisitor(); var result = visitor.Visit(input); Assert.AreEqual(expectedOutput, result); }
public void TestCardinalityTwoPermutation() { var set = new[] { 42, 37 }; var permutations = set.Permutations(); // should contain two results: the set itself and its reverse Assert.IsTrue(permutations.Count() == 2); Assert.IsTrue(permutations.First().SequenceEqual(set)); Assert.IsTrue(permutations.Last().SequenceEqual(set.Reverse())); }
public void CanJoinSequencesWithAllMatchingKeys() { var left = new[] { 1, 2, 3, 4, 5 }; var right = left.Reverse(); var result = left .FullOuterJoin(right, l => l, r => r, (l, r, k) => l + r) .ToArray(); Assert.That(result, Is.EqualTo(new[] { 2, 4, 6, 8, 10 })); }
public void GenericReverseTestCase() { var array = new[] { "test", "test2" }; array.Reverse(); Assert.AreEqual( "test2", array[0] ); Assert.AreEqual( "test", array[1] ); }
public void ConstructorShouldInitializeFromSequence() { // arrange var expected = new[] { "1", "2", "3" }; // act var target = new ObservableStack<string>( expected ); // assert Assert.Equal( 3, target.Count ); Assert.True( target.SequenceEqual( expected.Reverse() ) ); }
public void Params_CombineInOrder_Test(int x, int y, int z, int k) { var codes = new[] { x, y, z, k }; var codesReverse = codes.Reverse().ToArray(); int hash1 = HashTool.Compute(codes); int hash2 = HashTool.Compute(codesReverse); if(ArrayTool.Compare(codes, codesReverse)) Assert.AreEqual(hash1, hash2, "hash1={0}, hash2={1}", hash1, hash2); else Assert.AreNotEqual(hash1, hash2, "hash1={0}, hash2={1}", hash1, hash2); }
public static ushort ReadWord(this Stream stream, List<byte> rawLog = null) { var buf = new[] { stream.ReadUnescapedByte(rawLog), stream.ReadUnescapedByte(rawLog), }; if (BitConverter.IsLittleEndian) buf = buf.Reverse().ToArray(); return BitConverter.ToUInt16(buf, 0); }
public void Parameters_orders_can_be_different_between_parse_and_invoke() { var target = new Interpreter(); var parameters = new[] { new Parameter("A", "A"), new Parameter("B", "B"), }; var lambda = target.Parse("A + B", parameters); Assert.AreEqual("AB", lambda.Invoke(parameters.Reverse())); }
public void SafeSequenceEqual_ArgsHaveSameElementsButOutOfSequence_ReturnFalse() { // ARRANGE var arg = new[]{ 1, 2 }; // ACT bool actual = EnumerableExtensions.SafeSequenceEqual(arg, arg.Reverse()); // ASSERT Assert.IsFalse(actual, "Args are out of sequence."); }
public void TestReverse() { var original = new[] {1.0, 1.4, 1.6, 2.0}; var expected = original.Reverse(); var actual = Utility.Reverse(original); Assert.IsTrue(original.Zip(actual, (first, second) => Math.Abs(first - second) > 0.001).All(eq => eq)); Assert.IsTrue(expected.Zip(actual, (first, second) => Math.Abs(first - second) < 0.001).All(eq => eq)); var original2 = new[] {1, 2, 3, 4}; var expected2 = original2.Reverse(); var actual2 = Utility.Reverse(original2); Assert.IsTrue(original2.Zip(actual2, (first, second) => first != second).All(eq => eq)); Assert.IsTrue(expected2.Zip(actual2, (first, second) => first == second).All(eq => eq)); }
public void CopyToShouldCopySourceStack() { // arrange var expected = new[] { new object(), new object(), new object() }; var source = new Stack<object>( expected ); var target = new StackAdapter<object>( source ); var actual = new object[3]; // act target.CopyTo( actual, 0 ); // assert Assert.True( actual.SequenceEqual( expected.Reverse() ) ); }
public void ReverseTestCase1() { Array array = new[] { "0", "1", "2" }; array.Reverse( 1, 2 ); Assert.AreEqual( "0", array.GetValue( 0 ) ); Assert.AreEqual( "2", array.GetValue( 1 ) ); Assert.AreEqual( "1", array.GetValue( 2 ) ); }
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { var colors = new[] { new { Level = 0, Color = Colors.Transparent }, new { Level = 1, Color = Colors.GreenYellow }, new { Level = 10, Color = Colors.MediumSeaGreen }, new { Level = 20, Color = Colors.Green }, new { Level = 30, Color = Colors.Orange }, new { Level = 45, Color = Colors.OrangeRed }, new { Level = 60, Color = Colors.Red } }; var level = (int)value; var least = colors .Reverse() .SkipWhile(color => color.Level > level) .FirstOrDefault(); var colorLevel = least ?? colors.First(); return new SolidColorBrush(colorLevel.Color); }
public async Task CanGetForRepositoryDescendingSort() { var pullRequest = await CreatePullRequest(_context); const int position = 1; var commentsToCreate = new[] { "Comment One", "Comment Two", "Comment Three", "Comment Four" }; await CreateComments(commentsToCreate, position, _context.RepositoryName, pullRequest.Sha, pullRequest.Number); var pullRequestComments = await _client.GetAllForRepository(Helper.UserName, _context.RepositoryName, new PullRequestReviewCommentRequest { Direction = SortDirection.Descending }); Assert.Equal(pullRequestComments.Select(x => x.Body), commentsToCreate.Reverse()); }
static int CreateBone(Document doc, Metasequoia.Object obj, CreateBonePointInfo info, bool newMaterial, string boneName) { var vertices = new[] { info.BeginVertexIndex != -1 ? info.BeginVertexIndex : obj.AddVertex(info.BeginWorld) }.Concat(new[] { info.EndWorld, info.HasSize ? info.SizeWorld : (Point?)null, } .Where(_ => _.HasValue) .Select(_ => obj.AddVertex(_.Value))) .ToArray(); if (vertices.Length == 3 && info.Flip) vertices = vertices.Reverse().ToArray(); var face = obj.AddFace(vertices); if (info.HasSize && newMaterial) { var r = new Random(); var mat = doc.Materials.Where(_ => _.Name == boneName) .Select(_ => (int?)_.Index) .FirstOrDefault() ?? doc.AddMaterial(new Material { Name = boneName, Alpha = (float)(0.5 + r.NextDouble() * 0.4), Color = new Color((float)r.NextDouble(), (float)r.NextDouble(), (float)r.NextDouble()), }); obj.SetFaceMaterial(face, mat); doc.CurrentMaterialIndex = mat; } else obj.SetFaceMaterial(face, doc.CurrentMaterialIndex); foreach (var i in vertices) doc.AddSelectVertex(obj.Index, i); for (int i = 0; i < (vertices.Length == 2 ? 1 : vertices.Length); i++) doc.AddSelectLine(obj.Index, face, i); doc.AddSelectFace(obj.Index, face); return vertices[1]; }
public void SpecimenRequestsAreEmptyWhenAllThatWereRequestedAreCreated() { // Fixture setup var tracer = new DelegatingTracingBuilder(); var specimens = new[] { new object(), new object(), new object() }; var requestEvents = specimens.Select( (o, i) => new RequestTraceEventArgs(o, i)).ToList(); var createdEvents = specimens.Reverse().Select( (o, i) => new SpecimenCreatedEventArgs(o, null, i)).ToList(); var sut = new TerminatingWithPathSpecimenBuilder(tracer); // Exercise system requestEvents.ForEach(tracer.RaiseSpecimenRequested); createdEvents.ForEach(tracer.RaiseSpecimenCreated); // Verify outcome Assert.Empty(sut.SpecimenRequests); // Teardown }
public void ShouldCopyToLargeArray() { // arrange var expected = new[] { "1", "2" }; var target = new ObservableStack<string>( expected ); var actual = new string[4]; // act target.CopyTo( actual, 2 ); // assert Assert.True( actual.Skip( 2 ).SequenceEqual( expected.Reverse() ) ); }
public void ShouldCopyToWhenICollection() { // arrange var target = new ObservableStack<string>(); var collection = (ICollection) target; var expected = new[] { "1", "2" }; var actual = new string[2]; target.Push( "1" ); target.Push( "2" ); // act collection.CopyTo( actual, 0 ); // assert Assert.True( actual.SequenceEqual( expected.Reverse() ) ); }
/// <summary> /// A specific case for the CONNECT command, /// connect both ends blindly (will work for HTTPS, SSH and others) /// </summary> protected virtual void HandleConnect() { int NewDestinationPort; string NewDestinationHost = ParseDestinationHostAndPort( RequestLine, RequestHeaders, out NewDestinationPort); Connect(NewDestinationHost, NewDestinationPort); this.State.NextStep = null; this.SocketBP.WriteAsciiLine(string.Format("HTTP/{0} 200 Connection established", RequestLine.ProtocolVersion)); this.SocketBP.WriteAsciiLine(string.Empty); var socketsToConnect = new[] { this.SocketBP, this.SocketPS }; socketsToConnect .Zip(socketsToConnect.Reverse(), (from, to) => new { from,to }) .AsParallel() .ForAll(team => team.from.TunnelDataTo(team.to)); }
/// <summary> /// Handle a websocket handshake and tunnel the two ends /// </summary> private void HandleWebSocket() { this.State.NextStep = null; var socketsToConnect = new[] { this.SocketPS, this.SocketBP }; var upDatedSoc = socketsToConnect.Zip(socketsToConnect.Reverse(), (from, to) => new { from, to }).ToList(); Parallel.ForEach(upDatedSoc, team => { team.from.TunnelDataTo(team.to); }); return; }
public void AddQuad(int index0, int index1, int index2, int index3, int? tag) { PrevalidateGeometry(); var indicesAsArray = new[] { index0, index1, index2, index3 }; _currentMeshGeometry.Faces.Add(new Face { Indices = indicesAsArray, MaterialId = _model.AddMaterial(_currentMaterial), Tag = tag, Triangles = TessellatePolygon(indicesAsArray).ToList() }); if (_currentMaterial.MaterialMode == MaterialMode.Double) { _currentMeshGeometry.Faces.Add(new Face { Indices = indicesAsArray.Reverse().ToList(), MaterialId = _model.AddMaterial(_currentMaterial), Tag = tag, Triangles = TessellatePolygon(indicesAsArray.Reverse()).ToList() }); } }
public void Reverse() { var ints = new[] { 1, 2, 3 }; var reverse = ints.Reverse().ToArray(); AssertEquals(reverse.Length, 3); AssertEquals(reverse[0], 3); AssertEquals(reverse[1], 2); AssertEquals(reverse[2], 1); }
public void AddQuad(int index0, int index1, int index2, int index3, int? tag) { PrevalidateGeometry(); var indicesAsArray = new[] { index0, index1, index2, index3 }; _currentMeshGeometry.Faces.Add(new Face { Indices = indicesAsArray, MaterialId = _model.AddMaterial(_currentMaterial), Tag = tag, Triangles = new List<Triangle> { new Triangle(indicesAsArray[0], indicesAsArray[1], indicesAsArray[2]), new Triangle(indicesAsArray[0], indicesAsArray[2], indicesAsArray[3]) } }); if (_currentMaterial.MaterialMode == MaterialMode.Double) { _currentMeshGeometry.Faces.Add(new Face { Indices = indicesAsArray.Reverse().ToList(), MaterialId = _model.AddMaterial(_currentMaterial), Tag = tag, Triangles = new List<Triangle> { new Triangle(indicesAsArray[2], indicesAsArray[1], indicesAsArray[0]), new Triangle(indicesAsArray[3], indicesAsArray[2], indicesAsArray[0]) } }); } }
public void ReverseWorks() { var arr = new[] { 1, 3, 4, 1, 3, 2 }; arr.Reverse(); Assert.AreEqual(arr, new[] { 2, 3, 1, 4, 3, 1 }); }
public static void TestTextEscapes() { const string Separators = ",a#SsNn?\t"; var testStrings = new[] { "aaa", "aab", "baa", "aaaa", "a" + char.MaxValue, "a" + (char)(char.MaxValue - 1), "a" + char.MaxValue + ",", "Sn#S\nab,c", "#?E#?e\n###?>??ee", "\n", "\t", } .OrderBy(s => s, StringComparer.Ordinal) .ToList() .AsReadOnly(); foreach (var sep in Separators) { var escaper = new TextEncodingEscaper(sep); // test you can escape and unescape foreach (var s in testStrings) { var keyEscaped = escaper.EscapeKeyString(s); keyEscaped.Contains(sep).ShouldEqual(false); keyEscaped.Contains('\n').ShouldEqual(false); var keyUnescaped = escaper.UnescapeKeyString(keyEscaped); keyUnescaped.ShouldEqual(s); var valueEscaped = escaper.EscapeValueString(s); valueEscaped.Contains(sep).ShouldEqual(false); valueEscaped.Contains('\n').ShouldEqual(false); var valueUnescaped = escaper.UnescapeValueString(valueEscaped); valueUnescaped.ShouldEqual(s); } // test that ordering is preserved for keys var reorderdEscaped = testStrings.Reverse() .Select(escaper.EscapeKeyString) .OrderBy(s => s, StringComparer.Ordinal) .ToList() .AsReadOnly(); reorderdEscaped.Select(escaper.UnescapeKeyString) .SequenceEqual(testStrings) .Assert(testStrings + " != " + reorderdEscaped); } }