public void ConcatTest() { int[] first = new int[] { 0, 1, 2 }; int[] second = new int[] { 3, 4, 5 }; EnumerableAssert.AreSequentialEqual( Enumerable.Concat(first, second), EnumerableExtensions.Concat(first, second)); first = new int[] { }; second = new int[] { 3, 4, 5 }; EnumerableAssert.AreSequentialEqual( Enumerable.Concat(first, second), EnumerableExtensions.Concat(first, second)); first = new int[] { 0, 1, 2 }; second = new int[] { }; EnumerableAssert.AreSequentialEqual( Enumerable.Concat(first, second), EnumerableExtensions.Concat(first, second)); }
public void ShouldUseTheSpecifiedFormat() { using (var input = new MagickImageCollection(Files.CirclePNG)) { using (var memoryStream = new MemoryStream()) { using (var stream = new NonSeekableStream(memoryStream)) { input.Write(stream, MagickFormat.Tiff); memoryStream.Position = 0; using (var output = new MagickImageCollection(stream)) { EnumerableAssert.IsSingle(output); Assert.AreEqual(MagickFormat.Tiff, output[0].Format); } } } } }
public void Person_SortedSet() { var persons = new[] { new Person { Ssn = "324-00-3015", DateOfBirth = new DateTime(1970, 12, 17), FirstName = "Tod", LastName = "Temme" }, new Person { Ssn = "548-00-1592", DateOfBirth = new DateTime(1968, 03, 13), FirstName = "Lucia", LastName = "Armstrong" }, new Person { Ssn = "129-00-7416", DateOfBirth = new DateTime(1982, 09, 02), FirstName = "Spencer", LastName = "Weaver" }, new Person { Ssn = "831-00-6391", DateOfBirth = new DateTime(1974, 04, 30), FirstName = "Celia", LastName = "Potter" }, new Person { Ssn = "714-00-6502", DateOfBirth = new DateTime(1966, 11, 19), FirstName = "Powell", LastName = "Beck" }, }; var bySsn = new SortedSet <Person>(persons, KeyComparer.Create( (Person p) => p.Ssn)); // Not suitable for real-world scenarios, since SortedSet<T> does not allow duplicates. var byDateOfBirth = new SortedSet <Person>(persons, KeyComparer.Create( (Person p) => p.DateOfBirth)); var byFullName = new SortedSet <Person>(persons, KeyComparer.Create( (Person p) => $"{p.FirstName} {p.LastName}", StringComparer.Ordinal)); EnumerableAssert.AreEqual(new[] { "Spencer", "Tod", "Lucia", "Powell", "Celia" }, bySsn.Select(p => p.FirstName)); EnumerableAssert.AreEqual(new[] { "Powell", "Lucia", "Tod", "Celia", "Spencer" }, byDateOfBirth.Select(p => p.FirstName)); EnumerableAssert.AreEqual(new[] { "Celia", "Lucia", "Powell", "Spencer", "Tod" }, byFullName.Select(p => p.FirstName)); var person = new Person { Ssn = "301-00-1582", DateOfBirth = new DateTime(1984, 11, 01), FirstName = "Teddy", LastName = "Wake" }; bySsn.Add(person); EnumerableAssert.AreEqual(new[] { "Spencer", "Teddy", "Tod", "Lucia", "Powell", "Celia" }, bySsn.Select(p => p.FirstName)); }
public void GetExports_WhenMultipleRejectedDefinitionsRequiredImportsAreAdded_ShouldBeResurrected() { var part1 = PartFactory.CreateImporterExporter("Export", "Import"); var part2 = PartFactory.CreateImporterExporter("Export", "Import"); var provider = CreateCatalogExportProvider(part1, part2); var sourceProvider = ExportProviderFactory.CreateRecomposable(); provider.SourceProvider = sourceProvider; var exports = provider.GetExports <object>("Export"); EnumerableAssert.IsEmpty(exports, "definition1 and definition2 should have been rejected."); // Resurrect both definitions sourceProvider.AddExport("Import", new object()); exports = provider.GetExports <object>("Export"); Assert.AreEqual(2, exports.Count(), "definition1 and definition2 should have been resurrected."); }
public void VerifyImports(params T[] expectedValues) { EnumerableAssert.AreEqual(ICollectionOfTReadOnlyField, expectedValues); EnumerableAssert.AreEqual(ListOfTField, expectedValues); EnumerableAssert.AreEqual(ListOfTReadOnlyField, expectedValues); EnumerableAssert.AreEqual(CollectionOfTField, expectedValues); EnumerableAssert.AreEqual(CollectionOfTReadOnlyField, expectedValues); EnumerableAssert.AreEqual(ICollectionOfTReadOnlyProperty, expectedValues); EnumerableAssert.AreEqual(ListOfTProperty, expectedValues); EnumerableAssert.AreEqual(ListOfTReadOnlyProperty, expectedValues); EnumerableAssert.AreEqual(CollectionOfTProperty, expectedValues); EnumerableAssert.AreEqual(CollectionOfTReadOnlyProperty, expectedValues); #if FEATURE_OBSERVABLECOLLECTIONS EnumerableAssert.AreEqual(ObservableCollectionOfTField, expectedValues); EnumerableAssert.AreEqual(ObservableCollectionOfTReadOnlyField, expectedValues); EnumerableAssert.AreEqual(ObservableCollectionOfTProperty, expectedValues); EnumerableAssert.AreEqual(ObservableCollectionOfTReadOnlyProperty, expectedValues); #endif // FEATURE_OBSERVABLECOLLECTIONS }
public void ValidateRootDefinition() { ItemDefinition rootDefinition = engine.Definitions.GetDefinition(typeof(Definitions.IntegrityRoot)); ItemDefinition startPageDefinition = engine.Definitions.GetDefinition(typeof(Definitions.IntegrityStartPage)); Assert.That(rootDefinition.GetAllowedChildren(engine.Definitions, null).Contains(startPageDefinition)); //EnumerableAssert.Contains(rootDefinition.AllowedChildren, startPageDefinition); Assert.IsNull(rootDefinition.AuthorizedRoles); Assert.AreEqual(0, rootDefinition.AvailableZones.Count); Assert.AreEqual(0, rootDefinition.Containers.Count); Assert.IsEmpty(rootDefinition.Description); Assert.AreEqual(typeof(Definitions.IntegrityRoot).Name, rootDefinition.Discriminator); Assert.That(rootDefinition.Displayables.Count, Is.EqualTo(17)); Assert.AreEqual(0, rootDefinition.Editables.Count); EnumerableAssert.Contains(engine.Definitions.GetAllowedChildren(new Definitions.IntegrityRoot(), null, null), startPageDefinition); Assert.AreEqual(0, rootDefinition.Editables.Count); Assert.AreEqual(0, rootDefinition.GetModifiers("Title").Count); Assert.AreEqual(0, rootDefinition.EditableModifiers.Count); Assert.AreEqual(0, rootDefinition.SortOrder); Assert.AreEqual(typeof(Definitions.IntegrityRoot).Name, rootDefinition.Title); }
public void EnumerableMonoidTest() { // Left unit law: μ(η ∘ F) == F EnumerableAssert.AreSequentialEqual( new Enumerable <int>(1).Enumerable().Flatten(), new Enumerable <int>(1)); // Right unit law: F == μ(F ∘ η) EnumerableAssert.AreSequentialEqual( new Enumerable <int>(1), new Enumerable <IEnumerable <int> >(1.Enumerable()).Flatten()); // Associative law: μ(F ∘ F) ∘ F) == F ∘ μ(F ∘ F) IEnumerable <Enumerable <int> > left = new Enumerable <int>(1).Enumerable().Enumerable().Flatten(); IEnumerable <IEnumerable <int> > right = new Enumerable <IEnumerable <int> >(new Enumerable <int>(1)).Flatten().Enumerable(); Assert.AreEqual(left.Count(), right.Count()); for (int i = 0; i < left.Count(); i++) { EnumerableAssert.AreSequentialEqual(left.Skip(i - 1).Take(1).Single(), right.Skip(i - 1).Take(1).Single()); } }
public void ReadToEnd_FileStream() { using (var tempFile = new TempFile(create: false)) { var filePath = tempFile.FilePath; var bytes = CachedRandom.Current.NextBytes(16 * 1024); File.WriteAllBytes(filePath, bytes); using (var fileStream = File.OpenRead(filePath)) { EnumerableAssert.AreEqual(bytes, fileStream.ReadToEnd()); } using (var fileStream = File.OpenRead(filePath)) { byte[] discard = new byte[4 * 1024]; int discarded = fileStream.Read(discard, 0, discard.Length); EnumerableAssert.AreEqual(bytes.Skip(discarded), fileStream.ReadToEnd()); } } }
public void ReadToEnd_Partial() { var bytes = new byte[] { 243, 75, 31, 139, 26, 41, 52, 164, 191, 55, 75, 237 }; for (int pos = 0; pos < bytes.Length; pos++) { using (var stream = new MemoryStream(bytes)) { stream.Seek(pos, SeekOrigin.Begin); EnumerableAssert.AreEqual(bytes.Skip(pos), stream.ReadToEnd()); Assert.AreEqual(bytes.Length, stream.Position); } } bytes = CachedRandom.Current.NextBytes(4 * 1024 * 1024); using (var stream = new MemoryStream(bytes)) { int pos = bytes.Length / 3; stream.Seek(pos, SeekOrigin.Begin); EnumerableAssert.AreEqual(bytes.Skip(pos), stream.ReadToEnd()); Assert.AreEqual(bytes.Length, stream.Position); } }