public void TestAddDataSerializableFactoryWithBadId() { var config = new SerializationConfig(); config.AddDataSerializableFactory(-1, new MyDataSerializableFactory()); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }
internal XmlDocument ToXml(string group, ITestResultSerializerFactory serializerFactory) { XmlDocument doc = new XmlDocument(); //Check Metadata for xml serializer type, TDS is default value MetaDataEntry entry = ServiceLocator.Resolve <ConfigurationHolder>().GetFromMetaData(this.ProjectID, group, "XMLVersion"); XMLAdapter.AdapterType xmlType = XMLAdapter.AdapterType.TDS; if (entry != null) { xmlType = Utilities.Utility.Value(entry.TextVal, XMLAdapter.AdapterType.TDS); } // if set to 1/true, any demographics in the file will be preserved // Used only in the OSS environment to minimize configuration entry = ServiceLocator.Resolve <ConfigurationHolder>().GetFromMetaData(this.ProjectID, group, "IncludeAllDemographics"); SerializationConfig config = null; if (entry != null && Convert.ToBoolean(entry.IntVal)) { config = new SerializationConfigIncludeAllDemographics(); } else { //get the serialization config from the project metadata config = new SerializationConfig(/*ConfigurationHolder.IncludeAccommodations(ProjectID, group),*/ ServiceLocator.Resolve <ConfigurationHolder>().GetRTSAttributes(this.projectID, group)); } doc.LoadXml(serializerFactory.CreateSerializer(xmlType.ToString(), this).Serialize(config)); return(doc); }
public void TestClassDefinitionConfigWithErrors() { var serializationConfig = new SerializationConfig(); serializationConfig.AddPortableFactory(TestSerializationConstants.PORTABLE_FACTORY_ID, new TestPortableFactory()); serializationConfig.SetPortableVersion(1); serializationConfig.AddClassDefinition( new ClassDefinitionBuilder(TestSerializationConstants.PORTABLE_FACTORY_ID, TestSerializationConstants.RAW_DATA_PORTABLE) .AddLongField("l") .AddCharArrayField("c") .AddPortableField("p", CreateNamedPortableClassDefinition()) .Build()); try { new SerializationServiceBuilder().SetConfig(serializationConfig).Build(); Assert.Fail("Should throw HazelcastSerializationException!"); } catch (HazelcastSerializationException) { } new SerializationServiceBuilder().SetConfig(serializationConfig).SetCheckClassDefErrors(false).Build(); // -- OR -- serializationConfig.SetCheckClassDefErrors(false); new SerializationServiceBuilder().SetConfig(serializationConfig).Build(); }
static JsonRemotingRequestBody() { SerializationConfig <JsonRemotingRequestBody> .RegisterSerializer(arg => { if (arg == null) { return(new Dictionary <string, object>() .SerializeToString()); } return(arg.Parameters .Select(x => new[] { x.Key, x.Value.SerializeObject() }) .SerializeToString()); }); SerializationConfig <JsonRemotingRequestBody> .RegisterDeserializer(arg => { var items = arg.Deserialize <string[][]>(); var results = items .Select(x => { return(new KeyValuePair <string, object>(x[0], x[1].DeserializeObject())); }) .ToDictionary(x => x.Key, x => x.Value); return(new JsonRemotingRequestBody { Parameters = results }); }); }
public void TestClassDefinitionConfig() { var serializationConfig = new SerializationConfig(); serializationConfig.AddPortableFactory(TestSerializationConstants.PORTABLE_FACTORY_ID, new TestPortableFactory()); serializationConfig.SetPortableVersion(1); serializationConfig .AddClassDefinition( new ClassDefinitionBuilder(TestSerializationConstants.PORTABLE_FACTORY_ID, TestSerializationConstants.RAW_DATA_PORTABLE) .AddLongField("l") .AddCharArrayField("c") .AddPortableField("p", CreateNamedPortableClassDefinition()) .Build()) .AddClassDefinition( new ClassDefinitionBuilder(TestSerializationConstants.PORTABLE_FACTORY_ID, TestSerializationConstants.NAMED_PORTABLE) .AddUTFField("name").AddIntField("myint").Build()); var serializationService = new SerializationServiceBuilder() .SetConfig(serializationConfig) .AddDataSerializableFactory(TestSerializationConstants.DATA_SERIALIZABLE_FACTORY_ID, GetDataSerializableFactory()) .Build(); var p = new RawDataPortable(DateTime.Now.ToFileTime(), "test chars".ToCharArray(), new NamedPortable("named portable", 34567), 9876, "Testing raw portable", new ByteArrayDataSerializable(Encoding.UTF8.GetBytes("test bytes"))); var data = serializationService.ToData(p); Assert.AreEqual(p, serializationService.ToObject <RawDataPortable>(data)); }
public void TestChangeDefaultSerialization() { var config = new SerializationConfig(); ISerializer ser = new StringSerializer(); IDeserializer deser = new StringDeserializer(); var s = config.GetSerializersForTopic("topicnotfound"); Assert.That(s, Is.EqualTo(Tuple.Create(ByteArraySerialization.DefaultSerializer, ByteArraySerialization.DefaultSerializer))); var d = config.GetDeserializersForTopic("topicnotfound"); Assert.That(d, Is.EqualTo(Tuple.Create(ByteArraySerialization.DefaultDeserializer, ByteArraySerialization.DefaultDeserializer))); config.SetDefaultSerializers(ser, ser); config.SetDefaultDeserializers(deser, deser); s = config.GetSerializersForTopic("topicnotfound"); Assert.That(s, Is.EqualTo(Tuple.Create(ser, ser))); d = config.GetDeserializersForTopic("topicnotfound"); Assert.That(d, Is.EqualTo(Tuple.Create(deser, deser))); }
internal CppSourceCreator(SerializationConfig config, CppContextSerializer serializer) { _config = config; _serializer = serializer; overallSourceLocation = Path.Combine(_config.OutputDirectory, _config.OutputSourceDirectory, "main.cpp"); overallStreamWriter = _config.OneSourceFile ? new CppStreamWriter(new StreamWriter(overallSourceLocation), " ") : null; }
public void TestAddDataSerializableFactoryClassWithNoEmptyConstructor() { var config = new SerializationConfig(); config.AddDataSerializableFactoryClass(1, typeof(SerializableFactory)); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }
public void TestAddDataSerializableFactoryClassWithBadId() { var config = new SerializationConfig(); config.AddDataSerializableFactoryClass(-1, typeof(MyDataSerializableFactory)); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }
public void TestAddPortableFactoryWithBadId() { var config = new SerializationConfig(); config.AddPortableFactory(-1, new KitchenSinkPortableFactory()); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }
public void TestAddPortableFactoryClassWhichDoesNotImplementPortableFactory() { var config = new SerializationConfig(); config.AddPortableFactoryClass(1, typeof(SerializableFactory)); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }
private void AddConfigDataSerializableFactories( IDictionary <int, IDataSerializableFactory> dataSerializableFactories, SerializationConfig config) { foreach (var entry in config.GetDataSerializableFactories()) { int factoryId = entry.Key; IDataSerializableFactory factory = entry.Value; if (factoryId <= 0) { throw new ArgumentException("IDataSerializableFactory factoryId must be positive! -> " + factory); } if (dataSerializableFactories.ContainsKey(factoryId)) { throw new ArgumentException("IDataSerializableFactory with factoryId '" + factoryId + "' is already registered!"); } dataSerializableFactories.Add(factoryId, factory); } foreach (var entry in config.GetDataSerializableFactoryClasses()) { int factoryId = entry.Key; string factoryClassName = entry.Value; if (factoryId <= 0) { throw new ArgumentException("IDataSerializableFactory factoryId must be positive! -> " + factoryClassName); } if (dataSerializableFactories.ContainsKey(factoryId)) { throw new ArgumentException("IDataSerializableFactory with factoryId '" + factoryId + "' is already registered!"); } IDataSerializableFactory factory = null; try { Type type = Type.GetType(factoryClassName); if (type != null) { factory = Activator.CreateInstance(type) as IDataSerializableFactory; } } catch (Exception e) { //ClassLoaderUtil.newInstance(cl, factoryClassName); throw new HazelcastSerializationException(e); } dataSerializableFactories.Add(factoryId, factory); } foreach (IDataSerializableFactory f in dataSerializableFactories.Values) { var aware = f as IHazelcastInstanceAware; if (aware != null) { aware.SetHazelcastInstance(_hazelcastInstance); } } }
public void TestAddPortableFactoryClassWithDuplicateId() { var config = new SerializationConfig(); config.AddPortableFactory(1, new KitchenSinkPortableFactory()); config.AddPortableFactoryClass(1, typeof(KitchenSinkPortableFactory)); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }
public void TestAddDataSerializableFactoryClassWithBadId() { Assert.Throws <ArgumentException>(() => { var config = new SerializationConfig(); config.AddDataSerializableFactoryClass(-1, typeof(MyDataSerializableFactory)); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }); }
public void TestAddDataSerializableFactoryClassWithNoEmptyConstructor() { Assert.Throws <HazelcastSerializationException>(() => { var config = new SerializationConfig(); config.AddDataSerializableFactoryClass(1, typeof(SerializableFactory)); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }); }
public void TestAddDataSerializableFactoryWithBadId() { Assert.Throws <ArgumentException>(() => { var config = new SerializationConfig(); config.DataSerializableFactories.Add(-1, new MyDataSerializableFactory()); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }); }
public void TestDeserializeFetchResponse() { var response = new CommonResponse <FetchPartitionResponse> { TopicsResponse = new [] { new TopicData <FetchPartitionResponse> { TopicName = "Buffy_contre_les_zombies", PartitionsData = new[] { new FetchPartitionResponse { ErrorCode = ErrorCode.NoError, HighWatermarkOffset = 714, Partition = 999999, Messages = new List <ResponseMessage> { new ResponseMessage { Offset = 44, Message = new Message { Key = Key, Value = Value } } } } } } } }; using (var serialized = new ReusableMemoryStream(null)) { var config = new SerializationConfig(); Basics.WriteArray(serialized, response.TopicsResponse, config); TestCommonResponse(serialized, config, response, (p1, p2) => { Assert.AreEqual(p1.Partition, p2.Partition); Assert.AreEqual(p1.ErrorCode, p2.ErrorCode); Assert.AreEqual(p1.HighWatermarkOffset, p2.HighWatermarkOffset); Assert.AreEqual(p1.Messages.Count, p2.Messages.Count); foreach (var zipped in p1.Messages.Zip(p2.Messages, Tuple.Create)) { Assert.AreEqual(zipped.Item1.Offset, zipped.Item2.Offset); CollectionAssert.AreEqual(zipped.Item1.Message.Key as byte[], zipped.Item2.Message.Key as byte[]); CollectionAssert.AreEqual(zipped.Item1.Message.Value as byte[], zipped.Item2.Message.Value as byte[]); } return(true); }); } }
public void TestSerializationConfig() { var config = new SerializationConfig(); ISerializer ser = new StringSerializer(); IDeserializer deser = new StringDeserializer(); var t1 = Tuple.Create(ser, ser); var t2 = Tuple.Create(ser, ser); Assert.That(t1, Is.EqualTo(t2)); var s = config.GetSerializersForTopic("topicnotfound"); Assert.That(s, Is.EqualTo(Tuple.Create(ByteArraySerialization.DefaultSerializer, ByteArraySerialization.DefaultSerializer))); var d = config.GetDeserializersForTopic("topicnotfound"); Assert.That(d, Is.EqualTo(Tuple.Create(ByteArraySerialization.DefaultDeserializer, ByteArraySerialization.DefaultDeserializer))); config.SetSerializersForTopic("topicnotfound", ser, ser); config.SetDeserializersForTopic("topicnotfound", deser, deser); s = config.GetSerializersForTopic("topicnotfound"); Assert.That(s, Is.EqualTo(Tuple.Create(ser, ser))); d = config.GetDeserializersForTopic("topicnotfound"); Assert.That(d, Is.EqualTo(Tuple.Create(deser, deser))); var config2 = new SerializationConfig(config); s = config2.GetSerializersForTopic("topicnotfound"); Assert.That(s, Is.EqualTo(Tuple.Create(ser, ser))); d = config2.GetDeserializersForTopic("topicnotfound"); Assert.That(d, Is.EqualTo(Tuple.Create(deser, deser))); config2.SetSerializersForTopic("topicnotfound", null, ser); config2.SetDeserializersForTopic("topicnotfound", null, deser); s = config2.GetSerializersForTopic("topicnotfound"); Assert.That(s, Is.EqualTo(Tuple.Create(ByteArraySerialization.DefaultSerializer, ser))); d = config2.GetDeserializersForTopic("topicnotfound"); Assert.That(d, Is.EqualTo(Tuple.Create(ByteArraySerialization.DefaultDeserializer, deser))); config2.SetSerializersForTopic("topicnotfound", ser, null); config2.SetDeserializersForTopic("topicnotfound", deser, null); s = config2.GetSerializersForTopic("topicnotfound"); Assert.That(s, Is.EqualTo(Tuple.Create(ser, ByteArraySerialization.DefaultSerializer))); d = config2.GetDeserializersForTopic("topicnotfound"); Assert.That(d, Is.EqualTo(Tuple.Create(deser, ByteArraySerialization.DefaultDeserializer))); }
public void TestAddPortableFactoryClassWithNoEmptyConstructor() { Assert.Throws <MissingMethodException>(() => { var config = new SerializationConfig(); config.AddPortableFactoryClass(1, typeof(PortableFactory)); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }); }
public void TestAddPortableFactoryClassWhichDoesNotImplementPortableFactory() { Assert.Throws <HazelcastSerializationException>(() => { var config = new SerializationConfig(); config.AddPortableFactoryClass(1, typeof(SerializableFactory)); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }); }
public void TestAddPortableFactoryWithBadId() { Assert.Throws <ArgumentException>(() => { var config = new SerializationConfig(); config.AddPortableFactory(-1, new KitchenSinkPortableFactory()); var service = new SerializationServiceBuilder().SetConfig(config).Build(); }); }
private void AddConfigPortableFactories(IDictionary <int, IPortableFactory> portableFactories, SerializationConfig config) { foreach (var entry in config.GetPortableFactories()) { var factoryId = entry.Key; var factory = entry.Value; if (factoryId <= 0) { throw new ArgumentException("IPortableFactory factoryId must be positive! -> " + factory); } if (portableFactories.ContainsKey(factoryId)) { throw new ArgumentException("IPortableFactory with factoryId '" + factoryId + "' is already registered!"); } portableFactories.Add(factoryId, factory); } foreach (var entry in config.GetPortableFactoryClasses()) { var factoryId = entry.Key; var factoryClassName = entry.Value; if (factoryId <= 0) { throw new ArgumentException("IPortableFactory factoryId must be positive! -> " + factoryClassName); } if (portableFactories.ContainsKey(factoryId)) { throw new ArgumentException("IPortableFactory with factoryId '" + factoryId + "' is already registered!"); } var type = Type.GetType(factoryClassName); if (type == null) { throw new HazelcastSerializationException("Unable to find type " + factoryClassName); } if (!typeof(IPortableFactory).IsAssignableFrom(type)) { throw new HazelcastSerializationException("Type " + type + " does not implement IPortableFactory"); } var factory = Activator.CreateInstance(type) as IPortableFactory; portableFactories.Add(factoryId, factory); } foreach (var f in portableFactories.Values) { if (f is IHazelcastInstanceAware) { ((IHazelcastInstanceAware)f).SetHazelcastInstance(_hazelcastInstance); } } }
public ISerializationServiceBuilder SetConfig(SerializationConfig config) { _config = config; if (_portableVersion < 0) { _portableVersion = config.GetPortableVersion(); } _checkClassDefErrors = config.IsCheckClassDefErrors(); _useNativeByteOrder = config.IsUseNativeByteOrder(); _byteOrder = config.GetByteOrder(); return(this); }
public ISerializationServiceBuilder SetConfig(SerializationConfig config) { _config = config; if (_portableVersion < 0) { _portableVersion = config.PortableVersion; } _checkClassDefErrors = config.CheckClassDefErrors; _useNativeByteOrder = config.UseNativeByteOrder; _byteOrder = config.ByteOrder; return(this); }
public XmlWriterDynamicOutputDecorator(XmlWriter writer, SerializationConfig config, List <string> configurableNodeNames) { this.writer = writer; this.Config = config; if (configurableNodeNames == null) { this.configurableNodeNames = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase); } else { this.configurableNodeNames = new HashSet <string>(configurableNodeNames, StringComparer.InvariantCultureIgnoreCase); } emptyNodeController = new Stack <bool>(); }
public void TestAddDataSerializableFactoryClass() { var service1 = new SerializationServiceBuilder().Build(); var data = service1.ToData(new DataSerializableBasicType()); var config = new SerializationConfig(); config.AddDataSerializableFactoryClass(1, typeof(MyDataSerializableFactory)); var service = new SerializationServiceBuilder().SetConfig(config).Build(); var obj = service.ToObject <object>(data); Assert.IsInstanceOf <DataSerializableBasicType>(obj); }
public void TestAddPortableFactoryClass() { var service1 = new SerializationServiceBuilder().Build(); var data = service1.ToData(new KitchenSinkPortable()); var config = new SerializationConfig(); config.AddPortableFactoryClass(1, typeof(KitchenSinkPortableFactory)); var service = new SerializationServiceBuilder().SetConfig(config).Build(); var obj = service.ToObject <object>(data); Assert.IsInstanceOf <KitchenSinkPortable>(obj); }
public void TestSerializeProduceRequest() { var produce = new ProduceRequest { Timeout = 1223, RequiredAcks = 1, TopicsData = new[] { new TopicData <PartitionData> { TopicName = "barbu", PartitionsData = new[] { new PartitionData { Partition = 22, CompressionCodec = CompressionCodec.None, Messages = new[] { new Message { Value = TheValue } }, } } }, } }; var config = new SerializationConfig(); config.SetSerializersForTopic("barbu", new StringSerializer(), new StringSerializer()); config.SetDeserializersForTopic("barbu", new StringDeserializer(), new StringDeserializer()); using (var serialized = produce.Serialize(new ReusableMemoryStream(null), 321, ClientId, config)) { CheckHeader(Basics.ApiKey.ProduceRequest, 0, 321, TheClientId, serialized); Assert.AreEqual(produce.RequiredAcks, BigEndianConverter.ReadInt16(serialized)); Assert.AreEqual(produce.Timeout, BigEndianConverter.ReadInt32(serialized)); Assert.AreEqual(1, BigEndianConverter.ReadInt32(serialized)); // 1 topic data Assert.AreEqual("barbu", Basics.DeserializeString(serialized)); Assert.AreEqual(1, BigEndianConverter.ReadInt32(serialized)); // 1 partition data Assert.AreEqual(22, BigEndianConverter.ReadInt32(serialized)); var msgs = FetchPartitionResponse.DeserializeMessageSet(serialized, config.GetDeserializersForTopic("barbu")); Assert.AreEqual(1, msgs.Count); //Assert.AreEqual(TheValue, Encoding.UTF8.GetString(msgs[0].Message.Value)); Assert.AreEqual(TheValue, msgs[0].Message.Value as string); } }
public void TestGlobalSerializer() { var config = new SerializationConfig(); config.ConfigureGlobalSerializer(gs => { gs.TypeName = typeof(GlobalSerializer).AssemblyQualifiedName; }); var ss = new SerializationServiceBuilder().SetConfig(config).Build(); var foo = new CustomSerializableType { Value = "fooooo" }; var d = ss.ToData(foo); var newFoo = ss.ToObject <CustomSerializableType>(d); Assert.AreEqual(newFoo.Value, foo.Value); }
public virtual void TestCustomSerialize() { var config = new SerializationConfig(); var sc = new SerializerConfig() .SetImplementation(new CustomSerializer()) .SetTypeClass(typeof(CustomSerializableType)); config.SerializerConfigs.Add(sc); var ss = new SerializationServiceBuilder().SetConfig(config).Build(); var foo = new CustomSerializableType { Value = "fooooo" }; var d = ss.ToData(foo); var newFoo = ss.ToObject <CustomSerializableType>(d); Assert.AreEqual(newFoo.Value, foo.Value); }