/// <exception cref="System.Exception"></exception>
protected override void Configure(IConfiguration config)
{
config.DatabaseGrowthSize(Size);
config.BlockSize(3);
Db4oLegacyConfigurationBridge.AsIdSystemConfiguration(config).UsePointerBasedSystem
();
}
/// <exception cref="System.Exception"></exception>
protected override void Configure(IConfiguration config)
{
base.Configure(config);
config.Freespace().UseBTreeSystem();
configuration = config;
Db4oLegacyConfigurationBridge.AsIdSystemConfiguration(config).UseInMemorySystem();
}
protected override IObjectContainer CreateDatabase(IConfiguration config)
{
var embeddedConfiguration = Db4oLegacyConfigurationBridge.AsEmbeddedConfiguration
(config);
switch (_idSystemType)
{
case StandardIdSystemFactory.PointerBased:
{
embeddedConfiguration.IdSystem.UsePointerBasedSystem();
break;
}
case StandardIdSystemFactory.StackedBtree:
{
embeddedConfiguration.IdSystem.UseStackedBTreeSystem();
break;
}
case StandardIdSystemFactory.InMemory:
{
embeddedConfiguration.IdSystem.UseInMemorySystem();
break;
}
default:
{
throw new InvalidOperationException();
}
}
// embeddedConfiguration.file().freespace().useBTreeSystem();
return(base.CreateDatabase(config));
}
public void Prepare(IConfiguration configuration)
{
#if NET_3_5
var common = Db4oLegacyConfigurationBridge.AsCommonConfiguration(configuration);
common.Environment.Add(new LinqQueryMonitor());
#endif
}
/// <exception cref="System.Exception"></exception>
protected override void Configure(IConfiguration config)
{
var idSystemConfiguration = Db4oLegacyConfigurationBridge.AsIdSystemConfiguration
(config);
idSystemConfiguration.UseCustomSystem(new _IIdSystemFactory_29());
}
/// <exception cref="System.Exception"></exception>
protected override void Configure(IConfiguration legacy)
{
base.Configure(legacy);
ICommonConfiguration common = Db4oLegacyConfigurationBridge.AsCommonConfiguration
(legacy);
common.Environment.Add(_service);
}
/// <exception cref="System.Exception"></exception>
protected override void Configure(IConfiguration config)
{
IIdSystemConfiguration idSystemConfiguration = Db4oLegacyConfigurationBridge.AsIdSystemConfiguration
(config);
((IdSystemTestSuite.IIdSystemProvider)_fixture.Value).Apply(idSystemConfiguration
);
}
private void Open()
{
IConfiguration config = ((IConfiguration)_currentConfig.Run());
Db4oLegacyConfigurationBridge.AsIdSystemConfiguration(config).UsePointerBasedSystem
();
_container = (LocalObjectContainer)Db4oFactory.OpenFile(config, TempFile());
}
/// <exception cref="Db4objects.Db4o.Ext.OldFormatException"></exception>
public static IEmbeddedObjectContainer OpenObjectContainer(IEmbeddedConfiguration
config, string databaseFileName)
{
IConfiguration legacyConfig = Db4oLegacyConfigurationBridge.AsLegacy(config);
Config4Impl.AssertIsNotTainted(legacyConfig);
EmitDebugInfo();
IEmbeddedObjectContainer oc = new IoAdaptedObjectContainer(legacyConfig, databaseFileName
);
((EmbeddedConfigurationImpl)config).ApplyConfigurationItems(oc);
Db4objects.Db4o.Internal.Messages.LogMsg(legacyConfig, 5, databaseFileName);
return(oc);
}
/// <exception cref="System.Exception"></exception>
public virtual void Test()
{
if (CommonAndLocalConfigurationTestSuite.Subject() is IClientConfiguration)
{
return;
}
IFileConfigurationProvider config = ((IFileConfigurationProvider)Subject());
IFileConfiguration fileConfig = config.File;
Config4Impl legacyConfig = Db4oLegacyConfigurationBridge.AsLegacy(config);
fileConfig.BlockSize = 42;
Assert.AreEqual(42, legacyConfig.BlockSize());
fileConfig.DatabaseGrowthSize = 42;
Assert.AreEqual(42, legacyConfig.DatabaseGrowthSize());
fileConfig.DisableCommitRecovery();
Assert.IsTrue(legacyConfig.CommitRecoveryDisabled());
fileConfig.Freespace.DiscardSmallerThan(8);
Assert.AreEqual(8, legacyConfig.DiscardFreeSpace());
fileConfig.GenerateUUIDs = ConfigScope.Globally;
Assert.AreEqual(ConfigScope.Globally, legacyConfig.GenerateUUIDs());
fileConfig.GenerateCommitTimestamps = true;
Assert.IsTrue(legacyConfig.GenerateCommitTimestamps().DefiniteYes());
IStorage storageFactory = new FileStorage();
fileConfig.Storage = storageFactory;
Assert.AreSame(storageFactory, legacyConfig.Storage);
Assert.AreSame(storageFactory, fileConfig.Storage);
fileConfig.LockDatabaseFile = true;
Assert.IsTrue(legacyConfig.LockFile());
fileConfig.ReserveStorageSpace = 1024;
Assert.AreEqual(1024, legacyConfig.ReservedStorageSpace());
fileConfig.BlobPath = Path.GetTempPath();
Assert.AreEqual(Path.GetTempPath(), legacyConfig.BlobPath());
fileConfig.ReadOnly = true;
Assert.IsTrue(legacyConfig.IsReadOnly());
ICacheConfigurationProvider cacheProvider = ((ICacheConfigurationProvider)Subject
());
ICacheConfiguration cache = cacheProvider.Cache;
IIdSystemConfigurationProvider idSystemConfigurationProvider = ((IIdSystemConfigurationProvider
)Subject());
IIdSystemConfiguration idSystemConfiguration = idSystemConfigurationProvider.IdSystem;
Assert.AreEqual(StandardIdSystemFactory.Default, legacyConfig.IdSystemType());
idSystemConfiguration.UseStackedBTreeSystem();
Assert.AreEqual(StandardIdSystemFactory.StackedBtree, legacyConfig.IdSystemType()
);
idSystemConfiguration.UsePointerBasedSystem();
Assert.AreEqual(StandardIdSystemFactory.PointerBased, legacyConfig.IdSystemType()
);
}
public override void Configure(Config4Impl config)
{
Db4oLegacyConfigurationBridge.AsIdSystemConfiguration(config).UseStackedBTreeSystem
();
}
public override void Configure(Config4Impl config)
{
Db4oLegacyConfigurationBridge.AsIdSystemConfiguration(config).UseInMemorySystem();
}
public override void Configure(Config4Impl config)
{
Db4oLegacyConfigurationBridge.AsIdSystemConfiguration(config).UsePointerBasedSystem
();
}
public virtual void Test()
{
ICommonConfigurationProvider config = ((ICommonConfigurationProvider)Subject());
Config4Impl legacy = Db4oLegacyConfigurationBridge.AsLegacy(config);
ICommonConfiguration common = config.Common;
common.ActivationDepth = 42;
Assert.AreEqual(42, legacy.ActivationDepth());
Assert.AreEqual(42, common.ActivationDepth);
// TODO: assert
common.Add(new _IConfigurationItem_41());
TypeAlias alias = new TypeAlias("foo", "bar");
common.AddAlias(alias);
Assert.AreEqual("bar", legacy.ResolveAliasStoredName("foo"));
Assert.AreEqual("foo", legacy.ResolveAliasRuntimeName("bar"));
common.RemoveAlias(alias);
Assert.AreEqual("foo", legacy.ResolveAliasStoredName("foo"));
common.AllowVersionUpdates = false;
Assert.IsFalse(legacy.AllowVersionUpdates());
common.AutomaticShutDown = false;
Assert.IsFalse(legacy.AutomaticShutDown());
common.BTreeNodeSize = 42;
Assert.AreEqual(42, legacy.BTreeNodeSize());
common.Callbacks = false;
Assert.AreEqual(CallBackMode.None, legacy.CallbackMode());
common.CallConstructors = false;
Assert.IsTrue(legacy.CallConstructors().DefiniteNo());
common.DetectSchemaChanges = false;
Assert.IsFalse(legacy.DetectSchemaChanges());
DiagnosticCollector collector = new DiagnosticCollector();
common.Diagnostic.AddListener(collector);
IDiagnostic diagnostic = DummyDiagnostic();
legacy.DiagnosticProcessor().OnDiagnostic(diagnostic);
collector.Verify(new object[] { diagnostic });
common.ExceptionsOnNotStorable = true;
Assert.IsTrue(legacy.ExceptionsOnNotStorable());
common.InternStrings = true;
Assert.IsTrue(legacy.InternStrings());
// TODO: assert
common.MarkTransient("Foo");
common.MessageLevel = 3;
Assert.AreEqual(3, legacy.MessageLevel());
IObjectClass objectClass = common.ObjectClass(typeof(CommonAndLocalConfigurationTestSuite.BaseConfigurationProviderTestUnit.Item
));
objectClass.CascadeOnDelete(true);
Assert.IsTrue(((Config4Class)legacy.ObjectClass(typeof(CommonAndLocalConfigurationTestSuite.BaseConfigurationProviderTestUnit.Item
))).CascadeOnDelete().DefiniteYes());
Assert.IsTrue(((Config4Class)common.ObjectClass(typeof(CommonAndLocalConfigurationTestSuite.BaseConfigurationProviderTestUnit.Item
))).CascadeOnDelete().DefiniteYes());
common.OptimizeNativeQueries = false;
Assert.IsFalse(legacy.OptimizeNativeQueries());
Assert.IsFalse(common.OptimizeNativeQueries);
common.Queries.EvaluationMode(QueryEvaluationMode.Lazy);
Assert.AreEqual(QueryEvaluationMode.Lazy, legacy.EvaluationMode());
// TODO: test reflectWith()
// TODO: this probably won't sharpen :/
TextWriter outStream = Sharpen.Runtime.Out;
common.OutStream = outStream;
Assert.AreEqual(outStream, legacy.OutStream());
IStringEncoding stringEncoding = new _IStringEncoding_113();
common.StringEncoding = stringEncoding;
Assert.AreEqual(stringEncoding, legacy.StringEncoding());
common.TestConstructors = false;
Assert.IsFalse(legacy.TestConstructors());
common.TestConstructors = true;
Assert.IsTrue(legacy.TestConstructors());
common.UpdateDepth = 1024;
Assert.AreEqual(1024, legacy.UpdateDepth());
common.WeakReferences = false;
Assert.IsFalse(legacy.WeakReferences());
common.WeakReferenceCollectionInterval = 1024;
Assert.AreEqual(1024, legacy.WeakReferenceCollectionInterval());
}
protected override void Configure(IConfiguration config)
{
IFileConfiguration fileConfig = Db4oLegacyConfigurationBridge.AsFileConfiguration((Config4Impl)config);
fileConfig.Storage = new MemoryStorage();
}
public static IObjectContainer OpenFile(IConfiguration config, string databaseFileName
)
{
return(ObjectContainerFactory.OpenObjectContainer(Db4oLegacyConfigurationBridge.AsEmbeddedConfiguration
(config), databaseFileName));
}
private void ConfigureIdSystem(IConfiguration config)
{
Db4oLegacyConfigurationBridge.AsIdSystemConfiguration(config).UseCustomSystem(_idSystemFactory
);
}
private void ConfigureMaximumFileSize(IConfiguration config)
{
Db4oLegacyConfigurationBridge.AsFileConfiguration(config).MaximumDatabaseFileSize
= 10000;
}
