public void Test_1096_ByteArrayContentSame()
{
var ss = new SerializationServiceBuilder()
.AddPortableFactory(TestSerializationConstants.PORTABLE_FACTORY_ID, new TestPortableFactory()).Build();
AssertRepeatedSerialisationGivesSameByteArrays(ss, new NamedPortable("issue-1096", 1096));
AssertRepeatedSerialisationGivesSameByteArrays(ss, new InnerPortable(new byte[3], new char[5], new short[2],
new int[10], new long[7], new float[9], new double[1], new[] { new NamedPortable("issue-1096", 1096) }));
AssertRepeatedSerialisationGivesSameByteArrays(ss,
new RawDataPortable(1096L, "issue-1096".ToCharArray(), new NamedPortable("issue-1096", 1096), 1096,
"issue-1096", new ByteArrayDataSerializable(new byte[1])));
}
public void Test_Issue2172_WritePortableArray()
{
var ss = new SerializationServiceBuilder().SetInitialOutputBufferSize(16).Build();
var testObject2s = new TestObject2[100];
for (var i = 0; i < testObject2s.Length; i++)
{
testObject2s[i] = new TestObject2();
}
var testObject1 = new TestObject1(testObject2s);
ss.ToData(testObject1);
}
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 TestAddDataSerializableFactory()
{
var service1 = new SerializationServiceBuilder(new NullLoggerFactory()).Build();
var data = service1.ToData(new DataSerializableBasicType());
var config = new SerializationOptions();
config.AddDataSerializableFactory(1, new MyDataSerializableFactory());
var service = new SerializationServiceBuilder(new NullLoggerFactory()).SetConfig(config).Build();
var obj = service.ToObject <object>(data);
Assert.IsInstanceOf <DataSerializableBasicType>(obj);
}
public void TestNullValue_When_ValueType()
{
Assert.Throws <HazelcastSerializationException>(() =>
{
var ss = new SerializationServiceBuilder()
.Build();
var output = ss.CreateObjectDataOutput(1024);
ss.WriteObject(output, null);
var input = ss.CreateObjectDataInput(output.ToByteArray());
ss.ReadObject <int>(input);
});
}
public virtual void Test()
{
var portableFactory = new PortableFactoryFunc(i =>
{
if (i == 1)
{
return(new PortablePerson());
}
if (i == 2)
{
return(new PortableAddress());
}
throw new ArgumentException();
});
var ss = new SerializationServiceBuilder()
.AddPortableFactory(FactoryId, portableFactory).Build();
var k = 10;
var tasks = new Task[k];
for (var i = 0; i < k; i++)
{
tasks[i] = Task.Factory.StartNew(() =>
{
for (var j = 0; j < 10000; j++)
{
var key = "key" + Rnd();
var dataKey = ss.ToData(key);
Assert.AreEqual(key, ss.ToObject <string>(dataKey));
var value = 123L + Rnd();
var dataValue = ss.ToData(value);
Assert.AreEqual(value, ss.ToObject <long>(dataValue));
var address = new Address("here here" + Rnd(), 13131 + Rnd());
var dataAddress = ss.ToData(address);
Assert.AreEqual(address, ss.ToObject <Address>(dataAddress));
var person = new Person(13 + Rnd(), 199L + Rnd(), 56.89d, "mehmet", address);
var dataPerson = ss.ToData(person);
Assert.AreEqual(person, ss.ToObject <Person>(dataPerson));
var portableAddress = new PortableAddress("there there " + Rnd(), 90909 + Rnd());
var dataPortableAddress = ss.ToData(portableAddress);
Assert.AreEqual(portableAddress, ss.ToObject <PortableAddress>(dataPortableAddress));
var portablePerson = new PortablePerson(63 + Rnd(), 167L + Rnd(), "ahmet", portableAddress);
var dataPortablePerson = ss.ToData(portablePerson);
Assert.AreEqual(portablePerson, ss.ToObject <PortablePerson>(dataPortablePerson));
}
});
}
Task.WaitAll(tasks, new TimeSpan(0, 0, 0, 30));
}
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 TestNullValue_When_NullableType()
{
var ss = new SerializationServiceBuilder()
.Build();
var output = ss.CreateObjectDataOutput(1024);
ss.WriteObject(output, 1);
ss.WriteObject(output, null);
var input = ss.CreateObjectDataInput(output.ToByteArray());
Assert.AreEqual(1, ss.ReadObject <int?>(input));
Assert.IsNull(ss.ReadObject <int?>(input));
}
public void PagingPredicateHolderTest()
{
var serializationService = new SerializationServiceBuilder(new NullLoggerFactory())
.AddHook <PredicateDataSerializerHook>()
.Build();
var anchorDataListHolder = GetAnchorDataListHolder(serializationService, out var pageList, out var dataList);
var predicateData = new HeapData();
var comparatorData = new HeapData();
var partitionKeyData = new HeapData();
var holder = new PagingPredicateHolder(anchorDataListHolder, predicateData, comparatorData, 5, 12, 3, partitionKeyData);
Assert.That(holder.AnchorDataListHolder, Is.SameAs(anchorDataListHolder));
Assert.That(holder.PredicateData, Is.SameAs(predicateData));
Assert.That(holder.ComparatorData, Is.SameAs(comparatorData));
Assert.That(holder.PageSize, Is.EqualTo(5));
Assert.That(holder.Page, Is.EqualTo(12));
Assert.That(holder.IterationTypeId, Is.EqualTo(3));
Assert.That(holder.PartitionKeyData, Is.SameAs(partitionKeyData));
var predicate = new PagingPredicate(5)
{
IterationType = IterationType.Key
};
predicate.UpdateAnchors(new List <KeyValuePair <int, KeyValuePair <object, object> > >
{
new KeyValuePair <int, KeyValuePair <object, object> >(1, new KeyValuePair <object, object>("key", "value"))
});
holder = PagingPredicateHolder.Of(predicate, serializationService);
Assert.That(holder.PageSize, Is.EqualTo(5));
holder = PagingPredicateHolder.Of(new PartitionPredicate("key", new PagingPredicate(5)
{
IterationType = IterationType.Key
}), serializationService);
Assert.That(holder.PageSize, Is.EqualTo(5));
Assert.That(PagingPredicateHolder.Of(null, serializationService), Is.Null);
Assert.Throws <InvalidOperationException>(() => _ = PagingPredicateHolder.Of(new PagingPredicate(5), serializationService));
Assert.Throws <InvalidOperationException>(() => _ = PagingPredicateHolder.Of(new AndPredicate(), serializationService));
Assert.Throws <InvalidOperationException>(() => _ = PagingPredicateHolder.Of(new PartitionPredicate(), serializationService));
}
public void TestSerializationService_CreatePortableReader()
{
var serializationService = new SerializationServiceBuilder(new NullLoggerFactory()).Build();
var timestamp1 = TestUtils.RandomLong();
var child = new ChildPortableObject(timestamp1);
var timestamp2 = TestUtils.RandomLong();
var parent = new ParentPortableObject(timestamp2, child);
var timestamp3 = timestamp1 + timestamp2;
var grandParent = new GrandParentPortableObject(timestamp3, parent);
var data = serializationService.ToData(grandParent);
var reader = serializationService.CreatePortableReader(data);
Assert.AreEqual(grandParent.timestamp, reader.ReadLong("timestamp"));
Assert.AreEqual(parent.timestamp, reader.ReadLong("child.timestamp"));
Assert.AreEqual(child.timestamp, reader.ReadLong("child.child.timestamp"));
}
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 TestReadWrite(ByteOrder byteOrder)
{
var obj = KitchenSinkDataSerializable.Generate();
obj.Serializable = KitchenSinkDataSerializable.Generate();
var ss = new SerializationServiceBuilder().SetUseNativeByteOrder(false).SetByteOrder(byteOrder).Build();
IObjectDataOutput output = ss.CreateObjectDataOutput(1024);
output.WriteObject(obj);
IObjectDataInput input = ss.CreateObjectDataInput(output.ToByteArray());
var readObj = input.ReadObject <object>();
Assert.AreEqual(obj, readObj);
ss.Destroy();
}
public void AnchorDataListHolderTest()
{
var serializationService = new SerializationServiceBuilder(new NullLoggerFactory()).Build();
var holder = GetAnchorDataListHolder(serializationService, out var pageList, out var dataList);
Assert.That(holder.AnchorPageList, Is.SameAs(pageList));
Assert.That(holder.AnchorDataList, Is.SameAs(dataList));
var anchors = holder.AsAnchorIterator(serializationService).ToArray();
Assert.That(anchors.Length, Is.EqualTo(4));
for (var i = 0; i < 4; i++)
{
Assert.That(anchors[i].Key, Is.EqualTo(i));
Assert.That(anchors[i].Value.Key, Is.EqualTo(i + 1));
Assert.That(anchors[i].Value.Value, Is.EqualTo(i + 2));
}
}
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);
}
public virtual void TestInputOutputWithPortableReader(Endianness endianness)
{
var portable = KitchenSinkPortable.Generate();
var config = new SerializationOptions();
config.AddPortableFactory(KitchenSinkPortableFactory.FactoryId, typeof(KitchenSinkPortableFactory));
using var ss = new SerializationServiceBuilder(new NullLoggerFactory()).SetConfig(config)
.SetEndianness(endianness).Build();
var data = ss.ToData(portable);
var reader = ss.CreatePortableReader(data);
var actual = new KitchenSinkPortable();
actual.ReadPortable(reader);
Assert.AreEqual(portable, actual);
}
public void TestGlobalSerializer()
{
var config = new SerializationOptions();
config.DefaultSerializer = new SerializerOptions
{
Creator = () => (ISerializer)ServiceFactory.CreateInstance(typeof(GlobalSerializer).AssemblyQualifiedName)
};
var ss = new SerializationServiceBuilder(new NullLoggerFactory()).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);
}
private HazelcastClient(Configuration config)
{
Configuration = config;
HazelcastProperties = new HazelcastProperties(config.Properties);
if (config.InstanceName != null)
{
_instanceName = config.InstanceName;
}
else
{
_instanceName = "hz.client_" + _id;
}
LifecycleService = new LifecycleService(this);
try
{
//TODO make partition strategy parametric
var partitioningStrategy = new DefaultPartitioningStrategy();
SerializationService = new SerializationServiceBuilder().SetConfig(config.SerializationConfig)
.SetPartitioningStrategy(partitioningStrategy)
.SetVersion(IO.Serialization.SerializationService.SerializerVersion).Build();
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
ProxyManager = new ProxyManager(this);
//TODO EXECUTION SERVICE
ExecutionService = new ExecutionService(_instanceName);
LoadBalancer = config.LoadBalancer ?? new RoundRobinLB();
PartitionService = new PartitionService(this);
AddressProvider = new AddressProvider(Configuration.NetworkConfig, HazelcastProperties);
ConnectionManager = new ConnectionManager(this);
InvocationService = new InvocationService(this);
ListenerService = new ListenerService(this);
ClusterService = new ClusterService(this);
LockReferenceIdGenerator = new ClientLockReferenceIdGenerator();
// Statistics = new Statistics(this);
NearCacheManager = new NearCacheManager(this);
CredentialsFactory = config.SecurityConfig.AsCredentialsFactory() ??
new StaticCredentialsFactory(new UsernamePasswordCredentials());
}
public virtual void TestDataInputOutputWithPortable(Endianness endianness)
{
var portable = KitchenSinkPortable.Generate();
var config = new SerializationOptions();
config.AddPortableFactory(KitchenSinkPortableFactory.FactoryId, typeof(KitchenSinkPortableFactory));
using var ss = new SerializationServiceBuilder(new NullLoggerFactory()).SetConfig(config)
.SetEndianness(endianness).Build();
IObjectDataOutput output = ss.CreateObjectDataOutput(1024);
output.WriteObject(portable);
var data = output.ToByteArray();
IObjectDataInput input = ss.CreateObjectDataInput(data);
var readObject = input.ReadObject <IPortable>();
Assert.AreEqual(portable, readObject);
}
public virtual void TestCustomSerialize()
{
var config = new SerializationOptions();
var sc = new SerializerOptions
{
SerializedType = typeof(CustomSerializableType),
Creator = () => new CustomSerializer()
};
config.Serializers.Add(sc);
var ss = new SerializationServiceBuilder(new NullLoggerFactory()).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 TestInputOutputWithPortableReader(ByteOrder byteOrder)
{
var portable = KitchenSinkPortable.Generate();
var config = new SerializationConfig();
config.AddPortableFactoryClass(KitchenSinkPortableFactory.FactoryId, typeof(KitchenSinkPortableFactory));
var ss = new SerializationServiceBuilder().SetConfig(config).
SetUseNativeByteOrder(false).SetByteOrder(byteOrder).Build();
var data = ss.ToData(portable);
var reader = ss.CreatePortableReader(data);
var actual = new KitchenSinkPortable();
actual.ReadPortable(reader);
Assert.AreEqual(portable, actual);
ss.Destroy();
}
public virtual void TestReadWrite(Endianness endianness)
{
var obj = KitchenSinkDataSerializable.Generate();
obj.Serializable = KitchenSinkDataSerializable.Generate();
using var ss = new SerializationServiceBuilder(new NullLoggerFactory())
.AddDataSerializableFactory(1, new ArrayDataSerializableFactory(new Func <IIdentifiedDataSerializable>[]
{
() => new KitchenSinkDataSerializable(),
}))
.SetEndianness(endianness).Build();
IObjectDataOutput output = ss.CreateObjectDataOutput(1024);
output.WriteObject(obj);
IObjectDataInput input = ss.CreateObjectDataInput(output.ToByteArray());
var readObj = input.ReadObject <object>();
Assert.AreEqual(obj, readObj);
}
private HazelcastClient(ClientConfig config)
{
ClientConfig = config;
if (config.InstanceName != null)
{
_instanceName = config.InstanceName;
}
else
{
_instanceName = "hz.client_" + _id;
}
LifecycleService = new LifecycleService(this);
try
{
//TODO make partition strategy parametric
var partitioningStrategy = new DefaultPartitioningStrategy();
SerializationService = new SerializationServiceBuilder().SetConfig(config.GetSerializationConfig())
.SetPartitioningStrategy(partitioningStrategy)
.SetVersion(IO.Serialization.SerializationService.SerializerVersion).Build();
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
ProxyManager = new ProxyManager(this);
//TODO EXECUTION SERVICE
ExecutionService = new ExecutionService(_instanceName, config.GetExecutorPoolSize());
LoadBalancer = config.GetLoadBalancer() ?? new RoundRobinLB();
PartitionService = new PartitionService(this);
AddressProvider = new AddressProvider(ClientConfig);
ConnectionManager = new ConnectionManager(this);
InvocationService = new InvocationService(this);
ListenerService = new ListenerService(this);
ClusterService = new ClusterService(this);
LockReferenceIdGenerator = new ClientLockReferenceIdGenerator();
// Statistics = new Statistics(this);
NearCacheManager = new NearCacheManager(this);
CredentialsFactory = InitCredentialsFactory(config);
}
public void TestWriteObjectWithCustomSerializable()
{
var config = new SerializationConfig();
var sc = new SerializerConfig()
.SetImplementation(new CustomSerializer())
.SetTypeClass(typeof(CustomSerializableType));
config.AddSerializerConfig(sc);
var serializationService =
new SerializationServiceBuilder().SetPortableVersion(1)
.AddPortableFactory(TestSerializationConstants.PORTABLE_FACTORY_ID, new TestPortableFactory())
.SetConfig(config).Build();
var foo = new CustomSerializableType {
Value = "foo"
};
var objectCarryingPortable1 = new ObjectCarryingPortable(foo);
var data = serializationService.ToData(objectCarryingPortable1);
var objectCarryingPortable2 = serializationService.ToObject <ObjectCarryingPortable>(data);
Assert.AreEqual(objectCarryingPortable1, objectCarryingPortable2);
}
public virtual void TestDataInputOutputWithPortable(ByteOrder byteOrder)
{
var portable = KitchenSinkPortable.Generate();
var config = new SerializationConfig();
config.AddPortableFactoryClass(KitchenSinkPortableFactory.FactoryId, typeof(KitchenSinkPortableFactory));
var ss = new SerializationServiceBuilder().SetConfig(config).
SetUseNativeByteOrder(false).SetByteOrder(byteOrder).Build();
IObjectDataOutput output = ss.CreateObjectDataOutput(1024);
output.WriteObject(portable);
var data = output.ToByteArray();
IObjectDataInput input = ss.CreateObjectDataInput(data);
var readObject = input.ReadObject <IPortable>();
Assert.AreEqual(portable, readObject);
ss.Destroy();
}
public void TestGlobalSerializerOverride()
{
var config = new SerializationOptions();
var globalListSerializer = new GlobalListSerializer();
config.GlobalSerializer = new GlobalSerializerOptions
{
Creator = () => globalListSerializer,
OverrideClrSerialization = true
};
var ss = new SerializationServiceBuilder(new NullLoggerFactory()).SetConfig(config).Build();
var list = new List <string> {
"foo", "bar"
};
var d = ss.ToData(list);
var input = ss.CreateObjectDataInput(d);
var actual = (List <string>)globalListSerializer.Read(input);
Assert.AreEqual(list, actual);
}
public virtual void TestNestedPortableVersionedSerializer()
{
SerializationServiceBuilder builder1 = new SerializationServiceBuilder();
builder1.SetPortableVersion(6);
builder1.AddPortableFactory(1, new MyPortableFactory());
ISerializationService ss1 = builder1.Build();
SerializationServiceBuilder builder2 = new SerializationServiceBuilder();
builder2.SetPortableVersion(6);
builder2.AddPortableFactory(1, new MyPortableFactory());
ISerializationService ss2 = builder2.Build();
//make sure ss2 cached class definition of Child
ss2.ToData(new Child("ubeyd"));
//serialized parent from ss1
Parent parent = new Parent(new Child("ubeyd"));
IData data = ss1.ToData(parent);
// cached class definition of Child and the class definition from data coming from ss1 should be compatible
Assert.AreEqual(parent, ss2.ToObject <Parent>(data));
}
public void TestGlobalSerializerOverride()
{
var config = new SerializationConfig();
var globalListSerializer = new GlobalListSerializer();
config.ConfigureGlobalSerializer(gs =>
{
gs.Implementation = globalListSerializer;
gs.OverrideClrSerialization = true;
});
var ss = new SerializationServiceBuilder().SetConfig(config).Build();
var list = new List <string> {
"foo", "bar"
};
var d = ss.ToData(list);
var input = new ByteArrayObjectDataInput(d.ToByteArray(), HeapData.DataOffset, ss, ByteOrder.BigEndian);
var actual = (List <string>)globalListSerializer.Read(input);
Assert.AreEqual(list, actual);
}
