public void CompareToTest1() { using NativeString str = "Hola"; Assert.AreEqual(1, str.CompareTo("Hi")); Assert.AreEqual(1, str.CompareTo("Hello")); Assert.AreEqual(0, str.CompareTo("Hola")); }
/** * Add native media options. * * @param mediaInstance native media instance * @param options options to add * @return <code>true</code> if the options were added; <code>false</code> if they were not */ private bool AddMediaOptions(IntPtr mediaInstance, params string[] options) { Logger.Debug("AddMediaOptions(options={})", options); if (options != null) { IntPtr optionPtr = IntPtr.Zero; foreach (string option in options) { Logger.Debug("option={}", option); optionPtr = NativeString.StringPointer(option); if (optionPtr != IntPtr.Zero) { try { LibVlc.libvlc_media_add_option(mediaInstance, optionPtr); } finally { NativeString.Release(optionPtr); } } else { return(false); } } } return(true); }
/** * Create a new media list item for a give native media instance. * * @param mediaInstance native media instance * @return media list item */ private MediaListItem NewMediaListItem(IntPtr mediaInstance) { string name = NativeString.GetNativeString(LibVlc.libvlc_media_get_meta(mediaInstance, (int)libvlc_meta_e.libvlc_meta_Title)); string mrl = NativeString.GetNativeString(LibVlc.libvlc_media_get_mrl(mediaInstance)); List <MediaListItem> subItems; IntPtr subItemList = LibVlc.libvlc_media_subitems(mediaInstance); if (subItemList != IntPtr.Zero) { try { LibVlc.libvlc_media_list_lock(subItemList); subItems = new List <MediaListItem>(); for (int i = 0; i < LibVlc.libvlc_media_list_count(subItemList); i++) { IntPtr subItemInstance = LibVlc.libvlc_media_list_item_at_index(subItemList, i); subItems.Add(NewMediaListItem(subItemInstance)); LibVlc.libvlc_media_release(subItemInstance); } } finally { LibVlc.libvlc_media_list_unlock(subItemList); } LibVlc.libvlc_media_list_release(subItemList); } else { subItems = new List <MediaListItem>(0); } return(new MediaListItem(name, mrl, subItems)); }
public void AsSpanTest() { using NativeString str = "Hello"; ReadOnlySpan <char> span = str.AsSpan(); Assert.AreEqual(str.ToString(), span.ToString()); }
public static string ToStringUtf8(IntPtr pointer) { using (NativeString result = new NativeString(pointer)) { return(result.ToStringFromUtf8()); } }
public void CloneTest() { using NativeString str = new NativeString("Adios"); using NativeString clone = str.Clone(); Assert.AreEqual(str, clone); }
/** * Create a new native media instance. * * @param media media resource locator * @param mediaOptions zero or more media options * @return native media instance */ private IntPtr newMediaDescriptor(string media, params string[] mediaOptions) { Logger.Debug("newMediaDescriptor(media={},mediaOptions={})", media, mediaOptions); IntPtr mediaPointer = NativeString.StringPointer(media); IntPtr mediaInstance = IntPtr.Zero; if (mediaPointer != IntPtr.Zero) { try { mediaInstance = LibVlc.libvlc_media_new_path(instance, mediaPointer); Logger.Debug("mediaDescriptor={}", mediaInstance); if (mediaListInstance != IntPtr.Zero) { // Set the standard media options (if any)... AddMediaOptions(mediaInstance, standardMediaOptions); // FIXME handle return false? // Set the particular media options (if any)... AddMediaOptions(mediaInstance, mediaOptions); // FIXME handle return false? } } finally { NativeString.Release(mediaPointer); } } return(mediaInstance); }
public bool ReplyToFriendMessage(SteamID steamIDFriend, string message) { CheckIfUsable(); using (NativeString rawMessage = new NativeString(message)) { return(NativeMethods.Friends_ReplyToFriendMessage(steamIDFriend.AsUInt64, rawMessage.ToNativeAsUtf8())); } }
public bool SendClanChatMessage(SteamID steamIDClanChat, string text) { CheckIfUsable(); using (NativeString rawText = new NativeString(text)) { return(NativeMethods.Friends_SendClanChatMessage(steamIDClanChat.AsUInt64, rawText.ToNativeAsUtf8())); } }
public bool SetRichPresence(string key, string value) { CheckIfUsable(); using (NativeString rawString = new NativeString(value)) { return(NativeMethods.Friends_SetRichPresence(key, rawString.ToNativeAsUtf8())); } }
public static unsafe void *GetUnsafePtr(this NativeString nativeString) { #if ENABLE_UNITY_COLLECTIONS_CHECKS AtomicSafetyHandle.CheckWriteAndThrow(nativeString.m_Safety); #endif var data = nativeString.m_Impl.GetStringData(); return(data->buffer); }
//[Theory(Timeout = 1000 * 120)] //[ClassData(typeof(StringGenerator))] public void LoadTest(string[] data) { var hashMap = new HashSet <int>(); foreach (var s in data) { Assert.True(hashMap.Add(NativeString.GetHashCode(s))); } }
public bool SetHTTPRequestRawPostBody(HTTPRequestHandle request, string contentType, System.IntPtr body, uint bodyLength) { CheckIfUsable(); using (NativeString nativeContentType = new NativeString(contentType)) { return(NativeMethods.HTTP_SetHTTPRequestRawPostBody(request.AsUInt32, nativeContentType.ToNativeAsUtf8(), body, bodyLength)); } }
public HTTPRequestHandle CreateHTTPRequest(HTTPMethod HTTPRequestMethod, string absoluteURL) { CheckIfUsable(); using (NativeString nativeString = new NativeString(absoluteURL)) { return(new HTTPRequestHandle(NativeMethods.HTTP_CreateHTTPRequest((int)HTTPRequestMethod, nativeString.ToNativeAsUtf8()))); } }
public void SetPersonaName(string personaName) { CheckIfUsable(); using (NativeString nativeString = new NativeString(personaName)) { NativeMethods.Friends_SetPersonaName(nativeString.ToNativeAsUtf8()); } }
public bool GetHTTPResponseHeaderValue(HTTPRequestHandle request, string headerName, System.IntPtr headerValueBuffer, uint bufferSize) { CheckIfUsable(); using (NativeString nativeHeaderName = new NativeString(headerName)) { return(NativeMethods.HTTP_GetHTTPResponseHeaderValue(request.AsUInt32, nativeHeaderName.ToNativeAsUtf8(), headerValueBuffer, bufferSize)); } }
public void EqualsTest() { using NativeString str = "Hola"; object s = "Hola"; object s1 = "Hello"; Assert.IsTrue(str.Equals(s)); Assert.IsFalse(str.Equals(s1)); }
public void GetHashCodeTest() { NativeString str = "Hola"; Assert.NotZero(str.GetHashCode()); str.Dispose(); Assert.Zero(str.GetHashCode()); }
unsafe public void NativeStringTest3() { char *p = stackalloc char[] { 'H', 'e', 'l', 'l', 'o' }; using NativeString str = new NativeString(p, 5); Assert.AreEqual("Hello", str); Assert.AreEqual(5, str.Length); Assert.IsTrue(str.IsValid); Assert.IsFalse(str.IsEmpty); }
public void AllocateTest() { var str = "foo-bar"; var p = NativeString.Wrap(str); Assert.Equal(str.Length, p.GetLen()); Assert.Equal(Encoding.UTF8.GetByteCount(str), p.GetBuffer().Length); Assert.Equal(Encoding.UTF8, p.GetEncoding()); Assert.Equal(NativeString.GetHashCode(str), p.GetHashCode()); }
public void NativeStringTest2() { ReadOnlySpan <char> span = stackalloc char[] { 'H', 'e', 'l', 'l', 'o' }; using NativeString str = new NativeString(span); Assert.AreEqual("Hello", str); Assert.AreEqual(5, str.Length); Assert.IsTrue(str.IsValid); Assert.IsFalse(str.IsEmpty); }
public void DisposeTest() { NativeString str = "Hello"; str.Dispose(); Assert.AreEqual("", str); Assert.AreEqual(0, str.Length); Assert.IsFalse(str.IsValid); Assert.IsTrue(str.IsEmpty); }
public bool GetHTTPResponseHeaderSize(HTTPRequestHandle request, string headerName, out uint responseHeaderSize) { CheckIfUsable(); responseHeaderSize = 0; using (NativeString nativeHeaderName = new NativeString(headerName)) { return(NativeMethods.HTTP_GetHTTPResponseHeaderSize(request.AsUInt32, nativeHeaderName.ToNativeAsUtf8(), ref responseHeaderSize)); } }
public bool SetHTTPRequestGetOrPostParameter(HTTPRequestHandle request, string paramName, string paramValue) { CheckIfUsable(); using (NativeString nativeParamName = new NativeString(paramName)) { using (NativeString nativeParamValue = new NativeString(paramValue)) { return(NativeMethods.HTTP_SetHTTPRequestGetOrPostParameter(request.AsUInt32, nativeParamName.ToNativeAsUtf8(), nativeParamValue.ToNativeAsUtf8())); } } }
public bool SetHTTPRequestHeaderValue(HTTPRequestHandle request, string headerName, string headerValue) { CheckIfUsable(); using (NativeString nativeHeaderName = new NativeString(headerName)) { using (NativeString nativeHeaderValue = new NativeString(headerValue)) { return(NativeMethods.HTTP_SetHTTPRequestHeaderValue(request.AsUInt32, nativeHeaderName.ToNativeAsUtf8(), nativeHeaderValue.ToNativeAsUtf8())); } } }
public void CopyToTest() { using NativeString str = new NativeString("Hello".AsSpan()); Span <char> span = stackalloc char[5]; str.CopyTo(span, 0, 5); Assert.AreEqual('H', span[0]); Assert.AreEqual('e', span[1]); Assert.AreEqual('l', span[2]); Assert.AreEqual('l', span[3]); Assert.AreEqual('o', span[4]); }
/** * Set a local meta data value for a media instance. * <p> * Setting meta does not affect the underlying media file until {@link #save()} is called. * * @param metaType type of meta data * @param media media instance * @param value meta data value */ private void SetMeta(libvlc_meta_e metaType, string metaValue) { Logger.Trace("SetMeta(metaType={},media={},value={})", metaType, media, metaValue); IntPtr metaValuePtr = NativeString.StringPointer(metaValue); try { LibVlc.libvlc_media_set_meta(media, (int)metaType, metaValuePtr); } finally { NativeString.Release(metaValuePtr); } }
/** * Convert a collection of native module description structures. * * @param moduleDescriptions module descriptions * @return collection of module descriptions */ private List <ModuleDescription> GetModuleDescriptions(IntPtr moduleDescriptions) { List <ModuleDescription> result = new List <ModuleDescription>(); IntPtr moduleDescriptionPointer = moduleDescriptions; while (moduleDescriptionPointer != IntPtr.Zero) { libvlc_module_description_t moduleDescription = (libvlc_module_description_t)Marshal.PtrToStructure(moduleDescriptionPointer, typeof(libvlc_module_description_t)); result.Add(new ModuleDescription(NativeString.String(moduleDescription.psz_name), NativeString.String(moduleDescription.psz_shortname), NativeString.String(moduleDescription.psz_longname), NativeString.String(moduleDescription.psz_help))); moduleDescriptionPointer = moduleDescription.p_next; } return(result); }
public void ToNativeArrayAndDisposeTest() { using NativeString str = "Hola"; using NativeArray <char> array = str.ToNativeArrayAndDispose(); Assert.AreEqual('H', array[0]); Assert.AreEqual('o', array[1]); Assert.AreEqual('l', array[2]); Assert.AreEqual('a', array[3]); Assert.AreEqual(0, str.Length); Assert.IsFalse(str.IsValid); Assert.IsTrue(str.IsEmpty); }
unsafe void Utf16ToUtf8(string source) { var converted = new byte[source.Length * 4]; // UTF-8 text can be up to 2x as long as UTF-16 text var destination = new char[source.Length]; fixed(byte *c = converted) fixed(char *s = source) fixed(char *d = destination) { NativeString.Utf16ToUtf8(s, source.Length, c, out var converted_length, converted.Length); NativeString.Utf8ToUtf16(c, converted_length, d, out var destination_length, destination.Length); Assert.AreEqual(source, destination); } }