public void TestEqualityBuilder()
{
IEnumerable<Tester> a = new List<Tester>
{
new Tester(1, 2),
new Tester(3, 4),
new Tester(4, 10),
new Tester(10, 12),
new Tester(14, 432)
};
IEnumerable<Tester> b = new List<Tester>
{
new Tester(1, 2),
new Tester(3, 4),
new Tester(4, 10),
new Tester(10, 12),
new Tester(14, 432)
};
// Demonstrate that standard method returns false as references are different
Assert.IsFalse(a.SequenceEqual(b));
// Demonstrate the using an equality builder allows deeper comparison
Assert.IsTrue(a.SequenceEqual(b, new EqualityBuilder<Tester>((x, y) => x.A == y.A && x.B == y.B)));
}
public void GenerateFibonacciNumbersListTest()
{
List<int> fibonacciNumbers = new List<int>();
fibonacciNumbers = FluentMath.Get().FibonacciNumbers.ToValue(89);
Assert.IsTrue(fibonacciNumbers.SequenceEqual(new List<int>() { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 }));
fibonacciNumbers = FluentMath.Get().FibonacciNumbers.ToValue(13);
Assert.IsTrue(fibonacciNumbers.SequenceEqual(new List<int>() { 0, 1, 1, 2, 3, 5, 8, 13 }));
}
public void TestAdd()
{
var cpu = new CPU();
//Set initial values in register file
cpu.RegWrite(2, 10);
cpu.RegWrite(3, 255);
const string instr = "add $1, $2, $3";
cpu.AddInstruction(new Add(instr, 0, 1, 2, 3));
var expectedRecords = new List<ExecutionRecordList>();
int clockCycle = 0;
cpu.RunClock();
expectedRecords.Add(new ExecutionRecordList());
expectedRecords[clockCycle].Add(new ExecutionRecord(ExecutionType.Fetch, instr, 0, null));
clockCycle++;
Assert.IsTrue(expectedRecords.SequenceEqual(cpu.ExecutionRecords));
cpu.RunClock();
expectedRecords.Add(new ExecutionRecordList());
expectedRecords[clockCycle].Add(new ExecutionRecord(ExecutionType.Decode, "Add: rd = $1, rs = $2, rt = $3", 0, null));
clockCycle++;
Assert.IsTrue(expectedRecords.SequenceEqual(cpu.ExecutionRecords));
cpu.RunClock();
expectedRecords.Add(new ExecutionRecordList());
expectedRecords[clockCycle].Add(new ExecutionRecord(ExecutionType.Execute, "Add 10 + 255 = 265", 0, null));
clockCycle++;
Assert.IsTrue(expectedRecords.SequenceEqual(cpu.ExecutionRecords));
cpu.RunClock();
expectedRecords.Add(new ExecutionRecordList());
expectedRecords[clockCycle].Add(new ExecutionRecord(ExecutionType.Memory, "None", 0, null));
clockCycle++;
Assert.IsTrue(expectedRecords.SequenceEqual(cpu.ExecutionRecords));
cpu.RunClock();
expectedRecords.Add(new ExecutionRecordList());
expectedRecords[clockCycle].Add(new ExecutionRecord(ExecutionType.Writeback, "Register $1 <= 265", 0, null));
clockCycle++;
Assert.IsTrue(expectedRecords.SequenceEqual(cpu.ExecutionRecords));
//Test value inside register file
Assert.AreEqual(265, cpu.RegRead(1));
Assert.AreEqual(clockCycle, cpu.ClockCycle);
}
public void CategorySortComparison()
{
var l = new List<Category>
{
new Category("Hello"),
new Category("Hello", "GoodBye"),
new Category("Hello", "A"),
new Category("Hello", "B"),
new Category("A"),
new Category("Z")
};
var lSorted = new List<Category>
{
new Category("A"),
new Category("Hello"),
new Category("Hello", "A"),
new Category("Hello", "B"),
new Category("Hello", "GoodBye"),
new Category("Z")
};
Assert.IsFalse(l.SequenceEqual(lSorted));
l.Sort();
Assert.IsTrue(l.SequenceEqual(lSorted));
}
public void CalculatedRecurrenceSetPagingWorks()
{
#region Arrange
var validStartDateTime = new DateTime(2014, 1, 31);
const int validMonthsBetweenOccurrences = 2;
DateTime validEndDateTime = validStartDateTime.AddMonths(9);
var validDayOfWeekMonthlyRecurrence = new DayOfWeekMonthlyRecurrence(validStartDateTime,
validMonthsBetweenOccurrences, validEndDateTime);
var expectedRecurrenceSet = new List<DateTime>
{
new DateTime(2014, 3, 28), // 3/28/2014 (March)
new DateTime(2014, 5, 30), // 5/30/2014 (May)
};
#endregion
#region Act
const int validSkip = 1;
const int validTake = 2;
IEnumerable<DateTime> recurrenceSet = validDayOfWeekMonthlyRecurrence.CalculateRecurrenceSet(validSkip,
validTake);
#endregion
#region Assert
Assert.IsTrue(expectedRecurrenceSet.SequenceEqual(recurrenceSet));
#endregion
}
public void CanFindAllIndexes()
{
var expected = new List<int> { 1, 4, 5 };
var actual = this.array.FindAllIndexes(0, new int[0], 1);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void TestAdjacent()
{
IMatrix<string> matrix = new Matrix<string>(3, 3);
List<string> items = new List<string>(9);
for (int i = 0; i < items.Capacity; i++)
{
items.Add(string.Format("{0}", i));
}
var index = 0;
for (int y = 0; y < matrix.Rows; y++)
{
int x;
for (x = 0; x < matrix.Columns; x++)
{
matrix[x, y] = items[index++];
}
}
var middleCell = matrix[1, 1];
int middleIndex = matrix.IndexOf(middleCell);
items.RemoveAt(middleIndex);
var adjacentCells = matrix.GetAdjacentCells(middleCell);
Assert.IsTrue(items.SequenceEqual(adjacentCells));
}
public void CanCalculateRecurrenceSet()
{
#region Arrange
var validStartDateTime = new DateTime(2014, 2, 18);
const int validDaysBetweenOccurrences = 3;
var validEndDateTime = validStartDateTime.AddDays(validDaysBetweenOccurrences*3);
var validDailyRecurrence = new DailyRecurrence(validStartDateTime, validDaysBetweenOccurrences,
validEndDateTime);
#endregion
#region Act
var recurrenceSet = validDailyRecurrence.CalculateRecurrenceSet();
#endregion
#region Assert
var expectedRecurrenceSet = new List<DateTime>
{
validStartDateTime,
validStartDateTime.AddDays(validDaysBetweenOccurrences*1),
validStartDateTime.AddDays(validDaysBetweenOccurrences*2),
validStartDateTime.AddDays(validDaysBetweenOccurrences*3)
};
Assert.IsTrue(expectedRecurrenceSet.SequenceEqual(recurrenceSet));
#endregion
}
public void GetAllWithFullNameTest()
{
var ds = new List<string> { "DARTFORD", "LIVERPOOL", "PADDINGTON" };
var expressions = new List<string>{ "LIVERPOOL" };
var result = new DictionaryStationRepository(ds).GetAllThatStartWith("LIVERPOOL");
Assert.IsTrue(expressions.SequenceEqual(result));
}
public void GetAllWithMissingNameTest()
{
var ds = new List<string> { "EUSTON", "LONDON BRIDGE", "VICTORIA" };
var expressions = new List<string>(0);
var result = new DictionaryStationRepository(ds).GetAllThatStartWith("KINGS CROSS");
Assert.IsTrue(expressions.SequenceEqual(result));
}
public void ReturnFirst10FibonacciNumberWhenInputIs10()
{
var expectedResult = new List<ulong> { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 };
var result = Fibonacci.GetNumbers(10);
Assert.IsTrue(expectedResult.SequenceEqual(result.Numbers),
"Expected first 10 Fibonacci numbers; got something else");
}
public void SerializeDeserializeList1()
{
var l = new List<string>();
var l2 = l.Serialize().Deserialize<List<string>>();
Assert.IsTrue(l.SequenceEqual(l2));
Assert.AreNotSame(l, l2);
}
public void GetAllWithPartialNameTest()
{
var ds = new List<string> { "DARTFORD", "DARTMOUTH", "TOWER HILL", "DERBY" };
var expressions = new List<string> { "DARTFORD", "DARTMOUTH" };
var result = new DictionaryStationRepository(ds).GetAllThatStartWith("DART");
Assert.IsTrue(expressions.SequenceEqual(result));
}
public void TestMergeKeepDuplicates()
{
var arg = new List<List<int>> { new List<int> { 1, 3, 5 }, new List<int> { -1, 1, 2, 4 }, new List<int> { 6, 7 } };
var expected = new List<int> { -1, 1, 1, 2, 3, 4, 5, 6, 7 };
var res = arg.Merge(false).ToList();
Assert.IsTrue(expected.SequenceEqual(res), "Merge of [{0}] with duplicates gives {1} instead of {2}", string.Join(", ", arg.Select(IntsToString)), IntsToString(res), IntsToString(expected));
}
public void CanCalculateRecurrenceSet()
{
#region Arrange
var validStartDateTime = new DateTime(2014, 1, 31);
const int validMonthsBetweenOccurrences = 2;
DateTime validEndDateTime = validStartDateTime.AddMonths(9);
var validDayOfWeekMonthlyRecurrence = new DayOfWeekMonthlyRecurrence(validStartDateTime,
validMonthsBetweenOccurrences, validEndDateTime);
var expectedRecurrenceSet = new List<DateTime>
{
new DateTime(2014, 1, 31), // 1/31/2014 (January)
new DateTime(2014, 3, 28), // 3/28/2014 (March)
new DateTime(2014, 5, 30), // 5/30/2014 (May)
new DateTime(2014, 7, 25), // 7/25/2014 (July)
new DateTime(2014, 9, 26) // 9/26/2014 (September)
};
#endregion
#region Act
IEnumerable<DateTime> recurrenceSet = validDayOfWeekMonthlyRecurrence.CalculateRecurrenceSet();
#endregion
#region Assert
Assert.IsTrue(expectedRecurrenceSet.SequenceEqual(recurrenceSet));
#endregion
}
public void CanFindAllIndexesUsingComparerAndSkipList()
{
var expected = new List<int> { 1, 5 };
var actual = this.array.FindAllIndexes(0, new[] { 4 }, 1, EqualityComparer<int>.Default);
Assert.IsTrue(expected.SequenceEqual(actual));
}
public void Container_SerializeThreeObjects()
{
var expected = new List<ClassOfInt>
{
ClassOfInt.Create(true),
ClassOfInt.Create(true),
ClassOfInt.Create(true)
};
using (var writer = AvroContainer.CreateWriter<ClassOfInt>(this.resultStream, Codec.Null))
{
var metadata = new Dictionary<string, byte[]> { { Utilities.GetRandom<string>(false), Utilities.GetRandom<byte[]>(false) } };
writer.SetMetadata(metadata);
var block = writer.CreateBlockAsync().Result;
expected.ForEach(block.Write);
writer.WriteBlockAsync(block).Wait();
}
this.resultStream.Seek(0, SeekOrigin.Begin);
using (var reader = AvroContainer.CreateReader<ClassOfInt>(this.resultStream))
{
reader.MoveNext();
Assert.IsTrue(expected.SequenceEqual(reader.Current.Objects));
}
}
public void CanCalculateRecurrenceSet()
{
#region Arrange
var validStartDateTime = new DateTime(2014, 1, 31);
const int validMonthsBetweenOccurrences = 2;
DateTime validEndDateTime = validStartDateTime.AddMonths(9);
var validDayOfMonthMonthlyRecurrence = new DayOfMonthMonthlyRecurrence(validStartDateTime,
validMonthsBetweenOccurrences, validEndDateTime);
var expectedRecurrenceSet = new List<DateTime>
{
validStartDateTime, // 1/31/2014 (January)
validStartDateTime.AddMonths(2), // 3/31/2014 (March)
validStartDateTime.AddMonths(4), // 5/31/2014 (May)
validStartDateTime.AddMonths(6) // 7/31/2014 (July)
// no 9/31/2014 (September) because September only has 30 days so its skipped
};
#endregion
#region Act
IEnumerable<DateTime> recurrenceSet = validDayOfMonthMonthlyRecurrence.CalculateRecurrenceSet();
#endregion
#region Assert
Assert.IsTrue(expectedRecurrenceSet.SequenceEqual(recurrenceSet));
#endregion
}
public void CalculatedRecurrenceSetPagingWorks()
{
#region Arrange
var validStartDateTime = new DateTime(2014, 2, 19);
const int validYearsBetweenOccurrences = 2;
DateTime validEndDateTime = validStartDateTime.AddYears(6);
var validYearlyRecurrence = new YearlyRecurrence(validStartDateTime, validYearsBetweenOccurrences,
validEndDateTime);
#endregion
#region Act
const int validSkip = 1;
const int validTake = 2;
IEnumerable<DateTime> recurrenceSet = validYearlyRecurrence.CalculateRecurrenceSet(validSkip, validTake);
#endregion
#region Assert
var expectedRecurrenceSet = new List<DateTime>
{
validStartDateTime.AddYears(validYearsBetweenOccurrences*1),
validStartDateTime.AddYears(validYearsBetweenOccurrences*2)
};
Assert.IsTrue(expectedRecurrenceSet.SequenceEqual(recurrenceSet));
#endregion
}
public void GetAllWithPartialNameAndBlankSpaceTest()
{
var ds = new List<string> { "LIVERPOOL", "LIVERPOOL LIME STREET", "PADDINGTON" };
var expressions = new List<string> { "LIVERPOOL", "LIVERPOOL LIME STREET" };
var result = new DictionaryStationRepository(ds).GetAllThatStartWith("LIVERPOOL");
Assert.IsTrue(expressions.SequenceEqual(result));
}
public void TestGenerateRollover()
{
// List of points the generator will use.
var points = new List<Point>
{
new Point(0, 0),
new Point(0, 1),
new Point(1, 0),
new Point(1, 1)
};
// Setup a list of expected points by duplicating
// the original points.
var expected = new List<Point>(points);
expected.AddRange(points.Select(p => new Point(p.X, p.Y)));
// Prime the generator.
var generator = new DeterminatePointGenerator(points);
var generated = new List<Point>(points.Count);
// We want the generator to rollover and reuse the points.
for (int i = 0; i < points.Count * 2; i++)
{
generated.Add(generator.Generate(2, 2));
}
Assert.IsTrue(expected.SequenceEqual(generated));
}
public void TestProperList()
{
var sorter = new SelectionSorter();
var list = new List<int> { 3, 2, 1, 9, 7 };
sorter.Sort(list);
Assert.AreEqual(5, list.Count);
Assert.IsTrue(list.SequenceEqual(new List<int> { 1, 2, 3, 7, 9 }));
}
public void GenerateMockListReturnsCorrectListOfIntegers()
{
ICollection<int> testList = MyUtils.GenerateListOfIntegers(5);
List<int> correctList = new List<int> { 1, 2, 3, 4, 5 };
Assert.IsTrue(correctList.SequenceEqual(testList));
}
public void ShouldRemoveOnlyOneSemicolonIfMoreThanOneIsPresent()
{
_selectedLines.Add(";;line two");
var result = _blockUncomment.Execute(_selectedLines);
var expectedResult = new List<string>();
expectedResult.Add(";line two");
Assert.IsTrue(expectedResult.SequenceEqual(result));
}
public void ShouldDoNothingToALineThatEndsWithAComment()
{
_selectedLines.Add("line two ;asdf");
var result = _blockUncomment.Execute(_selectedLines);
var expectedResult = new List<string>();
expectedResult.Add("line two ;asdf");
Assert.IsTrue(expectedResult.SequenceEqual(result));
}
public void GetAllClientsTest()
{
var expected = new List<string> { "Name1", "Name2", "Name3" };
ClientRepository.InsertClients(expected);
List<Client> actual = ClientRepository.GetAllClients().ToList();
Assert.IsTrue(expected.SequenceEqual(actual.Select(o => o.Name)));
}
public void ShouldPutSemicolonOnBlankLineIfItIsTheOnlyLine()
{
_selectedLines.Add("");
var result = _blockComment.Execute(_selectedLines);
var expectedResult = new List<string>();
expectedResult.Add(";");
Assert.IsTrue(expectedResult.SequenceEqual(result));
}
public void ShouldDoNothingToALineThatDoesNotBeginWithASemicolon()
{
_selectedLines.Add("line two");
var result = _blockUncomment.Execute(_selectedLines);
var expectedResult = new List<string>();
expectedResult.Add("line two");
Assert.IsTrue(expectedResult.SequenceEqual(result));
}
public void TestMergeIsLazy()
{
// Elements go -4, -2, error, ...
var badlist = Enumerable.Range(-2, 5).Select(i => i == 0 ? 1 / i : 2 * i);
var arg = new List<IEnumerable<int>> { badlist, Enumerable.Range(-5, 5), Enumerable.Range(-3, 5) };
var expected = new List<int> {-5, -4, -3, -2};
var res = arg.Merge().Take(4);
Assert.IsTrue(expected.SequenceEqual(res), "Partial enumeration of sequence merge should not raise an error");
}
public void WhenInitializedItemsListWillReadFromFil()
{
var itemsCollection = new List<IItem>();
var itemDeserializer = new StubIItemDeserializer
{
Deserialize = () => itemsCollection
};
Assert.IsTrue(itemsCollection.SequenceEqual(SetupClass(itemDeserializer: itemDeserializer).Items));
}
