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);
}
}
