gitea-mirror/basic-computer-games
1
0
Fork 0
mirror of https://github.com/coding-horror/basic-computer-games.git synced 2025-12-21 23:00:43 -08:00
Code Issues Packages Projects Releases Wiki Activity

Define instance methods for reverser.

Browse Source
This commit is contained in:
Kristian Stolen
2022-01-12 20:00:59 +08:00
parent 08282e1a7d
commit a819a535bb
3 changed files with 86 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
73_Reverse/csharp/Reverse/Reverse.Tests/ReverserTests.cs
View File

@@ -7,15 +7,45 @@ namespace Reverse.Tests
{
public class ReverserTests
{
[Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
public void Constructor_CreatesRandomArrayOfSpecifiedLength(int size)
{
var sut = new TestReverser(size);
Assert.Equal(size, sut.GetArray().Length);
}
[Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
public void ConstructorArray_MaxElementValueIsEqualToSize(int size)
{
var sut = new TestReverser(size);
Assert.Equal(size, sut.GetArray().Max());
}
[Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
public void ConstructorArray_ReturnsRandomArrayWithDistinctElements(int size)
{
var sut = new TestReverser(size);
var array = sut.GetArray();
var arrayGroup = array.GroupBy(x => x);
var duplicateFound = arrayGroup.Any(x => x.Count() > 1);
Assert.False(duplicateFound);
}
[Theory]
[InlineData(new int[] { 1 }, new int[] { 1 })]
[InlineData(new int[] { 1, 2 }, new int[] { 2, 1 })]
[InlineData(new int[] { 1, 2, 3 }, new int[] { 3, 2, 1 })]
public void Reverse_WillReverseEntireArray(int[] input, int[] output)
{
Reverser.Reverse(input, input.Length);
var sut = new TestReverser(1);
sut.SetArray(input);
Assert.True(input.SequenceEqual(output));
sut.Reverse(input.Length);
Assert.True(sut.GetArray().SequenceEqual(output));
}
[Fact]
@@ -23,10 +53,12 @@ namespace Reverse.Tests
{
var input = new int[] { 1, 2, 3, 4 };
var output = new int[] { 2, 1, 3, 4 };
var sut = new TestReverser(1);
sut.SetArray(input);
Reverser.Reverse(input, 2);
sut.Reverse(2);
Assert.True(input.SequenceEqual(output));
Assert.True(sut.GetArray().SequenceEqual(output));
}
[Fact]
@@ -34,10 +66,12 @@ namespace Reverse.Tests
{
var input = new int[] { 1, 2 };
var output = new int[] { 1, 2 };
var sut = new TestReverser(1);
sut.SetArray(input);
Reverser.Reverse(input, 1);
sut.Reverse(1);
Assert.True(input.SequenceEqual(output));
Assert.True(sut.GetArray().SequenceEqual(output));
}
[Fact]
@@ -45,37 +79,12 @@ namespace Reverse.Tests
{
var input = new int[] { 1, 2 };
var output = new int[] { 1, 2 };
var sut = new TestReverser(1);
sut.SetArray(input);
Reverser.Reverse(input, input.Length + 1);
sut.Reverse(sut.GetArray().Length + 1);
Assert.True(input.SequenceEqual(output));
}
[Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
public void CreateRandomArray_ReturnsRandomArrayOfSpecifiedLength()
{
var result = Reverser.CreateRandomArray(5);
Assert.Equal(5, result.Length);
}
[Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
public void CreateRandomArray_MaxElementValueIsEqualToSize(int size)
{
var result = Reverser.CreateRandomArray(size);
Assert.Equal(size, result.Max());
}
[Property(Arbitrary = new[] { typeof(PositiveIntegerGenerator) })]
public void CreateRandomArray_ReturnsRandomArrayWithDistinctElements(int size)
{
var array = Reverser.CreateRandomArray(size);
var arrayGroup = array.GroupBy(x => x);
var duplicateFound = arrayGroup.Any(x => x.Count() > 1);
Assert.False(duplicateFound);
Assert.True(sut.GetArray().SequenceEqual(output));
}
[Theory]
@@ -84,7 +93,10 @@ namespace Reverse.Tests
[InlineData(new int[] { 1, 1 })]
public void IsArrayInAscendingOrder_WhenArrayElementsAreInNumericAscendingOrder_ReturnsTrue(int[] input)
{
var result = Reverser.IsArrayInAscendingOrder(input);
var sut = new TestReverser(1);
sut.SetArray(input);
var result = sut.IsArrayInAscendingOrder();
Assert.True(result);
}
@@ -92,7 +104,10 @@ namespace Reverse.Tests
[Fact]
public void IsArrayInOrder_WhenArrayElementsAreNotInNumericAscendingOrder_ReturnsFalse()
{
var result = Reverser.IsArrayInAscendingOrder(new int[] { 2, 1 });
var sut = new TestReverser(1);
sut.SetArray(new int[] { 2, 1 });
var result = sut.IsArrayInAscendingOrder();
Assert.False(result);
}

17
73_Reverse/csharp/Reverse/Reverse.Tests/TestReverser.cs Normal file
View File

@@ -0,0 +1,17 @@
namespace Reverse.Tests
{
internal class TestReverser : Reverser
{
public TestReverser(int arraySize) : base(arraySize) { }
public int[] GetArray()
{
return _array;
}
public void SetArray(int[] array)
{
_array = array;
}
}
}

17
73_Reverse/csharp/Reverse/Reverse/Reverser.cs
View File

@@ -4,6 +4,23 @@ namespace Reverse
{
public class Reverser
{
protected int[] _array;
public Reverser(int arraySize)
{
_array = CreateRandomArray(arraySize);
}
public void Reverse(int index)
{
Reverse(_array, index);
}
public bool IsArrayInAscendingOrder()
{
return IsArrayInAscendingOrder(_array);
}
public static void Reverse(int[] arrayToReverse, int indexToReverseTo)
{
if (indexToReverseTo > arrayToReverse.Length)