public void pointerTest1()
{
string managed = " my string 123 ";
UnmanagedString uns, uns2;
using (uns = new UnmanagedString(managed, UnmanagedString.SType.Unicode))
{
IntPtr ptr = uns;
using (uns2 = new UnmanagedString(ptr, uns.Type))
{
Assert.Equal(uns.Pointer, uns2.Pointer);
Assert.Equal(uns.Type, uns2.Type);
Assert.False(uns2.Owner);
Assert.True(uns.Owner);
Assert.Equal(managed.Length, uns2.Data.Length);
Assert.Equal(managed, uns2.Data);
}
}
Assert.Equal(IntPtr.Zero, (IntPtr)uns);
Assert.Equal(IntPtr.Zero, (IntPtr)uns2);
}
public void GetStringLengthTest3()
{
const int BSIZE = 2;
string managed = " my string 123 ";
using (var uns = new UnmanagedString(managed, UnmanagedString.SType.BSTR)) {
IntPtr ptr = uns;
Assert.AreEqual(managed.Length * BSIZE, ptr.GetStringLength(BSIZE));
}
}
public void allocFreeTest2()
{
string managed = " my string 123 ";
UnmanagedString uns;
using (uns = new UnmanagedString(managed, UnmanagedString.SType.Unicode)) {
WCharPtr actual = uns;
Assert.AreEqual(managed.Length, ((string)actual).Length);
Assert.AreEqual(UnmanagedString.SType.Unicode, uns.Type);
}
Assert.AreEqual(IntPtr.Zero, (IntPtr)uns);
}
public void allocFreeTest3()
{
string managed = " my string 123 ";
UnmanagedString uns;
using (uns = new UnmanagedString(managed, UnmanagedString.SType.BSTR)) {
BSTR actual = uns;
Assert.Equal(managed.Length, ((string)actual).Length);
Assert.Equal(UnmanagedString.SType.BSTR, uns.Type);
}
Assert.Equal(IntPtr.Zero, (IntPtr)uns);
}
public static bool GetDUOFirmwareBuild(IntPtr duo, ref string val)
{
try
{
UnmanagedString str = new UnmanagedString();
if (DUOLibInternal.DUOGetFirmwareBuild(duo, str.Pointer))
{
val = str.String;
return(true);
}
else
{
return(false);
}
}
catch { return(false); }
}
public void echoTest5()
{
using (var l = new ConariL(UNLIB_DLL))
{
string exp = "my string-123 !";
using (var uns = new UnmanagedString(exp, UnmanagedString.SType.Unicode))
{
WCharPtr wchrptr = uns;
Assert.AreEqual(exp, l.DLR.get_WStringPtrVal <WCharPtr>(wchrptr));
Assert.AreEqual(exp, l.bind <Func <WCharPtr, WCharPtr> >("get_WStringPtrVal")(wchrptr));
var dyn = l.bind(Dynamic.GetMethodInfo(typeof(WCharPtr), typeof(WCharPtr)), "get_WStringPtrVal");
Assert.AreEqual(exp, (WCharPtr)dyn.dynamic.Invoke(null, new object[] { wchrptr }));
}
}
}
public void echoTest3()
{
using (var l = new ConariL(UNLIB_DLL))
{
string exp = "my string-123 !";
using (var uns = new UnmanagedString(exp, UnmanagedString.SType.BSTR))
{
BSTR bstr = uns;
Assert.AreEqual(exp, l.DLR.get_BSTRVal <BSTR>(bstr));
Assert.AreEqual(exp, l.bind <Func <BSTR, BSTR> >("get_BSTRVal")(bstr));
var dyn = l.bind(Dynamic.GetMethodInfo(typeof(BSTR), typeof(BSTR)), "get_BSTRVal");
Assert.AreEqual(exp, (BSTR)dyn.dynamic.Invoke(null, new object[] { bstr }));
}
}
}
public void echoTest1()
{
using (var l = new ConariL(UNLIB_DLL))
{
string exp = "my string-123 !";
using (var uns = new UnmanagedString(exp, UnmanagedString.SType.Ansi))
{
CharPtr chrptr = uns;
Assert.AreEqual(exp, l.DLR.get_CharPtrVal <CharPtr>(chrptr));
Assert.AreEqual(exp, l.bind <Func <CharPtr, CharPtr> >("get_CharPtrVal")(chrptr));
var dyn = l.bind(Dynamic.GetMethodInfo(typeof(CharPtr), typeof(CharPtr)), "get_CharPtrVal");
Assert.AreEqual(exp, (CharPtr)dyn.dynamic.Invoke(null, new object[] { chrptr }));
}
}
}
public void tryAlgo(string data, string filter)
{
using (IConari l = new ConariL("regXwild.dll"))
{
using (var uData = new UnmanagedString(data, UnmanagedString.SType.Unicode))
using (var uFilter = new UnmanagedString(filter, UnmanagedString.SType.Unicode))
{
Console.WriteLine($"Unicode: true \niterations({iterations}) x average({average})\n");
var alg = new Algorithms();
calcAlgo(" regXwild via Conari (Lambda) - ESS version: ", l, uData, uFilter, alg.regXwildEssLambda);
calcAlgo(" regXwild via Conari (DLR)- ESS version: ", l, uData, uFilter, alg.regXwildEssDLR);
calcAlgo(" regXwild via Conari (Lambda) - EXT version: ", l, uData, uFilter, alg.regXwildExtLambda);
calcAlgo(" regXwild via Conari (DLR) - EXT version: ", l, uData, uFilter, alg.regXwildExtDLR);
}
}
}
public static int CompareOrdinal(UnmanagedString strA, Span <byte> strB)
{
if (strA.IsNull && strB == null)
{
return(0);
}
if (strB == null)
{
return(1);
}
if (strA.IsNull)
{
return(-1);
}
return(strA.StringAsBytes.SequenceCompareTo(strB));
}
public void GetStringBytesTest1()
{
string managed = " mystring ";
using (var uns = new UnmanagedString(managed, UnmanagedString.SType.Ansi)) {
IntPtr ptr = uns;
Assert.AreEqual(0, ptr.GetStringBytes(-1).Length);
Assert.AreEqual(0, ptr.GetStringBytes(0).Length);
Assert.AreEqual(5, ptr.GetStringBytes(5).Length);
var a = Encoding.UTF8.GetBytes(managed).Take(3).ToArray();
var b = ptr.GetStringBytes(3);
Assert.AreEqual(a[0], b[0]);
Assert.AreEqual(a[1], b[1]);
Assert.AreEqual(a[2], b[2]);
}
}
public void stringTest3()
{
using (var l = new ConariL(gCfgUnlib))
{
string exp = "mystring-123 !";
using (var uns1 = new UnmanagedString(exp, UnmanagedString.SType.Ansi))
using (var uns2 = new UnmanagedString(exp, UnmanagedString.SType.Ansi))
using (var uns3 = new UnmanagedString(" " + exp, UnmanagedString.SType.Ansi))
{
CharPtr chrptr = uns1;
CharPtr chrptr2 = uns2;
Assert.Equal(true, l.DLR.get_StringPtrCmpRef <bool>(chrptr, chrptr2));
Assert.True(l.bind <Func <CharPtr, CharPtr, bool> >("get_StringPtrCmpRef")(chrptr, chrptr2));
Assert.Equal(false, l.DLR.get_StringPtrCmpRef <bool>(chrptr, (CharPtr)uns3));
}
}
}
public void stringTest2()
{
using (var l = new ConariL(gCfgUnlib))
{
string exp = "mystring-123 !";
using (var uns1 = new UnmanagedString(exp, UnmanagedString.SType.Unicode))
using (var uns2 = new UnmanagedString(exp, UnmanagedString.SType.Unicode))
using (var uns3 = new UnmanagedString(" " + exp, UnmanagedString.SType.Unicode))
{
WCharPtr wchrptr = uns1;
WCharPtr wchrptr2 = uns2;
Assert.Equal(true, l.DLR.get_WCharPtrCmpRef <bool>(wchrptr, wchrptr2));
Assert.True(l.bind <Func <WCharPtr, WCharPtr, bool> >("get_WCharPtrCmpRef")(wchrptr, wchrptr2));
Assert.Equal(false, l.DLR.get_WCharPtrCmpRef <bool>(wchrptr, (WCharPtr)uns3));
}
}
}
public void stringTest4()
{
using (var l = new ConariL(UNLIB_DLL))
{
string exp = "mystring-123 !";
using (var uns1 = new UnmanagedString(exp, UnmanagedString.SType.Unicode))
using (var uns2 = new UnmanagedString(exp, UnmanagedString.SType.Unicode))
using (var uns3 = new UnmanagedString(" " + exp, UnmanagedString.SType.Unicode))
{
WCharPtr chrptr = uns1;
WCharPtr chrptr2 = uns2;
Assert.AreEqual(true, l.DLR.get_WStringPtrCmpRef <bool>(chrptr, chrptr2));
Assert.AreEqual(true, l.bind <Func <WCharPtr, WCharPtr, bool> >("get_WStringPtrCmpRef")(chrptr, chrptr2));
Assert.AreEqual(false, l.DLR.get_WStringPtrCmpRef <bool>(chrptr, (WCharPtr)uns3));
}
}
}
public static unsafe ReadOnlySpan <char> AsSpan(this UnmanagedString @this)
{
char *ptr = @this.GetInternalPointer();
return(new ReadOnlySpan <char>(ptr, @this.Length));
}
public static string SymbolToString(SymbolData symbol, uint symbolLoadFailure)
{
switch (symbol.BaseAddress.ToBytes)
{
case 0:
if (symbol.SymbolName.EqualsCaseInsensitiveInvariant(rootString))
{
return("[Root]");
}
return("?!?");
case 1:
return("");
case 2:
return("n/a");
case 3:
return("[Idle]");
}
var isJittedSymbol = symbol.ProcessImageData.UsageType == 4;
var sb = s_builder.Value;
sb.Clear();
UnmanagedString moduleName = symbol.ProcessImageData.ImageName.FileName;
if (!moduleName.HasValue)
{
moduleName = symbol.SymbolImageData.OriginalFileName;
}
var moduleSpan = moduleName.AsSpan();
if (!isJittedSymbol && moduleSpan.EndsWith(".ni.dll".AsSpan(), StringComparison.Ordinal))
{
isJittedSymbol = true;
moduleSpan = moduleSpan.Slice(0, moduleSpan.Length - 7);
}
if (isJittedSymbol && (moduleSpan.EndsWith(".dll".AsSpan(), StringComparison.OrdinalIgnoreCase) || moduleSpan.EndsWith(".exe".AsSpan(), StringComparison.OrdinalIgnoreCase)))
{
moduleSpan = moduleSpan.Slice(0, moduleSpan.Length - 4);
}
sb.Append(moduleSpan);
if (moduleSpan.IsEmpty)
{
sb.Append('?');
}
sb.Append('!');
if (symbolLoadFailure > 0)
{
sb.Append('<');
DecodedSymbol.SymbolLoadFailureDictionary.TryGetValue(symbolLoadFailure, out var failure);
sb.Append(failure ?? "Unknown failure");
sb.Append('>');
return(sb.ToString());
}
var functionName = symbol.SymbolName.AsSpan();
if (functionName.IsEmpty)
{
sb.Append(symbol.BaseAddress.ToBytes.ToString("X"));
}
else
{
if (isJittedSymbol)
{
if (functionName.StartsWith(moduleSpan, StringComparison.Ordinal))
{
functionName = functionName.Slice(moduleSpan.Length);
functionName = functionName.TrimStart('.');
}
if (functionName.EndsWith(" 0x0".AsSpan(), StringComparison.Ordinal))
{
functionName = functionName.Slice(0, functionName.Length - 4);
}
ProcessString(functionName, sb);
}
else
{
sb.Append(functionName);
}
}
return(sb.ToString());
}
public static int CompareOrdinal(Span <byte> strA, UnmanagedString strB)
{
return(-CompareOrdinal(strB, strA));
}
