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