MiniContext( string name ) { ServiceContainer = new SimpleServiceContainer(); ServiceContainer.Add( RequirementLayerSerializer.Instance ); ServiceContainer.Add( SimpleTypeFinder.Default ); ConfigContainer = SharedDictionary.Create( ServiceContainer ); ConfigManager = ConfigurationManager.Create( ConfigContainer ).ConfigManager; }
static SharedDicTestContext() { _allPlugins = new List<INamedVersionedUniqueId>(); _allPluginsEx = new ReadOnlyListOnIList<INamedVersionedUniqueId>( _allPlugins ); EnsurePlugins( 10 ); var c = new SimpleServiceContainer(); c.Add<ISimpleTypeFinder>( SimpleTypeFinder.Default ); _serviceProvider = c; }
public ReaderImpl( XmlReader reader, IServiceProvider baseServiceProvider, Version storageVersion, bool autoCloseReader ) : base(null) { Current = this; _xmlReader = reader; _serviceContainer = new SimpleServiceContainer( baseServiceProvider ); _path = new List<string>(); _pathEx = new ReadOnlyListOnIList<string>( _path ); _storageVersion = storageVersion; _mustCloseReader = autoCloseReader; }
MiniContext( string name ) { ServiceContainer = new SimpleServiceContainer(); ContextObject = new object(); ConfigContainer = SharedDictionary.Create( ServiceContainer ); ConfigManager = ConfigurationManager.Create( ConfigContainer ).ConfigManager; PluginRunner = new PluginRunner( ServiceContainer, ConfigManager ); PluginRunner.Initialize( ContextObject ); ServiceContainer.Add<IConfigContainer>( ConfigContainer ); }
public WriterImpl( XmlWriter writer, IServiceProvider baseServiceProvider, bool writeElementHeader, bool autoCloseWriter ) : base(null) { _xmlWriter = writer; _serviceContainer = new SimpleServiceContainer( baseServiceProvider ); if( writeElementHeader ) { Xml.WriteStartElement( "CK-Structured" ); Xml.WriteAttributeString( "version", "2.5.5" ); _mustEndElement = true; } _mustCloseWriter = autoCloseWriter; Current = this; }
public void WriteReadUserConfig() { string path = Path.Combine( TestFolder, "UserConfig.xml" ); Guid id = new Guid("{6AFBAE01-5CD1-4EDE-BB56-4590C5A253DF}"); // Write ---------------------------------------------------------- { ISharedDictionary dic = SharedDictionary.Create( null ); IConfigManagerExtended config = ConfigurationManager.Create( dic ); Assert.That( config, Is.Not.Null ); Assert.That( config.HostUserConfig, Is.Not.Null ); Assert.That( config.ConfigManager.UserConfiguration, Is.Not.Null ); config.HostUserConfig["key1"] = "value1"; config.HostUserConfig["key2"] = "value2"; config.HostUserConfig["key3"] = "value3"; config.ConfigManager.UserConfiguration.PluginsStatus.SetStatus( id, ConfigPluginStatus.AutomaticStart ); Assert.That( config.IsUserConfigDirty ); Assert.That( config.IsSystemConfigDirty, Is.False ); using( Stream wrt = new FileStream( path, FileMode.Create ) ) using( IStructuredWriter sw = SimpleStructuredWriter.CreateWriter( wrt, null ) ) { config.SaveUserConfig( sw ); } } // Read ------------------------------------------------------------ { ISimpleServiceContainer container = new SimpleServiceContainer(); ISharedDictionary dic = SharedDictionary.Create( container ); IConfigManagerExtended config = ConfigurationManager.Create( dic ); using( Stream str = new FileStream( path, FileMode.Open ) ) using( IStructuredReader sr = SimpleStructuredReader.CreateReader( str, container ) ) { config.LoadUserConfig( sr ); } Assert.That( config.HostUserConfig["key1"], Is.EqualTo( "value1" ) ); Assert.That( config.HostUserConfig["key2"], Is.EqualTo( "value2" ) ); Assert.That( config.HostUserConfig["key3"], Is.EqualTo( "value3" ) ); Assert.That( config.ConfigManager.UserConfiguration.PluginsStatus.GetStatus( id, ConfigPluginStatus.Disabled ) == ConfigPluginStatus.AutomaticStart ); } }
public ReaderImpl( XmlReader reader, IServiceProvider baseServiceProvider, bool autoCloseReader ) : base(null) { if( reader == null ) throw new ArgumentNullException( "reader" ); Current = this; _xmlReader = reader; _serviceContainer = new SimpleServiceContainer( baseServiceProvider ); _path = new List<string>(); _pathEx = new ReadOnlyListOnIList<string>( _path ); if( reader.IsStartElement( "CK-Structured" ) ) { _storageVersion = new Version( reader.GetAttribute( "version" ) ); _isEmpty = reader.IsEmptyElement; if( !_isEmpty ) _openingElementName = reader.Name; reader.Read(); } _mustCloseReader = autoCloseReader; }
public void EmptyFile() { string test = TestBase.GetTestFilePath( "Storage", "EmptyFile" ); using( Stream wrt = new FileStream( test, FileMode.Create ) ) { IStructuredWriter writer = SimpleStructuredWriter.CreateWriter( wrt, new SimpleServiceContainer() ); writer.Dispose(); } Assert.That( File.Exists( test ) ); using( Stream str = new FileStream( test, FileMode.Open ) ) { SimpleServiceContainer s = new SimpleServiceContainer(); s.Add( typeof( ISimpleTypeFinder ), SimpleTypeFinder.WeakDefault, null ); using( IStructuredReader reader = SimpleStructuredReader.CreateReader( str, s ) ) { Assert.That( reader.StorageVersion, Is.GreaterThanOrEqualTo( new Version( 2, 5, 0 ) ) ); } } }
private void DoTestEnum( Action<XDocument> docModifier ) { string test = TestBase.GetTestFilePath( "Storage", "TestEnum" ); using( Stream wrt = new FileStream( test, FileMode.Create ) ) { using( IStructuredWriter writer = SimpleStructuredWriter.CreateWriter( wrt, new SimpleServiceContainer() ) ) { writer.WriteObjectElement( "data", TestEnumValues.First ); writer.WriteObjectElement( "data", TestEnumValues.Second ); writer.WriteObjectElement( "After", 3712 * 2 ); } } LoadAndModifyXml( test, docModifier ); using( Stream str = new FileStream( test, FileMode.Open ) ) { SimpleServiceContainer s = new SimpleServiceContainer(); s.Add( typeof( ISimpleTypeFinder ), SimpleTypeFinder.WeakDefault, null ); using( IStructuredReader reader = SimpleStructuredReader.CreateReader( str, s ) ) { TestEnumValues value1 = (TestEnumValues)reader.ReadObjectElement( "data" ); TestEnumValues value2 = (TestEnumValues)reader.ReadObjectElement( "data" ); Assert.That( value1, Is.EqualTo( TestEnumValues.First ) ); Assert.That( value2, Is.EqualTo( TestEnumValues.Second ) ); Assert.That( reader.ReadObjectElement( "After" ), Is.EqualTo( 3712 * 2 ) ); } } }
public void BugUnexisting() { string xmlPath = TestBase.GetTestFilePath( "Storage", "BugUnexistingEnum" ); using( Stream wrt = new FileStream( xmlPath, FileMode.Create ) ) { using( IStructuredWriter writer = SimpleStructuredWriter.CreateWriter( wrt, new SimpleServiceContainer() ) ) { writer.WriteObjectElement( "data", UnexistingTestEnumValues.First ); writer.WriteObjectElement( "After", 3712 * 2 ); writer.WriteObjectElement( "data", new MayBeUnexistingButValidXmlObject() ); writer.WriteObjectElement( "After2", 3712 * 3 ); } } TestBase.DumpFileToConsole( xmlPath ); using( Stream str = new FileStream( xmlPath, FileMode.Open ) ) { SimpleServiceContainer s = new SimpleServiceContainer(); s.Add<ISimpleTypeFinder>( new UnexistingTypeFinder() ); using( IStructuredReader reader = SimpleStructuredReader.CreateReader( str, s ) ) { Assert.Throws<TypeLoadException>( () => reader.ReadObjectElement( "data" ) ); // An exception does not break the reader. Assert.That( reader.ReadObjectElement( "After" ), Is.EqualTo( 3712 * 2 ) ); Assert.Throws<TypeLoadException>( () => reader.ReadObjectElement( "data" ) ); // An exception does not break the reader. Assert.That( reader.ReadObjectElement( "After2" ), Is.EqualTo( 3712 * 3 ) ); } } }
public void BugBinarySizeDiffer() { string xmlPath = TestBase.GetTestFilePath( "Storage", "BugBinarySizeDiffer" ); SerializableObject original = new SerializableObject() { Name = "coucou", Power = 20 }; using( Stream wrt = new FileStream( xmlPath, FileMode.Create ) ) { using( IStructuredWriter writer = SimpleStructuredWriter.CreateWriter( wrt, new SimpleServiceContainer() ) ) { writer.WriteObjectElement( "data", original ); } } LoadAndModifyXml( xmlPath, d => d.Root.Element( "data" ).Attribute( "size" ).SetValue( "1" ) ); using( Stream str = new FileStream( xmlPath, FileMode.Open ) ) { SimpleServiceContainer s = new SimpleServiceContainer(); s.Add( typeof( ISimpleTypeFinder ), SimpleTypeFinder.WeakDefault, null ); using( IStructuredReader reader = SimpleStructuredReader.CreateReader( str, s ) ) { Assert.Throws<CKException>( () => reader.ReadObjectElement( "data" ) ); } } }
public void StructuredSerializedObjectTest() { string xmlPath = TestBase.GetTestFilePath( "Storage", "FakeStructuredSerializedObject" ); StructuredSerializableObject original = new StructuredSerializableObject() { OneInteger = 43, OneString = "Let's go..." }; using( Stream wrt = new FileStream( xmlPath, FileMode.Create ) ) { using( IStructuredWriter writer = SimpleStructuredWriter.CreateWriter( wrt, new SimpleServiceContainer() ) ) { writer.ObjectWriteExData += ( s, e ) => { if( e.Obj == original ) { e.Writer.Xml.WriteStartElement( "ExtraData" ); e.Writer.Xml.WriteAttributeString( "OneAtrribute", "23" ); e.Writer.Xml.WriteElementString( "SubValue", "string in element..." ); e.Writer.Xml.WriteEndElement(); } }; writer.WriteObjectElement( "data", original ); writer.WriteObjectElement( "After", 3712 * 2 ); } } TestBase.DumpFileToConsole( xmlPath ); // Reads without reading ExtraData element. using( Stream str = new FileStream( xmlPath, FileMode.Open ) ) { SimpleServiceContainer s = new SimpleServiceContainer(); s.Add<ISimpleTypeFinder>( SimpleTypeFinder.WeakDefault ); using( IStructuredReader reader = SimpleStructuredReader.CreateReader( str, s ) ) { object read = reader.ReadObjectElement( "data" ); Assert.That( read, Is.TypeOf( typeof( StructuredSerializableObject ) ) ); StructuredSerializableObject newOne = read as StructuredSerializableObject; Assert.That( newOne.OneString, Is.EqualTo( original.OneString ) ); Assert.That( newOne.OneInteger, Is.EqualTo( original.OneInteger ) ); Assert.That( reader.ReadObjectElement( "After" ), Is.EqualTo( 3712 * 2 ) ); } } // Reads ExtraData element. using( Stream str = new FileStream( xmlPath, FileMode.Open ) ) { SimpleServiceContainer s = new SimpleServiceContainer(); s.Add<ISimpleTypeFinder>( SimpleTypeFinder.WeakDefault ); using( IStructuredReader reader = SimpleStructuredReader.CreateReader( str, s ) ) { reader.ObjectReadExData += ( source, e ) => { Assert.That( e.Reader.Xml.IsStartElement( "ExtraData" ) ); Assert.That( e.Reader.Xml.GetAttributeInt( "OneAtrribute", -12 ), Is.EqualTo( 23 ) ); e.Reader.Xml.Read(); Assert.That( e.Reader.Xml.ReadElementContentAsString(), Is.EqualTo( "string in element..." ) ); // Forget to read the end element. Assert.That( e.Reader.Xml.NodeType == XmlNodeType.EndElement ); }; object read = reader.ReadObjectElement( "data" ); Assert.That( read, Is.TypeOf( typeof( StructuredSerializableObject ) ) ); StructuredSerializableObject newOne = read as StructuredSerializableObject; Assert.That( newOne.OneString, Is.EqualTo( original.OneString ) ); Assert.That( newOne.OneInteger, Is.EqualTo( original.OneInteger ) ); Assert.That( reader.ReadObjectElement( "After" ), Is.EqualTo( 3712 * 2 ) ); } } }
public void BugBinaryTooBigContent() { string xmlPath = TestBase.GetTestFilePath( "Storage", "BugBinaryTooBigContent" ); SerializableObject original = new SerializableObject() { Name = "coucou", Power = 20 }; using( Stream wrt = new FileStream( xmlPath, FileMode.Create ) ) { using( IStructuredWriter writer = SimpleStructuredWriter.CreateWriter( wrt, new SimpleServiceContainer() ) ) { writer.WriteObjectElement( "data", original ); } } LoadAndModifyXml( xmlPath, d => { var e = d.Root.Element( "data" ); e.SetValue( e.Value.Insert( e.Value.Length / 2, "00FF00FF" ) ); } ); using( Stream str = new FileStream( xmlPath, FileMode.Open ) ) { SimpleServiceContainer s = new SimpleServiceContainer(); s.Add( typeof( ISimpleTypeFinder ), SimpleTypeFinder.WeakDefault, null ); using( IStructuredReader reader = SimpleStructuredReader.CreateReader( str, s ) ) { object obj = reader.ReadObjectElement( "data" ); } } }
public void BinarySerializableObject() { string xmlPath = TestBase.GetTestFilePath( "Storage", "TestBinarySerializableObject" ); SerializableObject o = new SerializableObject(); o.Name = "TestName"; o.Power = 20; using( Stream wrt = new FileStream( xmlPath, FileMode.Create ) ) { using( IStructuredWriter writer = SimpleStructuredWriter.CreateWriter( wrt, new SimpleServiceContainer() ) ) { writer.WriteObjectElement( "Before", 3712 ); writer.WriteObjectElement( "data", o ); writer.WriteObjectElement( "After", 3712 * 2 ); } } using( Stream str = new FileStream( xmlPath, FileMode.Open ) ) { SimpleServiceContainer s = new SimpleServiceContainer(); s.Add( typeof( ISimpleTypeFinder ), SimpleTypeFinder.WeakDefault, null ); using( IStructuredReader reader = SimpleStructuredReader.CreateReader( str, s ) ) { Assert.That( reader.ReadObjectElement( "Before" ), Is.EqualTo( 3712 ) ); SerializableObject o2 = (SerializableObject)reader.ReadObjectElement( "data" ); Assert.AreEqual( o.Name, o2.Name ); Assert.AreEqual( o.Power, o2.Power ); Assert.That( reader.ReadObjectElement( "After" ), Is.EqualTo( 3712 * 2 ) ); } } }
public void ArrayListWithSerializableObjects() { string xmlPath = TestBase.GetTestFilePath( "Storage", "TestGenericListOfString" ); ArrayList list = new ArrayList(); SerializableObject firstObject = new SerializableObject() { Name = "Albert", Power = 34 }; list.Add( firstObject ); list.Add( new DateTime( 2009, 01, 11 ) ); list.Add( "Franchement, les mecs, vous trouvez que c'est normal que ce soit Spi qui se cogne tous les tests unitaires ?" ); using( Stream wrt = new FileStream( xmlPath, FileMode.Create ) ) { using( IStructuredWriter writer = SimpleStructuredWriter.CreateWriter( wrt, new SimpleServiceContainer() ) ) { writer.WriteObjectElement( "data", list ); writer.WriteObjectElement( "After", 3712 * 2 ); } } using( Stream str = new FileStream( xmlPath, FileMode.Open ) ) { SimpleServiceContainer s = new SimpleServiceContainer(); s.Add( typeof( ISimpleTypeFinder ), SimpleTypeFinder.WeakDefault, null ); using( IStructuredReader reader = SimpleStructuredReader.CreateReader( str, s ) ) { ArrayList list2 = (ArrayList)reader.ReadObjectElement( "data" ); Assert.AreEqual( ((SerializableObject)list2[0]).Name, ((SerializableObject)list[0]).Name ); Assert.AreEqual( ((SerializableObject)list2[0]).Power, ((SerializableObject)list[0]).Power ); CheckExactTypeAndValue( typeof( DateTime ), list[1], list2[1] ); CheckExactTypeAndValue( typeof( string ), list[2], list2[2] ); Assert.That( reader.ReadObjectElement( "After" ), Is.EqualTo( 3712 * 2 ) ); } } }
public void ColorStruct() { string xmlPath = TestBase.GetTestFilePath( "Storage", "TestColor" ); using( Stream wrt = new FileStream( xmlPath, FileMode.Create ) ) { using( IStructuredWriter writer = SimpleStructuredWriter.CreateWriter( wrt, new SimpleServiceContainer() ) ) { writer.WriteObjectElement( "data", Color.Red ); writer.WriteObjectElement( "data", Color.Blue ); writer.WriteObjectElement( "After", 3712 * 2 ); } } using( Stream str = new FileStream( xmlPath, FileMode.Open ) ) { SimpleServiceContainer s = new SimpleServiceContainer(); //s.Add( typeof( ISimpleTypeFinder ), SimpleTypeFinder.WeakDefault, null ); using( IStructuredReader reader = SimpleStructuredReader.CreateReader( str, s ) ) { CheckExactTypeAndValue( typeof( Color ), Color.Red, reader.ReadObjectElement( "data" ) ); CheckExactTypeAndValue( typeof( Color ), Color.Blue, reader.ReadObjectElement( "data" ) ); Assert.That( reader.ReadObjectElement( "After" ), Is.EqualTo( 3712 * 2 ) ); } } }
public void GenericListOfString() { string xmlPath = TestBase.GetTestFilePath( "Storage", "TestGenericListOfString" ); List<string> list = new List<string>(); list.Add( "content1" ); list.Add( "content2" ); list.Add( "content3" ); using( Stream wrt = new FileStream( xmlPath, FileMode.Create ) ) { using( IStructuredWriter writer = SimpleStructuredWriter.CreateWriter( wrt, new SimpleServiceContainer() ) ) { writer.WriteObjectElement( "Before", 3712 ); writer.WriteObjectElement( "data", list ); writer.WriteObjectElement( "After", 3712 * 2 ); } } using( Stream str = new FileStream( xmlPath, FileMode.Open ) ) { SimpleServiceContainer s = new SimpleServiceContainer(); s.Add<ISimpleTypeFinder>( SimpleTypeFinder.WeakDefault ); using( IStructuredReader reader = SimpleStructuredReader.CreateReader( str, s ) ) { Assert.That( reader.ReadObjectElement( "Before" ), Is.EqualTo( 3712 ) ); CheckExactTypeAndValue( typeof( List<string> ), list, reader.ReadObjectElement( "data" ) ); Assert.That( reader.ReadObjectElement( "After" ), Is.EqualTo( 3712 * 2 ) ); } } }