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