public void CreateFromStringListTest() { var r = new[] { "5", "5", "5", "5" }; var h = SafeCoTaskMemHandle.CreateFromStringList(r, StringListPackMethod.Concatenated, CharSet.Ansi, 7); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(16)); Assert.That(h.ToStringEnum(CharSet.Ansi, 7), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items); h = SafeCoTaskMemHandle.CreateFromStringList(r, StringListPackMethod.Concatenated, CharSet.Unicode, 7); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(25)); Assert.That(h.ToStringEnum(CharSet.Unicode, 7), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items); h = SafeCoTaskMemHandle.CreateFromStringList(r); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(18)); Assert.That(h.ToString(-1), Is.EqualTo("5")); Assert.That(h.ToStringEnum(), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items); h = SafeCoTaskMemHandle.CreateFromStringList(r, StringListPackMethod.Packed, CharSet.Ansi, 7); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(7 + IntPtr.Size + r.Length * (2 + IntPtr.Size))); Assert.That(h.ToStringEnum(4, CharSet.Ansi, 7), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items); h = SafeCoTaskMemHandle.CreateFromStringList(r, StringListPackMethod.Packed, CharSet.Unicode, 7); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(7 + IntPtr.Size + r.Length * (4 + IntPtr.Size))); Assert.That(h.ToStringEnum(4, CharSet.Unicode, 7), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items); h = SafeCoTaskMemHandle.CreateFromStringList(r, StringListPackMethod.Packed); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(IntPtr.Size + r.Length * (4 + IntPtr.Size))); Assert.That(h.ToStringEnum(4, CharSet.Unicode), Has.Exactly(4).EqualTo("5").And.Exactly(4).Items); h = SafeCoTaskMemHandle.CreateFromStringList(null); Assert.That((int)h.Size, Is.EqualTo(Extensions.StringHelper.GetCharSize())); }
public void EncryptTest() { byte[] rgbPlaintext = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; byte[] rgbIV = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; byte[] rgbAES128Key = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F }; var err = BCryptOpenAlgorithmProvider(out var hAlg, StandardAlgorithmId.BCRYPT_AES_ALGORITHM); Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS)); var cbKeyObject = BCryptGetProperty <uint>(hAlg, BCrypt.PropertyName.BCRYPT_OBJECT_LENGTH); Assert.That(cbKeyObject, Is.GreaterThan(0)); var cbBlockLen = BCryptGetProperty <uint>(hAlg, BCrypt.PropertyName.BCRYPT_BLOCK_LENGTH); Assert.That(cbBlockLen, Is.GreaterThan(0)); Assert.That(cbBlockLen, Is.LessThanOrEqualTo(rgbIV.Length)); var cm = System.Text.Encoding.Unicode.GetBytes(ChainingMode.BCRYPT_CHAIN_MODE_CBC); err = BCryptSetProperty(hAlg, BCrypt.PropertyName.BCRYPT_CHAINING_MODE, cm, (uint)cm.Length); Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS)); var pbKeyObject = new SafeCoTaskMemHandle((int)cbKeyObject); err = BCryptGenerateSymmetricKey(hAlg, out var hKey, pbKeyObject, cbKeyObject, rgbAES128Key, (uint)rgbAES128Key.Length, 0); Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS)); err = BCryptExportKey(hKey, default, BlobType.BCRYPT_OPAQUE_KEY_BLOB, IntPtr.Zero, 0, out var cbBlob);
public void CreateHashTest() { var err = BCryptOpenAlgorithmProvider(out var hAlg, StandardAlgorithmId.BCRYPT_SHA256_ALGORITHM); Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS)); var cbHashObject = BCryptGetProperty <uint>(hAlg, BCrypt.PropertyName.BCRYPT_OBJECT_LENGTH); Assert.That(cbHashObject, Is.GreaterThan(0)); var cbHash = BCryptGetProperty <uint>(hAlg, BCrypt.PropertyName.BCRYPT_HASH_LENGTH); Assert.That(cbHash, Is.GreaterThan(0)); var pbHashObject = new SafeHeapBlock((int)cbHashObject); var pbHash = new SafeHeapBlock((int)cbHash); err = BCryptCreateHash(hAlg, out var hHash, pbHashObject, cbHashObject); Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS)); var pbDupHashObj = new SafeCoTaskMemHandle((int)cbHashObject); err = BCryptDuplicateHash(hHash, out var hDupHash, pbDupHashObj, cbHashObject); Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS)); var rgbMsg = new byte[] { 0x61, 0x62, 0x63 }; err = BCryptHashData(hHash, rgbMsg, (uint)rgbMsg.Length, 0); Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS)); err = BCryptFinishHash(hHash, pbHash, cbHash); Assert.That((int)err, Is.EqualTo(NTStatus.STATUS_SUCCESS)); }
public static IEnumerable <INHERITED_FROM> GetInheritanceSource(string objectName, ResourceType objectType, SECURITY_INFORMATION securityInfo, bool container, IntPtr pAcl, ref GENERIC_MAPPING pGenericMapping) { var objSize = Marshal.SizeOf(typeof(INHERITED_FROM)); var aceCount = GetAceCount(pAcl); using (var pInherit = new SafeCoTaskMemHandle(objSize * (int)aceCount)) { var hr = 0; try { hr = AdvApi32.GetInheritanceSource(objectName, objectType, securityInfo, container, null, 0, pAcl, IntPtr.Zero, ref pGenericMapping, (IntPtr)pInherit); if (hr != 0) { throw new System.ComponentModel.Win32Exception(hr); } return(pInherit.ToIEnum <INHERITED_FROM>((int)aceCount)); } finally { if (hr != 0) { FreeInheritedFromArray((IntPtr)pInherit, (ushort)aceCount, IntPtr.Zero); } } } }
public void CreateFromListTest() { var r = new[] { 5, 5, 5, 5 }; var h = SafeCoTaskMemHandle.CreateFromList(r, r.Length); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(Marshal.SizeOf(typeof(int)) * r.Length)); Assert.That(h.ToStructure <int>(), Is.EqualTo(5)); Assert.That(h.ToEnumerable <int>(4), Has.Exactly(4).EqualTo(5).And.Exactly(4).Items); var d = new[] { new RECT(1, 1, 1, 1), new RECT(2, 2, 2, 2) }; h = SafeCoTaskMemHandle.CreateFromList(d, d.Length); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(Marshal.SizeOf(typeof(RECT)) * d.Length)); Assert.That(h.ToStructure <RECT>().X, Is.EqualTo(1)); Assert.That(h.ToArray <RECT>(2), Has.Exactly(2).Items); var p = new[] { new PRECT(1, 1, 1, 1), new PRECT(2, 2, 2, 2) }; h = SafeCoTaskMemHandle.CreateFromList(p); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(Marshal.SizeOf(typeof(PRECT)) * p.Length)); Assert.That(h.ToArray <RECT>(2), Has.Exactly(2).Items); Assert.That(() => SafeCoTaskMemHandle.CreateFromList(new[] { "X" }), Throws.ArgumentException); }
public void SafeArrayScopedAccessTest() { var psa = SafeArrayCreateVector(VARTYPE.VT_I4, 0, 5); { /*for (int i = 0; i < 5; i++) * { * var p = new SafeCoTaskMemHandle(16); * Marshal.GetNativeVariantForObject(i, (IntPtr)p); * Assert.That(SafeArrayPutElement(psa, new[] { i }, (IntPtr)p).Succeeded); * }*/ using (var d = new SafeArrayScopedAccessData(psa)) { //var a = d.Data.ToArray<int>(5); //Assert.That(a, Is.EquivalentTo(new long[] {0, 1, 2, 3, 4})); d.Data.Write(new[] { 0, 1, 2, 3, 4 }); } for (var i = 0; i < 5; i++) { var p = new SafeCoTaskMemHandle(16); Assert.That(SafeArrayGetElement(psa, new[] { i }, (IntPtr)p).Succeeded); var oi = p.ToStructure <int>(); Assert.That(oi, Is.EqualTo(i)); } } psa.Dispose(); }
public void TestEx() { const string fn = @"c:\windows\explorer.exe"; var sz = GetFileVersionInfoSizeEx(FILE_VER_GET.FILE_VER_GET_LOCALISED, fn, out _); Assert.NotZero(sz); using var mem = new SafeCoTaskMemHandle(sz); Assert.That(GetFileVersionInfoEx(FILE_VER_GET.FILE_VER_GET_LOCALISED, fn, 0, mem.Size, mem), ResultIs.Successful); Assert.That(VerQueryValue(mem, "\\", out var ptr, out var ptrLen), ResultIs.Successful); var ffi = ptr.ToStructure<VS_FIXEDFILEINFO>(ptrLen); ffi.WriteValues(); Assert.That(VerQueryValue(mem, @"\VarFileInfo\Translation", out ptr, out ptrLen), ResultIs.Successful); Assert.That(ptrLen, Is.GreaterThanOrEqualTo(4)); var langcp = ptr.ToStructure<uint>(ptrLen); var lookup = $"\\StringFileInfo\\{Macros.LOWORD(langcp):X4}{Macros.HIWORD(langcp):X4}\\"; GetStringVal("Comments"); GetStringVal("CompanyName"); GetStringVal("FileDescription"); GetStringVal("FileVersion"); GetStringVal("InternalName"); GetStringVal("LegalCopyright"); GetStringVal("ProductName"); GetStringVal("ProductVersion"); void GetStringVal(string val) { if (VerQueryValue(mem, lookup + val, out ptr, out ptrLen)) TestContext.WriteLine(StringHelper.GetString(ptr, CharSet.Auto)); } }
public void GetThemeTimingFunctionTest() { var buf = new SafeCoTaskMemHandle(100); var hr = GetThemeTimingFunction(hbt, 1, (IntPtr)buf, (uint)buf.Size, out var sz); // Can't test this as there are no properties that return a value. Assert.That(hr.Failed); }
/// <summary> /// Sets the specified window attribute through the Desktop Window Manager (DWM). /// </summary> /// <param name="window">The window.</param> /// <param name="attribute">The attribute.</param> /// <param name="value">The value.</param> public static void SetWindowAttribute <T>(this IWin32Window window, SetWindowAttr attribute, T value) where T : struct { if (window == null) { throw new ArgumentNullException(nameof(window)); } using (var ptr = SafeCoTaskMemHandle.AllocCoTaskMemStruct <T>(value)) DwmSetWindowAttribute(window.Handle, (DWMWINDOWATTRIBUTE)attribute, (IntPtr)ptr, ptr.Size); }
/// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary> public void Dispose() { if (buffer is null) { return; } buffer.Zero(); buffer = null; }
public void SafeCoTaskMemHandleTest4() { var h = new SafeCoTaskMemHandle("0123456789"); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(11 * Marshal.SystemDefaultCharSize)); h.Dispose(); Assert.That(h.IsClosed && h.IsInvalid); }
public void SafeCoTaskMemHandleTest2() { var h = new SafeCoTaskMemHandle(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(10)); h.Dispose(); Assert.That(h.IsClosed && h.IsInvalid); }
public void SafeCoTaskMemHandleTest3() { var h = new SafeCoTaskMemHandle(new[] { (IntPtr)1, (IntPtr)2, (IntPtr)3, (IntPtr)4, (IntPtr)5 }); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(5 * IntPtr.Size)); h.Dispose(); Assert.That(h.IsClosed && h.IsInvalid); }
public void CreateFromStructureTest() { var r = new RECT(5, 5, 5, 5); var h = SafeCoTaskMemHandle.CreateFromStructure(r); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(Marshal.SizeOf(typeof(RECT)))); Assert.That(h.ToStructure <RECT>().X, Is.EqualTo(5)); }
public void SafeCoTaskMemHandleTest1() { var h = new SafeCoTaskMemHandle(Marshal.AllocCoTaskMem(5), 5); Assert.That(!h.IsClosed && !h.IsInvalid); Assert.That((int)h.Size, Is.EqualTo(5)); h.Dispose(); Assert.That(h.IsClosed && h.IsInvalid); }
public void Dhcpv6RequestParamsTest() { using var pparam = new SafeCoTaskMemStruct <DHCPV6CAPI_PARAMS>(new DHCPV6CAPI_PARAMS { OptionId = DHCPV6_OPTION_ID.DHCPV6_OPTION_CLIENTID }); var recdParams = new DHCPV6CAPI_PARAMS_ARRAY { nParams = 1, Params = pparam }; uint sz = 1000; using var mem = new SafeCoTaskMemHandle(sz); Assert.That(Dhcpv6RequestParams(false, default, DhcpTests.adp.Id, IntPtr.Zero, recdParams, mem, ref sz), ResultIs.Successful);
public void GetAdaptersInfoTest() { uint len = 15000; var mem = new SafeCoTaskMemHandle((int)len); #pragma warning disable CS0618 // Type or member is obsolete Assert.That(GetAdaptersInfo((IntPtr)mem, ref len), Is.Zero); Assert.That(((IntPtr)mem).LinkedListToIEnum <IP_ADAPTER_INFO>(i => i.Next), Is.Not.Empty); #pragma warning restore CS0618 // Type or member is obsolete }
public void ResizeTest() { var h = new SafeCoTaskMemHandle(5); Assert.That(!h.IsClosed && !h.IsInvalid && h.Size == 5); var ptr = (IntPtr)h; h.Size = 50; Assert.That(!h.IsClosed && !h.IsInvalid && h.Size == 50 && (IntPtr)h != ptr); }
/// <summary>Sets the tab stops in a multiline edit control. When text is copied to the control, any tab character in the text causes space to be generated up to the next tab stop.</summary> /// <param name="textBox">The text box.</param> /// <param name="tabs">An array of unsigned integers specifying the tab stops, in dialog template units. If this parameter is not supplied, default tab stops are set at every 32 dialog template units. If a single value is provided, this value is the distance between all tab stops, in dialog template units. If two or more values are provided, each value represents a tab stop in dialog template units.</param> public static void SetTabStops(this TextBox textBox, params uint[] tabs) { if (tabs == null) { tabs = new uint[0]; } using (var ptr = SafeCoTaskMemHandle.CreateFromList(tabs)) SendMessage(textBox.Handle, (uint)EditMessage.EM_SETTABSTOPS, (IntPtr)tabs.Length, (IntPtr)ptr); textBox.Invalidate(); }
public AutomaticJumpListSample() { InitializeComponent(); // From wWinMain var mem = SafeCoTaskMemHandle.CreateFromStructure <uint>(); var memSz = (uint)mem.Size; var fRecentSelected = SHGetValue(HKEY.HKEY_CURRENT_USER, REGPATH_SAMPLE, REGVAL_RECENTCATEGORY, out _, mem, ref memSz).Succeeded ? mem.ToStructure <uint>() != 0 : true; SetCategory(fRecentSelected); }
private void ElevatePrivileges(string[] privs) { var newPriv = new PTOKEN_PRIVILEGES(Array.ConvertAll(privs, s => new LUID_AND_ATTRIBUTES(LUID.FromName(s), PrivilegeAttributes.SE_PRIVILEGE_ENABLED))); prevState = PTOKEN_PRIVILEGES.GetAllocatedAndEmptyInstance(); if (!AdjustTokenPrivileges(tok, false, newPriv, prevState.Size, prevState, out var retLen)) { Win32Error.ThrowLastError(); } prevState.Size = (int)retLen; }
/// <summary> /// Gets the specified window attribute from the Desktop Window Manager (DWM). /// </summary> /// <typeparam name="T">Return type. Must match the attribute.</typeparam> /// <param name="window">The window.</param> /// <param name="attribute">The attribute.</param> /// <returns>Value of the windows attribute.</returns> public static T GetWindowAttribute <T>(this IWin32Window window, GetWindowAttr attribute) where T : struct { if (window == null) { throw new ArgumentNullException(nameof(window)); } using (var ptr = SafeCoTaskMemHandle.AllocCoTaskMem <T>()) { DwmGetWindowAttribute(window.Handle, (DWMWINDOWATTRIBUTE)attribute, (IntPtr)ptr, ptr.Size); return(ptr.ToStructure <T>()); } }
public static void AdjustPrivileges(this SafeTokenHandle hObj, SafeCoTaskMemHandle privileges) { if (privileges == null || privileges.IsInvalid) { return; } uint retLen = 0; if (!AdjustTokenPrivileges(hObj, false, privileges, (uint)privileges.Size, SafeCoTaskMemHandle.Null, ref retLen)) { throw new Win32Exception(); } }
public void DhcpRequestParamsTest() { var sendParams = default(DHCPCAPI_PARAMS_ARRAY); using var pparam = new SafeCoTaskMemStruct <DHCPAPI_PARAMS>(new DHCPAPI_PARAMS { OptionId = DHCP_OPTION_ID.OPTION_SUBNET_MASK }); //using var pparam = new SafeCoTaskMemStruct<DHCPAPI_PARAMS>(new DHCPAPI_PARAMS { OptionId = DHCP_OPTION_ID.OPTION_HOST_NAME }); var reqParams = new DHCPCAPI_PARAMS_ARRAY { nParams = 1, Params = pparam }; uint sz = 1000; using var mem = new SafeCoTaskMemHandle(sz); Assert.That(DhcpRequestParams(DHCPCAPI_REQUEST.DHCPCAPI_REQUEST_SYNCHRONOUS, default, adp.Id, IntPtr.Zero, sendParams, reqParams, mem, ref sz, null), ResultIs.Successful);
static unsafe int Main() { HRESULT hr = HRESULT.S_OK; IntPtr[] rgParaEKU = { szOID_PKIX_KP_EMAIL_PROTECTION }; var EKUCriteria = new CERT_SELECT_CRITERIA { dwType = CertSelectBy.CERT_SELECT_BY_ENHKEY_USAGE, cPara = (uint)rgParaEKU.Length, }; fixed(IntPtr *pArr = rgParaEKU) EKUCriteria.ppPara = (IntPtr)(void *)pArr; var bDigSig = (byte)CertKeyUsage.CERT_DIGITAL_SIGNATURE_KEY_USAGE; // in byte 0 var pDigSig = &bDigSig; var extDigSig = new CERT_EXTENSION { Value = new CRYPTOAPI_BLOB { cbData = 1, pbData = (IntPtr)pDigSig } }; using var pExtDigSig = SafeCoTaskMemHandle.CreateFromStructure(extDigSig); IntPtr[] rgParaKU = { pExtDigSig }; var KUCriteria = new CERT_SELECT_CRITERIA { dwType = CertSelectBy.CERT_SELECT_BY_KEY_USAGE, cPara = (uint)rgParaKU.Length }; fixed(IntPtr *pArr = rgParaKU) KUCriteria.ppPara = (IntPtr)(void *)pArr; CERT_SELECT_CRITERIA[] rgCriteriaFilter = { EKUCriteria, KUCriteria }; using var hStore = CertOpenStore(CertStoreProvider.CERT_STORE_PROV_SYSTEM, 0, default, CertStoreFlags.CERT_SYSTEM_STORE_CURRENT_USER, "MY"); if (hStore.IsInvalid) { hr = (HRESULT)Win32Error.GetLastError(); goto CleanUp; } Console.Write("Looking for certificates in MY store ...\n"); if (!CertSelectCertificateChains(default, CertSelection.CERT_SELECT_TRUSTED_ROOT | CertSelection.CERT_SELECT_HAS_PRIVATE_KEY, default,
private SafeCoTaskMemHandle CreateHeifWriter() { var writerHandle = SafeCoTaskMemHandle.Allocate(MarshalHelper.SizeOf <heif_writer>()); unsafe { var writer = (heif_writer *)writerHandle.DangerousGetHandle(); writer->heif_writer_version = 1; writer->write = Marshal.GetFunctionPointerForDelegate(this.writeDelegate); } return(writerHandle); }
static int Main(string[] args) { if (args.Length != 1) { Console.Write("Usage: \n"); Console.Write("> regfs.exe <Virtualization Root Path> \n"); return(-1); } // args[1] should be the path to the virtualization root. string rootPath = args[0]; // Specify the notifications that we want ProjFS to send to us. Everywhere under the virtualization // root we want ProjFS to tell us when files have been opened, when they're about to be renamed, // and when they're about to be deleted. PRJ_NOTIFICATION_MAPPING[] notificationMappings = new[] { new PRJ_NOTIFICATION_MAPPING { NotificationRoot = "", NotificationBitMask = PRJ_NOTIFY_TYPES.PRJ_NOTIFY_FILE_OPENED | PRJ_NOTIFY_TYPES.PRJ_NOTIFY_PRE_RENAME | PRJ_NOTIFY_TYPES.PRJ_NOTIFY_PRE_DELETE } }; // Store the notification mapping we set up into a start options structure. We leave all the // other options at their defaults. using var mem = SafeCoTaskMemHandle.CreateFromList(notificationMappings); PRJ_STARTVIRTUALIZING_OPTIONS opts = new PRJ_STARTVIRTUALIZING_OPTIONS { NotificationMappings = mem, NotificationMappingsCount = 1 }; // Start the provider using the options we set up. RegfsProvider provider = new RegfsProvider(); var hr = provider.Start(rootPath, opts); if (hr.Failed) { Console.Write("Failed to start virtualization instance: 0x{0:X8}\n", hr); return(-1); } Console.Write("RegFS is running at virtualization root [{0}]\n", rootPath); Console.Write("Press Enter to stop the provider..."); Console.ReadKey(); provider.Stop(); return(0); }
public void WNetGetResourceParentTest() { uint sz = 1; var lnr = new NETRESOURCE(remSh + shDir, null, prov); var ptr = new SafeCoTaskMemHandle((int)sz); Assert.That(WNetGetResourceParent(lnr, (IntPtr)ptr, ref sz), Is.EqualTo(Win32Error.ERROR_MORE_DATA)); ptr.Size = (int)sz; WNetGetResourceParent(lnr, (IntPtr)ptr, ref sz).ThrowIfFailed(); var nrp = ptr.ToStructure <NETRESOURCE>(); Assert.That((int)nrp.dwUsage, Is.Not.Zero); Assert.That(nrp.lpRemoteName, Is.EqualTo(remSh)); }
public WriterErrors() { this.successMessage = null; this.writeErrorMessage = null; try { this.successMessage = SafeCoTaskMemHandle.FromStringAnsi("Success"); this.writeErrorMessage = SafeCoTaskMemHandle.FromStringAnsi("Write error"); } catch (Exception) { DisposableUtil.Free(ref this.successMessage); throw; } }
public void WNetGetResourceInformationTest() { uint sz = 1; var lnr = new NETRESOURCE(remSh + shDir); var ptr = new SafeCoTaskMemHandle((int)sz); Assert.That(WNetGetResourceInformation(lnr, (IntPtr)ptr, ref sz, out var _), Is.EqualTo(Win32Error.ERROR_MORE_DATA)); ptr.Size = (int)sz; WNetGetResourceInformation(lnr, (IntPtr)ptr, ref sz, out var sys).ThrowIfFailed(); var rnr = ptr.ToStructure <NETRESOURCE>(); Assert.That((int)rnr.dwUsage, Is.Not.Zero); Assert.That(rnr.lpRemoteName, Is.EqualTo(remSh)); Assert.That(sys, Is.Not.EqualTo(IntPtr.Zero)); }