public void SingleAttributeProjectionTest()
{
Assert.Throws <ArgumentException>(() => _ = Hazelcast.Projection.Projections.SingleAttribute(""));
var x = Hazelcast.Projection.Projections.SingleAttribute("attribute");
Assert.That(x, Is.InstanceOf <SingleAttributeProjection>());
var p = (SingleAttributeProjection)x;
Assert.That(p.FactoryId, Is.EqualTo(FactoryIds.ProjectionDsFactoryId));
Assert.That(p.ClassId, Is.EqualTo(ProjectionDataSerializerHook.SingleAttribute));
Assert.Throws <ArgumentNullException>(() => p.WriteData(null));
Assert.Throws <ArgumentNullException>(() => p.ReadData(null));
using var output = new ObjectDataOutput(256, null, Endianness.BigEndian);
p.WriteData(output);
using var input = new ObjectDataInput(output.Buffer, null, Endianness.BigEndian);
p = new SingleAttributeProjection();
p.ReadData(input);
Assert.That(p.AttributePath, Is.EqualTo("attribute"));
}
public void EndpointQualifierTest()
{
var q = new EndpointQualifier(ProtocolType.Client, "identifier");
Assert.That(q.Type, Is.EqualTo(ProtocolType.Client));
Assert.That(q.Identifier, Is.EqualTo("identifier"));
Assert.That(q.FactoryId, Is.EqualTo(0));
Assert.That(q.ClassId, Is.EqualTo(17));
Assert.That(q, Ish.Equatable(
new EndpointQualifier(ProtocolType.Client, "identifier"),
new EndpointQualifier(ProtocolType.MemCache, "identifier"),
new EndpointQualifier(ProtocolType.Client, "other")));
Assert.That(q.GetHashCode(), Is.Not.Zero);
Assert.Throws <ArgumentNullException>(() => q.WriteData(null));
Assert.Throws <ArgumentNullException>(() => q.ReadData(null));
var output = new ObjectDataOutput(1024, null, Endianness.BigEndian);
q.WriteData(output);
var input = new ObjectDataInput(output.ToByteArray(), null, Endianness.BigEndian);
var r = new EndpointQualifier(ProtocolType.Wan, "meh");
r.ReadData(input);
Assert.That(q, Is.EqualTo(r));
}
private T AssertPredicate <T>(T predicate, int classId)
where T : IIdentifiedDataSerializable
{
Assert.That(predicate.FactoryId, Is.EqualTo(FactoryIds.PredicateFactoryId));
Assert.That(predicate.ClassId, Is.EqualTo(classId));
// Assert.Throws<ArgumentNullException>(() => predicate.WriteData(null));
// Assert.Throws<ArgumentNullException>(() => predicate.ReadData(null));
using var output = new ObjectDataOutput(1024, _serializationService, Endianness.BigEndian);
predicate.WriteData(output);
T p = default;
if (typeof(T) != typeof(PagingPredicate) && typeof(T) != typeof(PartitionPredicate))
{
using var input = new ObjectDataInput(output.Buffer, _serializationService, Endianness.BigEndian);
p = (T)Activator.CreateInstance(typeof(T));
p.ReadData(input);
Assert.That(predicate.Equals(p));
Assert.That(predicate.Equals(predicate));
Assert.That(predicate.Equals(null), Is.False);
Assert.That(Equals(predicate, p));
Assert.That(Equals(predicate, predicate));
Assert.That(Equals(predicate, null), Is.False);
var type = typeof(T);
MethodInfo staticEquals;
do
{
staticEquals = type.GetMethod("Equals", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
type = type.BaseType;
} while (staticEquals == null && type != typeof(object));
Assert.That(staticEquals, Is.Not.Null);
Assert.That((bool)staticEquals.Invoke(null, new object[] { predicate, p }));
Assert.That((bool)staticEquals.Invoke(null, new object[] { predicate, predicate }));
Assert.That((bool)staticEquals.Invoke(null, new object[] { predicate, null }), Is.False);
var data = _serializationService.ToData(predicate);
p = _serializationService.ToObject <T>(data);
Assert.That(predicate.Equals(p));
}
_ = predicate.GetHashCode();
Console.WriteLine($"{typeof(T)}: {predicate}");
return(p);
}
private void AssertAggregator <TResult>(AggregatorBase <TResult> aggregator, int classId)
{
var aggregatorType = aggregator.GetType();
Assert.That(aggregator.FactoryId, Is.EqualTo(FactoryIds.AggregatorDsFactoryId));
Assert.That(aggregator.ClassId, Is.EqualTo(classId));
Assert.Throws <ArgumentException>(() => _ = Aggregators.Count(""));
Assert.Throws <ArgumentException>(() => _ = Aggregators.Count(null));
Assert.Throws <ArgumentNullException>(() => aggregator.WriteData(null));
Assert.Throws <ArgumentNullException>(() => aggregator.ReadData(null));
using var output = new ObjectDataOutput(1024, _serializationService, Endianness.BigEndian);
aggregator.WriteData(output);
using var input = new ObjectDataInput(output.Buffer, _serializationService, Endianness.BigEndian);
var a = (AggregatorBase <TResult>)Activator.CreateInstance(aggregatorType);
a.ReadData(input);
Assert.That(a.AttributePath, Is.EqualTo(aggregator.AttributePath));
var data = _serializationService.ToData(aggregator);
if (aggregatorType.IsGenericType)
{
// doh - cannot deserialize generic types?
IAggregator <object> x = null;
if (aggregatorType.GetGenericTypeDefinition() == typeof(MaxAggregator <>))
{
x = _serializationService.ToObject <MaxAggregator <object> >(data);
}
else if (aggregatorType.GetGenericTypeDefinition() == typeof(MinAggregator <>))
{
x = _serializationService.ToObject <MinAggregator <object> >(data);
}
else
{
Assert.Fail("Unsupported generic aggregator type.");
}
Assert.That(x.AttributePath, Is.EqualTo(aggregator.AttributePath));
}
else
{
var x = _serializationService.ToObject <IAggregator <TResult> >(data);
Assert.That(x.AttributePath, Is.EqualTo(aggregator.AttributePath));
}
}
public void PartitionPredicate()
{
AssertPredicate(new PartitionPredicate(), PredicateDataSerializerHook.PartitionPredicate);
AssertPredicate(new PartitionPredicate("key", Predicates.True()), PredicateDataSerializerHook.PartitionPredicate);
var partition = new PartitionPredicate("key", Predicates.True());
Assert.That(partition.FactoryId, Is.EqualTo(FactoryIds.PredicateFactoryId));
Assert.That(partition.ClassId, Is.EqualTo(PredicateDataSerializerHook.PartitionPredicate));
using var output = new ObjectDataOutput(1024, _serializationService, Endianness.BigEndian);
partition.WriteData(output);
using var input = new ObjectDataInput(output.Buffer, _serializationService, Endianness.BigEndian);
var p = new PartitionPredicate();
p.ReadData(input);
Assert.That(p.PartitionKey, Is.EqualTo(partition.PartitionKey));
Assert.That(p.Target, Is.EqualTo(partition.Target));
}
public MorphingPortableReader(PortableSerializer serializer, ObjectDataInput input, IClassDefinition cd)
: base(serializer, input, cd)
{
}
public void ComparerTest()
{
var comparer = new PredicateComparer(1, IterationType.Value);
Assert.Throws <ArgumentNullException>(() => comparer.WriteData(null));
Assert.Throws <ArgumentNullException>(() => comparer.ReadData(null));
using var output = new ObjectDataOutput(1024, _serializationService, Endianness.BigEndian);
comparer.WriteData(output);
var c = new PredicateComparer();
using var input = new ObjectDataInput(output.Buffer, _serializationService, Endianness.BigEndian);
c.ReadData(input);
Assert.That(c.Type, Is.EqualTo(comparer.Type));
Assert.That(c.IterationType, Is.EqualTo(comparer.IterationType));
// entry
Assert.That(new PredicateComparer(0, IterationType.Key).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo("key1".CompareTo("key2")));
Assert.That(new PredicateComparer(1, IterationType.Key).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo("key2".CompareTo("key1")));
Assert.That(new PredicateComparer(2, IterationType.Key).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo(0));
Assert.That(new PredicateComparer(2, IterationType.Key).Compare(("key1", "value1"), ("key2x", "value2")),
Is.EqualTo("key1".Length.CompareTo("key2x".Length)));
Assert.That(new PredicateComparer(3, IterationType.Key).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo(0));
Assert.That(new PredicateComparer(3, IterationType.Key).Compare(("key1", "value1"), ("key2x", "value2")),
Is.EqualTo(0));
// uh?
Assert.That(new PredicateComparer(0, (IterationType)666).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo("key1".CompareTo("key2")));
Assert.That(new PredicateComparer(1, (IterationType)666).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo("key2".CompareTo("key1")));
Assert.That(new PredicateComparer(2, (IterationType)666).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo(0));
Assert.That(new PredicateComparer(2, (IterationType)666).Compare(("key1", "value1"), ("key2x", "value2")),
Is.EqualTo("key1".Length.CompareTo("key2x".Length)));
Assert.That(new PredicateComparer(3, (IterationType)666).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo(0));
Assert.That(new PredicateComparer(3, (IterationType)666).Compare(("key1", "value1"), ("key2x", "value2")),
Is.EqualTo(0));
// value
Assert.That(new PredicateComparer(0, IterationType.Value).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo("value1".CompareTo("value2")));
Assert.That(new PredicateComparer(1, IterationType.Value).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo("value2".CompareTo("value1")));
Assert.That(new PredicateComparer(2, IterationType.Value).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo(0));
Assert.That(new PredicateComparer(2, IterationType.Value).Compare(("key1", "value1"), ("key2", "value2x")),
Is.EqualTo("value1".Length.CompareTo("value2x".Length)));
Assert.That(new PredicateComparer(3, IterationType.Value).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo(0));
Assert.That(new PredicateComparer(3, IterationType.Value).Compare(("key1", "value1"), ("key2", "value2x")),
Is.EqualTo(0));
// entry
Assert.That(new PredicateComparer(0, IterationType.Entry).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo("key1:::value1".CompareTo("key2:::value2")));
Assert.That(new PredicateComparer(1, IterationType.Entry).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo("key2:::value2".CompareTo("key1:::value1")));
Assert.That(new PredicateComparer(2, IterationType.Entry).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo(0));
Assert.That(new PredicateComparer(2, IterationType.Entry).Compare(("key1", "value1"), ("key2", "value2x")),
Is.EqualTo("key1:::value1".Length.CompareTo("key2:::value2x".Length)));
Assert.That(new PredicateComparer(3, IterationType.Entry).Compare(("key1", "value1"), ("key2", "value2")),
Is.EqualTo(0));
Assert.That(new PredicateComparer(3, IterationType.Entry).Compare(("key1", "value1"), ("key2", "value2x")),
Is.EqualTo(0));
Assert.That(new PredicateComparer(0, IterationType.Entry).Compare(("abc", "defghi"), ("abcdef", "ghi")),
Is.EqualTo("abc:::defghi".CompareTo("abcdef:::ghi")));
// NOTE
// the behavior for non-supported types and iteration types is ... weird
}
public virtual void Before()
{
_input = new ObjectDataInput(InitData, null, Endianness.BigEndian);
}
