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);
}
