public void TestCSAliases()
		{
			Config4Impl config = new Config4Impl();
			JavaSupport javaSupport = new JavaSupport();

			javaSupport.Prepare(config);

			string resolvedName = config.ResolveAliasRuntimeName(UnversionedNameFor(typeof(ClassInfo)));
			Assert.AreEqual("com.db4o.cs.internal.ClassInfo", resolvedName);
		}

		public IdSystemConfigurationImpl(Config4Impl config)
		{
			_config = config;
		}

		protected override bool ApplyRenames(Config4Impl config)
		{
			LogMsg(58, null);
			return false;
		}

		public FileConfigurationImpl(Config4Impl config)
		{
			_config = config;
		}

			public ConfigDeepCloneContext(Config4Impl orig, Config4Impl cloned)
			{
				_orig = orig;
				_cloned = cloned;
			}

		public ClassInfoHelper(Config4Impl config)
		{
			_config = config;
		}

		private int Frequency(Config4Impl config)
		{
			return Math.Min(config.TimeoutClientSocket(), config.TimeoutServerSocket()) / 4;
		}

		protected virtual bool ApplyRenames(Config4Impl config)
		{
			bool renamed = false;
			IEnumerator i = config.Rename().GetEnumerator();
			while (i.MoveNext())
			{
				Rename ren = (Rename)i.Current;
				if (AlreadyApplied(ren))
				{
					continue;
				}
				if (ApplyRename(ren))
				{
					renamed = true;
				}
			}
			return renamed;
		}

		public CacheConfigurationImpl(Config4Impl config)
		{
			_config = config;
		}

			public override void Configure(Config4Impl config)
			{
				config.Freespace().UseRamSystem();
			}

		internal virtual void Rename(Config4Impl config)
		{
			bool renamedOne = false;
			if (config.Rename() != null)
			{
				renamedOne = ApplyRenames(config);
			}
			_classCollection.CheckChanges();
			if (renamedOne)
			{
				Reboot();
			}
		}

		public ServerConfigurationImpl(Config4Impl config) : base(config)
		{
		}

		private void InitializeReferenceSystemFactory(Config4Impl config)
		{
			_referenceSystemFactory = config.ReferenceSystemFactory();
		}

		private Config4Impl PrepareConfig(Config4Impl originalConfig, IStorage storage, bool
			 readOnly)
		{
			Config4Impl sourceConfig = (Config4Impl)originalConfig.DeepClone(null);
			sourceConfig.WeakReferences(false);
			sourceConfig.Storage = storage;
			sourceConfig.ReadOnly(readOnly);
			return sourceConfig;
		}

 public TypeHandlerConfigurationDotNet(Config4Impl config) : base(config)
 {
     ListTypeHandler(new CollectionTypeHandler());
     MapTypeHandler(new MapTypeHandler());
 }

 public NetworkingConfigurationProviderImpl(Config4Impl config)
 {
     _networking = new NetworkingConfigurationImpl(config);
 }

		public TypeHandlerConfiguration(Config4Impl config)
		{
			_config = config;
		}

		public CommonConfigurationImpl(Config4Impl config)
		{
			_config = config;
		}

		public object DeepClone(object param)
		{
			Config4Impl ret = new Config4Impl();
			Config4Impl.ConfigDeepCloneContext context = new Config4Impl.ConfigDeepCloneContext
				(this, ret);
			ret._config = (KeySpecHashtable4)_config.DeepClone(context);
			ret._internStrings = _internStrings;
			ret._messageLevel = _messageLevel;
			ret._readOnly = _readOnly;
			if (_registeredTypeHandlers != null)
			{
				ret._registeredTypeHandlers = (Collection4)_registeredTypeHandlers.DeepClone(context
					);
			}
			return ret;
		}

		internal void InitEncryption(Config4Impl a_config)
		{
			if (a_config.Encrypt() && a_config.Password() != null && a_config.Password().Length
				 > 0)
			{
				i_encrypt = true;
				i_encryptor = new byte[a_config.Password().Length];
				for (int i = 0; i < i_encryptor.Length; i++)
				{
					i_encryptor[i] = (byte)(a_config.Password()[i] & unchecked((int)(0xff)));
				}
				i_lastEncryptorByte = a_config.Password().Length - 1;
				return;
			}
			OldEncryptionOff();
		}