public void Constructor4_ValuesAsErrorsArgument_ShouldSetErrorsProperty() { var errors = Expectations.GetCompositionErrors(); foreach (var e in errors) { var result = new CompositionResult <string>(e); EnumerableAssert.AreEqual(e, result.Errors); } }
public void GetEnumerator() { var dictionary = GetWritableDictionaryWithData(); var readOnlyDictionary = GetReadOnlyDictionary(dictionary); IEnumerable <KeyValuePair <string, object> > genericEnumerable = readOnlyDictionary; EnumerableAssert.AreEqual(genericEnumerable, dictionary); IEnumerable weakEnumerable = (IEnumerable)readOnlyDictionary; EnumerableAssert.AreEqual(weakEnumerable, dictionary); }
public void Constructor_ValueAsDictionaryArgument_ShouldSetItemsProperty() { var expectations = Expectations.GetMetadata(); foreach (var e in expectations) { var proxy = new ReadOnlyDictionaryDebuggerProxy <string, object>(CreateReadOnlyDictionary(e)); EnumerableAssert.AreEqual(e, proxy.Items); } }
public void Constructor2_DictionaryAsMetadataArgument_ShouldSetMetadataProperty() { var expectations = Expectations.GetMetadata(); foreach (var e in expectations) { var definition = new ExportDefinition("Contract", e); EnumerableAssert.AreEqual(e, definition.Metadata); } }
public void Constructor2_ValueAsMetadataArgument_ShouldSetMetadataProperty() { var expectations = Expectations.GetMetadata(); foreach (var e in expectations) { var definition = new ContractBasedImportDefinition("ContractName", (string)null, null, ImportCardinality.ExactlyOne, false, false, CreationPolicy.Any, e); EnumerableAssert.AreEqual(e, definition.Metadata); } }
public void Constructor4_DictionaryAsMetadataArgument_ShouldSetDefinitionMetadataProperty() { var expectations = Expectations.GetMetadata(); foreach (var e in expectations) { var export = new Export("ContractName", e, () => null); EnumerableAssert.AreEqual(e, export.Definition.Metadata); } }
public void Constructor5_ArrayAsAsErrorsArgument_ShouldNotAllowModificationAfterConstruction() { var error = CreateCompositionError(); var errors = new CompositionError[] { error }; var exception = new CompositionException("Message", new Exception(), errors); errors[0] = null; EnumerableAssert.AreEqual(exception.Errors, error); }
public void RequiredNonSharedImporter_ShouldFilterShared() { var container = CreateDefaultContainer(); var importer = container.GetExportedValue <RequiredNonSharedImporter>(); EnumerableAssert.AreEqual( importer.Exports.Select(obj => obj.GetType()), typeof(CreationPolicyAnyExportImplicit), typeof(CreationPolicyAnyExportExplicit), typeof(CreationPolicyNonSharedExport)); }
public void Constructor_ValueAsCatalogArgument_ShouldSetAssemblyProperty() { var expectations = Expectations.GetAssemblies(); using (TemporaryFileCopier copier = new TemporaryFileCopier(expectations.Select(assembly => assembly.Location).ToArray())) { var catalog = CreateDirectoryCatalog(copier.DirectoryPath); var proxy = new DirectoryCatalog.DirectoryCatalogDebuggerProxy(catalog); EnumerableAssert.AreEqual(expectations, proxy.Assemblies); } }
private static void AssertCanParse(Expression <Func <ExportDefinition, bool> > constraint, string contractName, IEnumerable <KeyValuePair <string, Type> > requiredMetadata) { Assert.IsNotNull(constraint); string contractNameResult = null; IEnumerable <KeyValuePair <string, Type> > requiredMetadataResult = null; bool success = ContraintParser.TryParseConstraint(constraint, out contractNameResult, out requiredMetadataResult); Assert.IsTrue(success); Assert.AreEqual(contractName, contractNameResult); EnumerableAssert.AreEqual(requiredMetadata, requiredMetadataResult); }
public void TestFlatten() { IEnumerable <IEnumerable <int> > source = new[] { new[] { 1, 3, 7 }, new[] { 2, 4 } }; IEnumerable <int> flattened = source.Flatten(); EnumerableAssert.AreEqual(new[] { 1, 3, 7, 2, 4 }, flattened); }
public void Metadata_DerivedExportDefinition_ShouldReturnDefinitionMetadata() { var expectations = Expectations.GetMetadata(); foreach (var e in expectations) { var definition = ExportDefinitionFactory.Create("ContractName", e); var export = new DerivedExport(definition); EnumerableAssert.AreEqual(e, export.Metadata); } }
public void then_session_is_updated_with_new_eventSources() { var currentEventSource = this.sinkSettings.EventSources.First(); var newEventSource = new EventSourceSettings(currentEventSource.Name, level: currentEventSource.Level, matchAnyKeyword: EventKeywords.AuditSuccess); this.Sut.UpdateSession(new List <EventSourceSettings> { newEventSource }); Assert.AreEqual(newEventSource.Level, currentEventSource.Level); Assert.AreEqual(newEventSource.MatchAnyKeyword, currentEventSource.MatchAnyKeyword); EnumerableAssert.AreEqual(newEventSource.Arguments, currentEventSource.Arguments); EnumerableAssert.AreEqual(newEventSource.ProcessNamesToFilter, currentEventSource.ProcessNamesToFilter); }
public void ImportSingleIntoCollection() { var container = ContainerFactory.Create(); var importer = new Int32CollectionImporter(); var exporter = new Int32Exporter(42); CompositionBatch batch = new CompositionBatch(); batch.AddPart(importer); batch.AddPart(exporter); container.Compose(batch); EnumerableAssert.AreEqual(importer.Values, 42); }
public void VerifyImports(params T[] expectedValues) { // Fields EnumerableAssert.AreEqual(IEnumerableOfTField, expectedValues); EnumerableAssert.AreEqual(IEnumerableOfObjectField, expectedValues.Cast <object>()); EnumerableAssert.AreEqual(ArrayOfTField, expectedValues); EnumerableAssert.AreEqual(ArrayOfObjectField, expectedValues.Cast <object>()); // Properties EnumerableAssert.AreEqual(IEnumerableOfTProperty, expectedValues); EnumerableAssert.AreEqual(IEnumerableOfObjectProperty, expectedValues.Cast <object>()); EnumerableAssert.AreEqual(ArrayOfTProperty, expectedValues); EnumerableAssert.AreEqual(ArrayOfObjectProperty, expectedValues.Cast <object>()); }
public void ImportCollectionsNameless() { // Verifing that the contract name gets the correct value var container = ContainerFactory.Create(); NamelessImporter importer = new NamelessImporter(); NamelessExporter exporter42 = new NamelessExporter(42); NamelessExporter exporter0 = new NamelessExporter(0); CompositionBatch batch = new CompositionBatch(); batch.AddParts(importer, exporter42, exporter0); container.Compose(batch); EnumerableAssert.AreEqual(importer.ReadWriteIList, 42, 0); }
public void TestCircuitEvaluation() { BitArray[] inputs = { BitArray.FromBinaryString("0111010011"), BitArray.FromBinaryString("1101100010"), BitArray.FromBinaryString("0111110011") }; Bit[] sequentialInput = inputs.SelectMany(bits => bits).ToArray(); CircuitBuilder builder = new CircuitBuilder(); SetIntersectionCircuitRecorder setIntersectionCircuitRecorder = new SetIntersectionCircuitRecorder(inputs.Length, inputs[0].Length); setIntersectionCircuitRecorder.Record(builder); Circuit circuit = builder.CreateCircuit(); ForwardCircuit forwardCircuit = new ForwardCircuit(circuit); ICircuitEvaluator <Bit> evaluator = new LocalCircuitEvaluator(); ReportingBatchCircuitEvaluator <Bit> batchCircuitEvaluator = new ReportingBatchCircuitEvaluator <Bit>(new BatchCircuitEvaluator <Bit>(evaluator)); BitArray lazyEvaluationOutput = new BitArray(circuit.Evaluate(evaluator, sequentialInput)); BitArray forwardEvaluationOutput = new BitArray(forwardCircuit.Evaluate(batchCircuitEvaluator, sequentialInput)); BitArray expectedEvaluationOutput = BitArray.FromBinaryString("01010000101100"); EnumerableAssert.AreEqual( expectedEvaluationOutput, lazyEvaluationOutput ); EnumerableAssert.AreEqual( expectedEvaluationOutput, forwardEvaluationOutput ); int[] actualBatchSizes = batchCircuitEvaluator.BatchSizes; int[] expectedBatchSizes = { 10, 10, 9, 9, 8 }; EnumerableAssert.AreEqual( expectedBatchSizes, actualBatchSizes ); }
public void ReadToEnd_Entire() { var bytes = new byte[] { 243, 75, 31, 139, 26 }; using (var stream = new MemoryStream(bytes)) { EnumerableAssert.AreEqual(bytes, stream.ReadToEnd()); Assert.AreEqual(bytes.Length, stream.Position); } bytes = CachedRandom.Current.NextBytes(4 * 1024 * 1024); using (var stream = new MemoryStream(bytes)) { EnumerableAssert.AreEqual(bytes, stream.ReadToEnd()); Assert.AreEqual(bytes.Length, stream.Position); } }
public void VerifyImport(params int[] expectedValues) { object[] untypedExpectedValues = expectedValues.Cast <object>().ToArray(); ExportsAssert.AreEqual(CollectionPlain, untypedExpectedValues); ExportsAssert.AreEqual(CollectionPlainRawMetadata, untypedExpectedValues); EnumerableAssert.IsTrueForAll(CollectionPlainRawMetadata, i => true.Equals(i.Metadata["PropertyName"])); EnumerableAssert.IsEmpty(CollectionPlainEmpty); EnumerableAssert.IsEmpty(CollectionPlainEmptyRawMetadata); // Add a new Export to this collection to ensure that it doesn't // modifiy the other collections because they should each have there // own collection instance CollectionPlain.Add(ExportFactory.Create <object>("Value")); ExportsAssert.AreEqual(CollectionTyped, expectedValues); ExportsAssert.AreEqual(CollectionTypedRawMetadata, expectedValues); EnumerableAssert.IsTrueForAll(CollectionTypedRawMetadata, i => true.Equals(i.Metadata["PropertyName"])); EnumerableAssert.IsEmpty(CollectionTypedEmpty); ExportsAssert.AreEqual(CollectionTypedMetadata, expectedValues); #if !SILVERLIGHT // Silverlight doesn't support strongly typed metadata EnumerableAssert.IsTrueForAll(CollectionTypedMetadata, i => true == i.Metadata.PropertyName); #endif //!SILVERLIGHT EnumerableAssert.IsEmpty(CollectionTypedMetadataEmpty); EnumerableAssert.AreEqual(ReadWriteEnumerable, expectedValues); EnumerableAssert.IsEmpty(ReadWriteEnumerableEmpty); ExportsAssert.AreEqual(MetadataUntypedEnumerable, untypedExpectedValues); ExportsAssert.AreEqual(MetadataUntypedEnumerableRawMetadata, untypedExpectedValues); EnumerableAssert.IsTrueForAll(MetadataUntypedEnumerableRawMetadata, i => true.Equals(i.Metadata["PropertyName"])); EnumerableAssert.IsEmpty(MetadataUntypedEnumerableEmpty); EnumerableAssert.IsEmpty(MetadataUntypedEnumerableEmptyRawMetadata); ExportsAssert.AreEqual(MetadataTypedEnumerable, expectedValues); ExportsAssert.AreEqual(MetadataTypedEnumerableRawMetadata, expectedValues); EnumerableAssert.IsTrueForAll(MetadataTypedEnumerableRawMetadata, i => true.Equals(i.Metadata["PropertyName"])); EnumerableAssert.IsEmpty(MetadataTypedEnumerableEmpty); ExportsAssert.AreEqual(MetadataFullyTypedEnumerable, expectedValues); #if !SILVERLIGHT // Silverlight doesn't support strongly typed metadata EnumerableAssert.IsTrueForAll(MetadataFullyTypedEnumerable, i => true == i.Metadata.PropertyName); #endif //!SILVERLIGHT EnumerableAssert.IsEmpty(MetadataFullyTypedEnumerableEmpty); }
public void Items_ShouldNotCacheUnderlyingItems() { var dictionary = new Dictionary <string, object>(); dictionary.Add("Name", "Value"); var proxy = new ReadOnlyDictionaryDebuggerProxy <string, object>(CreateReadOnlyDictionary(dictionary)); EnumerableAssert.AreEqual(dictionary, proxy.Items); dictionary.Add("AnotherName", "Value"); EnumerableAssert.AreEqual(dictionary, proxy.Items); dictionary.Add("AndAnotherName", "Value"); EnumerableAssert.AreEqual(dictionary, proxy.Items); }
public void Sorting() { using (new CultureSwapper(PredefinedCulture.EnglishUnitedStates)) { var cities = new[] { paris, newYork, athens, madrid, añasco }; var sortedSet = new SortedSet <City>(cities, KeyComparer.Create((City city) => city.Name)); EnumerableAssert.AreEqual(new[] { añasco, athens, madrid, newYork, paris }, sortedSet); sortedSet = new SortedSet <City>(cities, KeyComparer.Create((City city) => city.Name, StringComparer.Ordinal)); EnumerableAssert.AreEqual(new[] { athens, añasco, madrid, newYork, paris }, sortedSet); } int[] nums = new[] { 47, -32, -54, 18, 62, -71, 58 }; var byAbs = new SortedSet <int>(nums, KeyComparer.Create((int n) => Math.Abs(n))); EnumerableAssert.AreEqual(new [] { 18, -32, 47, -54, 58, 62, -71 }, byAbs); }
public void AddExport_ReturnedComposablePart_ContainsExportDefinitionRepresentingExport() { var metadata = new Dictionary <string, object>(); metadata["Name"] = "Value"; CompositionBatch batch = new CompositionBatch(); var export = ExportFactory.Create("Contract", "Value", metadata); var part = batch.AddExport(export); Assert.Equal(1, batch.PartsToAdd.Count); var definition = part.ExportDefinitions.Single(); Assert.Equal("Contract", definition.ContractName); Assert.Equal("Value", part.GetExportedValue(definition)); EnumerableAssert.AreEqual(metadata, definition.Metadata); }
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); EnumerableAssert.AreEqual(ObservableCollectionOfTField, expectedValues); EnumerableAssert.AreEqual(ObservableCollectionOfTReadOnlyField, expectedValues); EnumerableAssert.AreEqual(ObservableCollectionOfTProperty, expectedValues); EnumerableAssert.AreEqual(ObservableCollectionOfTReadOnlyProperty, expectedValues); }
public void ImportCollections_WriteOnlyArray() { var container = ContainerFactory.Create(); var batch = new CompositionBatch(); var importer = new ImporterWriteOnlyArray(); List <int> values = new List <int>() { 21, 32, 43 }; batch.AddPart(importer); values.ForEach(v => batch.AddExportedValue("Value", v)); container.Compose(batch); EnumerableAssert.AreEqual(values, importer.PublicArray); }
public void RebindingShouldNotHappenForConstructorArguments() { var container = GetContainerWithCatalog(); CompositionBatch batch = new CompositionBatch(); var p1 = batch.AddExportedValue("MyConstructorCollectionItem", 1); batch.AddExportedValue("MyConstructorCollectionItem", 2); batch.AddExportedValue("MyConstructorCollectionItem", 3); container.Compose(batch); var a = container.GetExportedValue <AWithCollectionArgument>(); EnumerableAssert.AreEqual(a.Values, 1, 2, 3); batch = new CompositionBatch(); batch.AddExportedValue("MyConstructorCollectionItem", 4); batch.AddExportedValue("MyConstructorCollectionItem", 5); batch.AddExportedValue("MyConstructorCollectionItem", 6); // After rejection changes that are incompatible with existing assumptions are no // longer silently ignored. The batch attempting to make this change is rejected // with a ChangeRejectedException CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PreventedByExistingImport, () => { container.Compose(batch); }); // The collection which is a constructor import should not be rebound EnumerableAssert.AreEqual(a.Values, 1, 2, 3); batch.RemovePart(p1); // After rejection changes that are incompatible with existing assumptions are no // longer silently ignored. The batch attempting to make this change is rejected // with a ChangeRejectedException CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PreventedByExistingImport, () => { container.Compose(batch); }); // The collection which is a constructor import should not be rebound EnumerableAssert.AreEqual(a.Values, 1, 2, 3); }
public void then_session_is_updated_with_new_eventSources_with_filters_and_arguments() { var currentEventSource = this.sinkSettings.EventSources.First(); var newEventSource = new EventSourceSettings( currentEventSource.Name, level: currentEventSource.Level, matchAnyKeyword: currentEventSource.MatchAnyKeyword, arguments: new[] { new KeyValuePair <string, string>("key", "value") }, processNameFilters: new[] { "process" }); this.Sut.UpdateSession(new List <EventSourceSettings> { newEventSource }); Assert.AreEqual(newEventSource.Level, currentEventSource.Level); Assert.AreEqual(newEventSource.MatchAnyKeyword, currentEventSource.MatchAnyKeyword); EnumerableAssert.AreEqual(newEventSource.Arguments, currentEventSource.Arguments); EnumerableAssert.AreEqual(newEventSource.ProcessNamesToFilter, currentEventSource.ProcessNamesToFilter); }
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)); }
private static void PerformSecureComputation(IMultiPartyNetworkSession session, BitArray expectedOutput) { BitArray localInput = Inputs[session.LocalParty.Id]; using CryptoContext cryptoContext = CryptoContext.CreateDefault(); IObliviousTransfer obliviousTransfer = new NaorPinkasObliviousTransfer( new SecurityParameters(47, 23, 4, 1, 1), cryptoContext ); IMultiplicativeSharing multiplicativeSharing = new ObliviousTransferMultiplicativeSharing( obliviousTransfer, cryptoContext ); SecretSharingSecureComputation computation = new SecretSharingSecureComputation( session, multiplicativeSharing, cryptoContext ); SetIntersectionCircuitRecorder circuitRecorder = new SetIntersectionCircuitRecorder( session.NumberOfParties, localInput.Length ); CircuitBuilder circuitBuilder = new CircuitBuilder(); circuitRecorder.Record(circuitBuilder); ForwardCircuit circuit = new ForwardCircuit(circuitBuilder.CreateCircuit()); BitArray actualOutput = computation .EvaluateAsync(circuit, circuitRecorder.InputMapping, circuitRecorder.OutputMapping, localInput) .Result; EnumerableAssert.AreEqual( expectedOutput, actualOutput ); }
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 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()); } } }