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