public void SatisfyImports_Recomposable_Unregister_ValueShouldChangeOnce() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); exportProvider.AddExport("Value", 21); var import = ImportDefinitionFactory.Create("Value", true); var importer = PartFactory.CreateImporter(import); engine.SatisfyImports(importer); Assert.Equal(21, importer.GetImport(import)); exportProvider.ReplaceExportValue("Value", 42); Assert.Equal(42, importer.GetImport(import)); engine.ReleaseImports(importer, null); exportProvider.ReplaceExportValue("Value", 666); Assert.Equal(42, importer.GetImport(import)); GC.KeepAlive(importer); }
public void PreviewImports_ReleaseImports_ShouldNotBlockChanges() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); var import = ImportDefinitionFactory.Create("Value"); var importer = PartFactory.CreateImporter(import); exportProvider.AddExport("Value", 21); engine.PreviewImports(importer, null); Assert.Throws <ChangeRejectedException>(() => exportProvider.AddExport("Value", 22)); Assert.Throws <ChangeRejectedException>(() => exportProvider.RemoveExport("Value")); engine.ReleaseImports(importer, null); exportProvider.AddExport("Value", 22); exportProvider.RemoveExport("Value"); GC.KeepAlive(importer); }
public void SatisfyImports_TwoRecomposables_SingleExportValueChanged() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); var import1 = ImportDefinitionFactory.Create("Value1", true); var import2 = ImportDefinitionFactory.Create("Value2", true); var importer = PartFactory.CreateImporter(import1, import2); exportProvider.AddExport("Value1", 21); exportProvider.AddExport("Value2", 23); engine.SatisfyImports(importer); Assert.Equal(21, importer.GetImport(import1)); Assert.Equal(23, importer.GetImport(import2)); importer.ResetImport(import1); importer.ResetImport(import2); // Only change Value1 exportProvider.ReplaceExportValue("Value1", 42); Assert.Equal(42, importer.GetImport(import1)); Assert.Equal(null, importer.GetImport(import2)); GC.KeepAlive(importer); }
public ImportDefinition AddImport(string contractName, ImportCardinality cardinality, bool isRecomposable, bool isPrerequisite) { var import = ImportDefinitionFactory.CreateDefault(contractName, cardinality, isRecomposable, isPrerequisite); this.AddImport(import); return(import); }
public void SatisfyImports_OneRecomposable_OneNotRecomposable() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); var import1 = ImportDefinitionFactory.Create("Value", true); var import2 = ImportDefinitionFactory.Create("Value", false); var importer = PartFactory.CreateImporter(import1, import2); exportProvider.AddExport("Value", 21); engine.SatisfyImports(importer); // Initial compose values should be 21 Assert.Equal(21, importer.GetImport(import1)); Assert.Equal(21, importer.GetImport(import2)); // Reset value to ensure it doesn't get set to same value again importer.ResetImport(import1); importer.ResetImport(import2); Assert.Throws <ChangeRejectedException>(() => exportProvider.ReplaceExportValue("Value", 42)); Assert.Equal(null, importer.GetImport(import1)); Assert.Equal(null, importer.GetImport(import2)); GC.KeepAlive(importer); }
private static ImportDefinition ImportFromContract(string contractName) { return(ImportDefinitionFactory.CreateDefault(contractName, ImportCardinality.ZeroOrMore, false, false)); }
public void GetExports_WhenCatalogDisposed_ShouldThrowObjectDisposed() { var catalog = CreateAssemblyCatalog(); catalog.Dispose(); var definition = ImportDefinitionFactory.Create(); ExceptionAssert.ThrowsDisposed(catalog, () => catalog.GetExports(definition)); }
public void SetImport_WrongDefinitionAsDefinitionArgument_ShouldThrowArgument() { var part = CreateDefaultPart(); var definition = ImportDefinitionFactory.Create(); Assert.Throws <ArgumentException>("definition", () => { part.SetImport(definition, Enumerable.Empty <Export>()); }); }
public void AddExportedValueOfT_ReturnedComposablePart_ExportsArrayWithNullElementAsExportsArgumentToSetImports_ShouldThrowArgument() { CompositionBatch batch = new CompositionBatch(); var part = batch.AddExportedValue <string>("Value"); var definition = ImportDefinitionFactory.Create(); Assert.Throws <ArgumentException>("exports", () => { part.SetImport(definition, new Export[] { null }); }); }
public void PreviewImports_ZeroCollectionImport_ShouldSucceed() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrMore); var importer = PartFactory.CreateImporter(import); engine.PreviewImports(importer, null); GC.KeepAlive(importer); }
public void CreateParsesHeaderRowTrue() { // Arrange var input = "TABLENAME customTableName;\nHEADERROW;\nCOLUMN 0 MyColumnName STRING;"; // Act var id = ImportDefinitionFactory.Create(input); // Assert Assert.IsTrue(id.IsValid()); Assert.IsTrue(id.Definition.HeaderRow); }
public void AddPart_ReturnedComposablePart_NullAsExportsArgumentToSetImports_ShouldThrowArgumentNull() { CompositionBatch batch = new CompositionBatch(); var part = batch.AddPart(new Int32Importer()); var definition = ImportDefinitionFactory.Create(); Assert.Equal(1, batch.PartsToAdd.Count); Assert.Throws <ArgumentNullException>("exports", () => { part.SetImport(definition, (IEnumerable <Export>)null); }); }
public void AddPart_ReturnedComposablePart_WrongDefinitionAsDefinitionArgumentToSetImports_ShouldThrowArgument() { CompositionBatch batch = new CompositionBatch(); var part = batch.AddPart(new Int32Importer()); var definition = ImportDefinitionFactory.Create(); Assert.Equal(1, batch.PartsToAdd.Count); Assert.Throws <ArgumentException>("definition", () => { part.SetImport(definition, Enumerable.Empty <Export>()); }); }
public void AddExportedValueOfT_ReturnedComposablePart_SetImports_ShouldThrowArgument() { CompositionBatch batch = new CompositionBatch(); var part = batch.AddExportedValue <string>("Value"); var definition = ImportDefinitionFactory.Create(); Assert.Equal(1, batch.PartsToAdd.Count); Assert.Throws <ArgumentException>("definition", () => { part.SetImport(definition, Enumerable.Empty <Export>()); }); }
public void AddExportedValue_ReturnedComposablePart_ExportsArrayWithNullElementAsExportsArgumentToSetImports_ShouldThrowArgument() { CompositionBatch batch = new CompositionBatch(); var part = batch.AddExportedValue("Contract", "Value"); var definition = ImportDefinitionFactory.Create(); Assert.AreEqual(1, batch.PartsToAdd.Count); ExceptionAssert.ThrowsArgument <ArgumentException>("exports", () => { part.SetImport(definition, new Export[] { null }); }); }
public void AddExportedValueOfT_ReturnedComposablePart_NullAsExportsArgumentToSetImports_ShouldThrowArgumentNull() { CompositionBatch batch = new CompositionBatch(); var part = batch.AddExportedValue <string>("Value"); var definition = ImportDefinitionFactory.Create(); Assert.AreEqual(1, batch.PartsToAdd.Count); ExceptionAssert.ThrowsArgument <ArgumentNullException>("exports", () => { part.SetImport(definition, (IEnumerable <Export>)null); }); }
public void AddExport_ReturnedComposablePart_SetImports_ShouldThrowArgument() { CompositionBatch batch = new CompositionBatch(); var export = ExportFactory.Create("Contract", "Value"); var part = batch.AddExport(export); var definition = ImportDefinitionFactory.Create(); Assert.AreEqual(1, batch.PartsToAdd.Count); ExceptionAssert.ThrowsArgument <ArgumentException>("definition", () => { part.SetImport(definition, Enumerable.Empty <Export>()); }); }
private void CreateThrowsExceptionOnNullEquivalent(string definition) { try { var id = ImportDefinitionFactory.Create(definition); Assert.Fail("Expected exception, not thrown."); } catch (ArgumentNullException ex) { Assert.AreEqual("ImportDefinitionString", ex.ParamName); } catch (Exception ex) { Assert.Fail("Expected ArgumentNullException, " + ex.GetType().Name + " thrown instead."); } }
public void PreviewImports_ZeroCollectionImport_NonRecomposable_ShouldNotBlockChanges() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrMore, false, false); var importer = PartFactory.CreateImporter(import); engine.PreviewImports(importer, null); exportProvider.AddExport("Value", 21); exportProvider.AddExport("Value", 22); exportProvider.RemoveExport("Value"); GC.KeepAlive(importer); }
public void SatisfyImports_MissingOptionalImport_Recomposable_ShouldNotBlockChanges() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrOne, true, false); var importer = PartFactory.CreateImporter(import); exportProvider.AddExport("Value", 20); engine.SatisfyImports(importer); exportProvider.AddExport("Value", 21); exportProvider.RemoveExport("Value"); GC.KeepAlive(importer); }
public void SatisfyImportsOnce_Unsuccessful_ShouldNotBlockChanges() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); var import = ImportDefinitionFactory.Create("Value"); var importer = PartFactory.CreateImporter(import); Assert.Throws <CompositionException>(() => engine.SatisfyImportsOnce(importer)); exportProvider.AddExport("Value", 22); exportProvider.AddExport("Value", 23); exportProvider.RemoveExport("Value"); GC.KeepAlive(importer); }
public static ImportDefinition CreateImportDefinition() { var sb = new StringBuilder(); sb.AppendLine("TABLENAME TestTable;") .AppendLine("COLUMN 0 ABoolean BOOLEAN;") .AppendLine("COLUMN 1 AByte BYTE;") .AppendLine("COLUMN 2 ACharacter CHAR;") .AppendLine("COLUMN 3 ADateTime DATETIME;") .AppendLine("COLUMN 4 ADecimal DECIMAL;") .AppendLine("COLUMN 5 ADouble DOUBLE;") .AppendLine("COLUMN 6 AGuid GUID;") .AppendLine("COLUMN 7 AnInt16 INT16;") .AppendLine("COLUMN 8 AnInt32 INT32;") .AppendLine("COLUMN 9 AnInt64 INT64;") .AppendLine("COLUMN 10 AString STRING;") .AppendLine("DESTINATION DestinationBoolean BOOLEAN SET {true};") .AppendLine("DESTINATION DestinationByte BYTE SET {254};") .AppendLine("DESTINATION DestinationChar CHAR SET {a};") .AppendLine("DESTINATION DestinationDateTime DATETIME SET {2018-01-01T05:00:00Z};") .AppendLine("DESTINATION DestinationDecimal DECIMAL SET {123.456};") .AppendLine("DESTINATION DestinationDouble DOUBLE SET {1.23};") .AppendLine("DESTINATION DestinationGuid GUID SET {4732B277-11B3-440D-9327-1E2E6613746C};") .AppendLine("DESTINATION DestinationINT16 INT16 SET {32767};") .AppendLine("DESTINATION DestinationINT32 INT32 SET {2147483647};") .AppendLine("DESTINATION DestinationINT64 INT64 SET {9223372036854775807};") .AppendLine("DESTINATION DestinationString STRING SET {This is a string.};") .AppendLine("DESTINATION DestinationSubstituteBoolean BOOLEAN SUBSTITUTE {boolean};") .AppendLine("DESTINATION DestinationSubstituteByte BYTE SUBSTITUTE {byte};") .AppendLine("DESTINATION DestinationSubstituteChar CHAR SUBSTITUTE {char};") .AppendLine("DESTINATION DestinationSubstituteDateTime DATETIME SUBSTITUTE {datetime};") .AppendLine("DESTINATION DestinationSubstituteDecimal DECIMAL SUBSTITUTE {decimal};") .AppendLine("DESTINATION DestinationSubstituteDouble DOUBLE SUBSTITUTE {double};") .AppendLine("DESTINATION DestinationSubstituteGuid GUID SUBSTITUTE {guid};") .AppendLine("DESTINATION DestinationSubstituteInt16 INT16 SUBSTITUTE {int16};") .AppendLine("DESTINATION DestinationSubstituteInt32 INT32 SUBSTITUTE {int32};") .AppendLine("DESTINATION DestinationSubstituteInt64 INT64 SUBSTITUTE {int64};") .AppendLine("DESTINATION DestinationSubstituteString STRING SUBSTITUTE {string};") .AppendLine("DESTINATION DestinationGenerateGuid GUID GENERATE;") .AppendLine("DESTINATION DestinationGenerateDateOnly DATETIME GENERATE DATEONLY;") .AppendLine("DESTINATION DestinationGenerateDateTime DATETIME GENERATE;"); var importDefinitionString = sb.ToString(); var id = ImportDefinitionFactory.Create(importDefinitionString); return(id.Definition); }
public void GetExports_WhenCatalogDisposed_ShouldThrowObjectDisposed() { ExceptionAssert.Throws <ObjectDisposedException>(RetryMode.DoNotRetry, () => { using (var app = new Application()) { app.AppMain(() => { var catalog = new ApplicationCatalog(); catalog.Dispose(); var definition = ImportDefinitionFactory.Create(); catalog.GetExports(definition); }); } }); }
public ImportingComposablePart(string exportContractName, ImportCardinality cardinality, bool isRecomposable, params string[] contractNames) { if (exportContractName != null) { var definition = ExportDefinitionFactory.Create(exportContractName); _exportDefinitions.Add(definition); } foreach (string contractName in contractNames) { var definition = ImportDefinitionFactory.Create(contractName, cardinality, isRecomposable, false); _importDefinitions.Add(definition); } }
private ImportDefinition CreateImportDefinition() { var sb = new StringBuilder(); sb.AppendLine("TABLE SomeTableName;"); sb.AppendLine("COLUMN 0 Boolean BOOLEAN;"); sb.AppendLine("COLUMN 1 Byte BYTE;"); sb.AppendLine("COLUMN 2 Char CHAR;"); sb.AppendLine("COLUMN 3 Date DATETIME;"); sb.AppendLine("COLUMN 4 Decimal DECIMAL;"); sb.AppendLine("COLUMN 5 Double DOUBLE;"); sb.AppendLine("COLUMN 6 UniqueIdentifier GUID;"); sb.AppendLine("COLUMN 7 16-bit-Integer INT16;"); sb.AppendLine("COLUMN 8 32-bit-Integer INT32;"); sb.AppendLine("COLUMN 9 64-bit-Integer INT64;"); sb.AppendLine("COLUMN 10 String STRING;"); return(ImportDefinitionFactory.Create(sb.ToString()).Definition); }
public void PreviewImports_Unsuccessful_AtomicComposition_ShouldNotBlockChanges() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); var import = ImportDefinitionFactory.Create("Value"); var importer = PartFactory.CreateImporter(import); using (var atomicComposition = new AtomicComposition()) { Assert.Throws <ChangeRejectedException>(() => engine.PreviewImports(importer, atomicComposition)); } exportProvider.AddExport("Value", 22); exportProvider.AddExport("Value", 23); exportProvider.RemoveExport("Value"); GC.KeepAlive(importer); }
public void SatisfyImports_ZeroCollectionImport_NonRecomposable_ShouldNotBlockChanges() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); var import = ImportDefinitionFactory.Create("Value", ImportCardinality.ZeroOrMore, false, false); var importer = PartFactory.CreateImporter(import); exportProvider.AddExport("Value", 20); engine.SatisfyImports(importer); Assert.Throws <ChangeRejectedException>(() => exportProvider.AddExport("Value", 21)); Assert.Throws <ChangeRejectedException>(() => exportProvider.RemoveExport("Value")); GC.KeepAlive(importer); }
public void SatisfyImports_Recomposable_Prerequisite_ValueShouldChange() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); var import = ImportDefinitionFactory.Create("Value", true, true); var importer = PartFactory.CreateImporter(import); exportProvider.AddExport("Value", 21); engine.SatisfyImports(importer); Assert.AreEqual(21, importer.GetImport(import)); exportProvider.ReplaceExportValue("Value", 42); Assert.AreEqual(42, importer.GetImport(import), "Value should change!"); GC.KeepAlive(importer); }
public void SatisifyImportsOnce_Recomposable_ValueShouldNotChange_NoRecompositionRequested_ViaNonArgumentSignature() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); exportProvider.AddExport("Value", 21); var import = ImportDefinitionFactory.Create("Value", true); var importer = PartFactory.CreateImporter(import); engine.SatisfyImportsOnce(importer); Assert.Equal(21, importer.GetImport(import)); exportProvider.ReplaceExportValue("Value", 42); Assert.Equal(21, importer.GetImport(import)); GC.KeepAlive(importer); }
public void SatisfyImports_NonRecomposable_Prerequisite_ValueShouldNotChange() { var exportProvider = ExportProviderFactory.CreateRecomposable(); var engine = new ImportEngine(exportProvider); var import = ImportDefinitionFactory.Create("Value", false, true); var importer = PartFactory.CreateImporter(import); exportProvider.AddExport("Value", 21); engine.SatisfyImports(importer); Assert.Equal(21, importer.GetImport(import)); Assert.Throws <ChangeRejectedException>(() => exportProvider.ReplaceExportValue("Value", 42)); Assert.Equal(21, importer.GetImport(import)); GC.KeepAlive(importer); }