public void Types_GetJniTypeNameFromInstance()
{
using (var o = new JavaObject())
Assert.AreEqual("java/lang/Object", JniEnvironment.Types.GetJniTypeNameFromInstance(o.PeerReference));
using (var o = new JavaInt32Array(0))
Assert.AreEqual("[I", JniEnvironment.Types.GetJniTypeNameFromInstance(o.PeerReference));
}
protected async override Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
IInvoker invoker = JavaScope.GetJavaInvoker(context);
var className = TargetType.Get(context);
if (string.IsNullOrWhiteSpace(className))
{
throw new ArgumentNullException(nameof(TargetType));
}
List <object> parameters = GetParameters(context);
JavaObject instance = null;
try
{
instance = await invoker.InvokeConstructor(className, parameters, parameters.Select(param => param?.GetType()).ToList(), cancellationToken);
}
catch (Exception e)
{
Trace.TraceError($"Constrcutor could not be invoker: {e.ToString()}");
throw new InvalidOperationException(Resources.ConstructorException, e);
}
return(asyncCodeActivityContext =>
{
Result.Set(asyncCodeActivityContext, instance);
});
}
public IJavaData Convert(JavaObject @object)
{
byte[] data = @object.SelectValue <byte[]>("[0]");
long milli = BitConverter.ToInt64(data.Reverse().ToArray(), 0);
return(new JavaValue(unix + TimeSpan.FromMilliseconds(milli)));
}
protected override void Execute(CodeActivityContext context)
{
IInvoker invoker = JavaScope.GetJavaInvoker(context);
var javaObject = JavaObject.Get(context) ?? throw new ArgumentNullException(Resources.JavaObject);
Result.Set(context, javaObject.Convert <T>());
}
protected async override Task <Action <AsyncCodeActivityContext> > ExecuteAsync(AsyncCodeActivityContext context, CancellationToken cancellationToken)
{
IInvoker invoker = JavaScope.GetJavaInvoker(context);
var methodName = MethodName.Get(context) ?? throw new ArgumentNullException(Resources.MethodName);
JavaObject javaObject = TargetObject.Get(context);
string className = TargetType.Get(context);
if (javaObject == null && string.IsNullOrWhiteSpace(className))
{
throw new InvalidOperationException(Resources.InvokationObjectException);
}
List <object> parameters = GetParameters(context);
var types = GetParameterTypes(context, parameters);
JavaObject instance = null;
try
{
instance = await invoker.InvokeMethod(methodName, className, javaObject, parameters, types, cancellationToken);
}
catch (Exception e)
{
Trace.TraceError($"The method could not be invoked: {e}");
throw new InvalidOperationException(Resources.InvokeMethodException, e);
}
return(asyncCodeActivityContext =>
{
Result.Set(asyncCodeActivityContext, instance);
});
}
public void JavaReferencedInstanceSurvivesCollection()
{
Console.WriteLine("JavaReferencedInstanceSurvivesCollection");
using (var t = new JniType("java/lang/Object")) {
var oldHandle = IntPtr.Zero;
var array = new JavaObjectArray <JavaObject> (1);
var w = new Thread(() => {
var v = new JavaObject();
oldHandle = v.PeerReference.Handle;
array [0] = v;
});
w.Start();
w.Join();
JniEnvironment.Runtime.ValueManager.CollectPeers();
GC.WaitForPendingFinalizers();
GC.WaitForPendingFinalizers();
var first = array [0];
Assert.IsNotNull(JniRuntime.CurrentRuntime.ValueManager.PeekValue(first.PeerReference));
var f = first.PeerReference;
var o = (JavaObject)JniRuntime.CurrentRuntime.ValueManager.GetValue(ref f, JniObjectReferenceOptions.Copy);
Assert.AreSame(first, o);
if (oldHandle != o.PeerReference.Handle)
{
Console.WriteLine("Yay, object handle changed; value survived a GC!");
}
else
{
Console.WriteLine("What is this, Android pre-ICS?!");
}
o.Dispose();
array.Dispose();
}
}
public void DisposeWithJavaObjectDisposesObject([Values(true, false)] bool register)
{
var native = new JavaObject();
if (!register)
{
native.UnregisterFromRuntime();
}
var instance = new DynamicJavaInstance(native);
Assert.AreEqual(1, JavaClassInfo.GetClassInfoCount("java/lang/Object"));
Assert.AreSame(native, instance.Value);
instance.Dispose();
Assert.AreEqual(null, instance.Value);
Assert.AreEqual(-1, JavaClassInfo.GetClassInfoCount("java/lang/Object"));
if (register)
{
Assert.IsTrue(native.PeerReference.IsValid);
}
else
{
Assert.IsFalse(native.PeerReference.IsValid);
}
}
void ReadInstanceData(ClassDescriptor descriptor, JavaObject @object)
{
if (descriptor.Base != null)
{
ReadInstanceData(descriptor.Base, @object);
}
if ((descriptor.Flags & ClassFlags.SERIALIZABLE) == ClassFlags.SERIALIZABLE)
{
if ((descriptor.Flags & ClassFlags.EXTERNALIZABLE) == ClassFlags.EXTERNALIZABLE)
{
throw new StreamCorruptedException("Descriptor can't be serializable and externizable");
}
@object.Fields.AddRange(ReadFieldData(descriptor));
if ((descriptor.Flags & ClassFlags.WRITE_METHOD) == ClassFlags.WRITE_METHOD)
{
@object.Custom.AddRange(ReadCustomData());
}
}
else if ((descriptor.Flags & ClassFlags.EXTERNALIZABLE) == ClassFlags.EXTERNALIZABLE)
{
//if (descriptor.Flags.HasFlag(ClassFlags.BLOCK_DATA))
// throw new NotSupportedException("External non block data not supported");
@object.Custom.AddRange(ReadCustomData());
}
}
public void RegisterWithVM_PermitsAliases()
{
using (var original = new JavaObject()) {
var p = original.PeerReference;
var alias = new JavaObject(ref p, JniObjectReferenceOptions.Copy);
alias.Dispose();
}
}
public void TestInvalidClassName()
{
var javaObj = new JavaObject("blabla");
var ex = Assert.Throws <IgniteException>(() => TestFilter(javaObj));
Assert.IsTrue(ex.Message.StartsWith("Java object/factory class is not found"));
}
public void GetJniTypeName()
{
using (var o = new JavaObject()) {
Assert.AreEqual("java/lang/Object", o.GetJniTypeName());
}
using (var o = new JavaInt32Array(0)) {
Assert.AreEqual("[I", o.GetJniTypeName());
}
}
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String)
{
Serialized_java = iprot.ReadBinary();
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct)
{
Shell = new ShellComponent();
Shell.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct)
{
Java_object = new JavaObject();
Java_object.Read(iprot);
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void GetJniTypeName_Exceptions()
{
IJavaPeerable o = null;
Assert.Throws <ArgumentNullException> (() => o.GetJniTypeName());
o = new JavaObject();
o.Dispose();
Assert.Throws <ObjectDisposedException> (() => o.GetJniTypeName());
}
public void TestFactory()
{
var javaObj = new JavaObject(PlatformFilterFactory,
new Dictionary <string, object> {
{ "startsWith", "valid" }
});
TestFilter(javaObj);
}
JavaObject ReadInstance()
{
ClassDescriptor descriptor = ReadClassDesc();
JavaObject @object = new JavaObject(descriptor.Name);
CreateReference(@object);
ReadInstanceData(descriptor, @object);
return(@object);
}
public void CrossThreadSharingRequresRegistration()
{
JavaObject o = null;
FinalizerHelpers.PerformNoPinAction(() => {
o = new JavaObject();
});
o.ToString();
o.Dispose();
}
public void TestInvalidProperty()
{
var javaObject = new JavaObject(PlatformFilter)
{
Properties = { { "invalidProp", "123" } }
};
var ex = Assert.Throws <IgniteException>(() => TestFilter(javaObject));
Assert.IsTrue(ex.Message.StartsWith("Java object/factory class field is not found"));
}
public IJavaData Convert(JavaObject @object)
{
double value = @object.SelectValue <double>("intVal");
int scale = @object.SelectValue <int>("scale");
for (int i = 0; i < scale; ++i)
{
value /= 10.0;
}
return(new JavaValue(value));
}
public IJavaData Convert(JavaObject @object)
{
string code = @object.SelectValue <string>("language");
string country = @object.SelectValue <string>("country");
if (!string.IsNullOrEmpty(country))
{
code += "-" + country;
}
return(new JavaValue(CultureInfo.GetCultureInfo(code)));
}
public void TestFilter()
{
var javaObj = new JavaObject(PlatformFilter)
{
Properties =
{
{ "startsWith", "valid" },
{ "charField", 'a' },
{ "byteField", (byte)1 },
{ "sbyteField", (sbyte)2 },
{ "shortField", (short)3 },
{ "ushortField", (ushort)4 },
{ "intField", 5 },
{ "uintField", (uint)6 },
{ "longField", (long)7 },
{ "ulongField", (ulong)8 },
{ "floatField", (float)9.99 },
{ "doubleField", 10.123 },
{ "decimalField", (decimal)11.245 },
{ "boolField", true },
{ "guidField", Guid.Parse("1c579241-509d-47c6-a1a0-87462ae31e59") },
{
"objField", new TestBinary(1, "2")
},
{ "charArr", new[] { 'a' } },
{ "byteArr", new[] { (byte)1 } },
{ "sbyteArr", new[] { (sbyte)2 } },
{ "shortArr", new[] { (short)3 } },
{ "ushortArr", new[] { (ushort)4 } },
{ "intArr", new[] { 5 } },
{ "uintArr", new[] { (uint)6 } },
{ "longArr", new[] { (long)7 } },
{ "ulongArr", new[] { (ulong)8 } },
{ "floatArr", new[] { (float)9.99 } },
{ "doubleArr", new[] { 10.123 } },
{ "boolArr", new[] { true } },
{
"objArr", new object[]
{
new TestBinary(1, "2")
}
},
{ "arrayList", new ArrayList {
"x"
} },
{ "hashTable", new Hashtable {
{ 1, "2" }
} }
}
};
TestFilter(javaObj);
}
/// <summary>
/// Tests the specified filter.
/// </summary>
private void TestFilter(JavaObject obj, bool local)
{
// Test with cache of strings
var pred = obj.ToCacheEntryEventFilter <int, string>();
TestFilter(pred, local, "validValue", "invalidValue");
// Test with cache of binary objects
var objPred = obj.ToCacheEntryEventFilter <int, TestBinary>();
TestFilter(objPred, local, new TestBinary(1, "validValue"), new TestBinary(2, "invalidValue"));
}
public void CrossThreadSharingRequresRegistration()
{
JavaObject o = null;
var t = new Thread(() => {
o = new JavaObject();
});
t.Start();
t.Join();
o.ToString();
o.Dispose();
}
public void PeekValue()
{
JniObjectReference lref;
using (var o = new JavaObject()) {
lref = o.PeerReference.NewLocalRef();
Assert.AreSame(o, JniRuntime.CurrentRuntime.ValueManager.PeekValue(lref));
}
// At this point, the Java-side object is kept alive by `lref`,
// but the wrapper instance has been disposed, and thus should
// be unregistered, and thus unfindable.
Assert.IsNull(JniRuntime.CurrentRuntime.ValueManager.PeekValue(lref));
JniObjectReference.Dispose(ref lref);
}
public void Dispose_ClearsLocalReferences()
{
if (!HaveSafeHandles)
{
Assert.Ignore("SafeHandles aren't used, so magical disposal from a distance isn't supported.");
return;
}
JniObjectReference lref;
using (var envp = new JniTransition(JniEnvironment.EnvironmentPointer)) {
lref = new JavaObject().PeerReference.NewLocalRef();
Assert.IsTrue(lref.IsValid);
}
Assert.IsFalse(lref.IsValid);
}
public IJavaData Convert(JavaObject @object)
{
byte[] bytes = @object.SelectValues <byte>("magnitude").ToArray();
long signum = @object.SelectValue <long>("signum");
if (bytes.Length == 0)
{
return(new JavaValue(signum));
}
foreach (byte field in bytes)
{
signum = (signum << 8) | field;
}
return(new JavaValue(signum));
}
public void CreateValue()
{
using (var vm = new MyValueManager())
using (var o = new JavaObject()) {
vm.OnSetRuntime(JniRuntime.CurrentRuntime);
var r = o.PeerReference;
var x = (IJavaPeerable)vm.CreateValue(ref r, JniObjectReferenceOptions.Copy);
Assert.AreNotSame(o, x);
x.Dispose();
x = vm.CreateValue <IJavaPeerable> (ref r, JniObjectReferenceOptions.Copy);
Assert.AreNotSame(o, x);
x.Dispose();
}
}
public IJavaData Convert(JavaObject @object)
{
object instance = descriptor.CreateInstance();
foreach (JavaField field in @object.Fields)
{
if (!(field.Value is JavaValue))
{
continue;
}
PropertyInfo property = descriptor.GetProperty(field.Name);
property?.SetValue(instance, Converter.Convert(((JavaValue)field.Value).Value, property.PropertyType, true), null);
}
return(new JavaValue(instance));
}
public void ObjectDisposed()
{
var o = new JavaObject();
o.Dispose();
// These should not throw
var h = o.PeerReference;
var p = o.JniPeerMembers;
// These should throw
Assert.Throws <ObjectDisposedException> (() => o.GetHashCode());
Assert.Throws <ObjectDisposedException> (() => o.UnregisterFromRuntime());
Assert.Throws <ObjectDisposedException> (() => o.ToString());
Assert.Throws <ObjectDisposedException> (() => o.Equals(o));
}
public unsafe void Ctor()
{
using (var t = new JniType("java/lang/Object")) {
var c = t.GetConstructor("()V");
var lref = t.NewObject(c, null);
Assert.IsTrue(lref.IsValid);
using (var o = new JavaObject(ref lref, JniObjectReferenceOptions.Copy)) {
Assert.IsTrue(lref.IsValid);
Assert.AreNotSame(lref, o.PeerReference);
}
using (var o = new JavaObject(ref lref, JniObjectReferenceOptions.CopyAndDispose)) {
Assert.IsFalse(lref.IsValid);
Assert.AreNotSame(lref, o.PeerReference);
}
}
}
public IJavaData Convert(JavaObject @object)
{
JavaObject transformed = new JavaObject(@object.Type);
transformed.Fields.AddRange(@object.Fields);
for (int i = 1; i < @object.Custom.Count; i += 2)
{
JavaValue value = @object.Custom[i] as JavaValue;
if (value == null)
{
continue;
}
JavaField field = new JavaField(value.Get <string>(), @object.Custom[i + 1]);
transformed.Fields.Add(field);
}
return(transformed);
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.List) {
{
Fields = new List<string>();
TList _list4 = iprot.ReadListBegin();
for( int _i5 = 0; _i5 < _list4.Count; ++_i5)
{
string _elem6;
_elem6 = iprot.ReadString();
Fields.Add(_elem6);
}
iprot.ReadListEnd();
}
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Shuffle = new NullStruct();
Shuffle.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
All = new NullStruct();
All.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Struct) {
None = new NullStruct();
None.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.Struct) {
Direct = new NullStruct();
Direct.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct) {
Custom_object = new JavaObject();
Custom_object.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.String) {
Custom_serialized = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.Struct) {
Local_or_shuffle = new NullStruct();
Local_or_shuffle.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public void Read (TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop) {
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.String) {
Serialized_java = iprot.ReadBinary();
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Struct) {
Shell = new ShellComponent();
Shell.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.Struct) {
Java_object = new JavaObject();
Java_object.Read(iprot);
} else {
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
{
int index = (int)indexes[0];
PrimitiveType memberAsPrimitive;
ArrayType memberAsArray;
if ((memberAsPrimitive = _arrayType.MemberType as PrimitiveType) != null)
{
switch (memberAsPrimitive.Kind)
{
case PrimitiveTypeKind.Boolean: result = _vm.GetBooleanArray(_arrayPtr)[index]; break;
case PrimitiveTypeKind.Byte: result = _vm.GetByteArray(_arrayPtr)[index]; break;
case PrimitiveTypeKind.Char: result = _vm.GetCharArray(_arrayPtr)[index]; break;
case PrimitiveTypeKind.Double: result = _vm.GetDoubleArray(_arrayPtr)[index]; break;
case PrimitiveTypeKind.Float: result = _vm.GetFloatArray(_arrayPtr)[index]; break;
case PrimitiveTypeKind.Int: result = _vm.GetIntArray(_arrayPtr)[index]; break;
case PrimitiveTypeKind.Long: result = _vm.GetLongArray(_arrayPtr)[index]; break;
case PrimitiveTypeKind.Short: result = _vm.GetShortArray(_arrayPtr)[index]; break;
default: throw new InvalidOperationException("Unknown primitive kind: " + memberAsPrimitive.Kind);
}
return true;
}
else if ((memberAsArray = _arrayType.MemberType as ArrayType) != null)
{
result = new JavaArray(_vm, _vm.GetArray(_arrayPtr)[index], memberAsArray);
return true;
}
else
{
IntPtr objectPointer = _vm.GetArray(_arrayPtr)[index];
// I'll intentionally pass the actual type as null if we have a non-null object, so we can discover
// the precise type instead of just assuming it's of the base class type.
result = new JavaObject(_vm, objectPointer, objectPointer == IntPtr.Zero ? (JavaClass)_arrayType.MemberType : null);
return true;
}
}
