sean-m
/
Vanara
mirror of https://github.com/dahall/Vanara.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Fixed overloads for HttpQueryInfo

pull/328/head
dahall 2022-07-16 08:27:54 -06:00
parent 20bd7a40e1
commit 4c4657f0ab
2 changed files with 480 additions and 510 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
PInvoke/WinINet/WinINet.cs
View File

@ -5053,8 +5053,10 @@ namespace Vanara.PInvoke
// DWORD_PTR dwContext );
[DllImport(Lib.WinInet, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("wininet.h", MSDNShortId = "caaff8e8-7db9-4d6d-8ba2-d8d19475173a")]
public static extern SafeHINTERNET HttpOpenRequest(HINTERNET hConnect, [Optional] string lpszVerb, string lpszObjectName, [Optional] string lpszVersion, [Optional] string lpszReferrer,
[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StringPtrArrayMarshaler), MarshalCookie = "Auto"), Optional] string[] lplpszAcceptTypes, [Optional] INTERNET_FLAG dwFlags, [Optional] IntPtr dwContext);
public static extern SafeHINTERNET HttpOpenRequest(HINTERNET hConnect, string lpszVerb = null, string lpszObjectName = "/",
string lpszVersion = null, string lpszReferrer = null,
[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StringPtrArrayMarshaler), MarshalCookie = "Auto")] string[] lplpszAcceptTypes = null,
INTERNET_FLAG dwFlags = 0, IntPtr dwContext = default);
/// <summary>Retrieves header information associated with an HTTP request.</summary>
/// <param name="hRequest">A handle returned by a call to the HttpOpenRequest or InternetOpenUrl function.</param>

162
UnitTests/PInvoke/WinINet/WinInetTests.cs
View File

@ -5,11 +5,13 @@ using System.Linq;
using System.Text;
using Vanara.Extensions;
using Vanara.InteropServices;
using Vanara.PInvoke;
using Vanara.PInvoke.Tests;
using static Vanara.PInvoke.WinINet;
namespace Vanara.PInvoke.Tests
{
[TestFixture()]
namespace WinINet;
[TestFixture]
public class WinInetTests
{
private const string exturl = "https://microsoft.com";
@ -27,8 +29,8 @@ namespace Vanara.PInvoke.Tests
[Test]
public void CreateUrlCacheContainerTest()
{
var icci = INTERNET_CACHE_CONFIG_INFO.Default;
var flags = CACHE_CONFIG_FC.CACHE_CONFIG_CONTENT_PATHS_FC | CACHE_CONFIG_FC.CACHE_CONFIG_COOKIES_PATHS_FC | CACHE_CONFIG_FC.CACHE_CONFIG_HISTORY_PATHS_FC |
INTERNET_CACHE_CONFIG_INFO icci = INTERNET_CACHE_CONFIG_INFO.Default;
CACHE_CONFIG_FC flags = CACHE_CONFIG_FC.CACHE_CONFIG_CONTENT_PATHS_FC | CACHE_CONFIG_FC.CACHE_CONFIG_COOKIES_PATHS_FC | CACHE_CONFIG_FC.CACHE_CONFIG_HISTORY_PATHS_FC |
CACHE_CONFIG_FC.CACHE_CONFIG_QUOTA_FC | CACHE_CONFIG_FC.CACHE_CONFIG_STICKY_CONTENT_USAGE_FC;
Assert.That(GetUrlCacheConfigInfo(ref icci, default, flags), ResultIs.Successful);
icci.WriteValues();
@ -41,24 +43,22 @@ namespace Vanara.PInvoke.Tests
[Test]
public void CreateUrlCacheEntryTest()
{
using (var tmp = new TempFile())
{
using var tmp = new TempFile();
var url = "temp://" + Guid.NewGuid().ToString("N");
var sb = new StringBuilder(512);
Assert.That(CreateUrlCacheEntry(url, 0, "tmp", sb), ResultIs.Successful);
try
{
System.IO.File.Copy(tmp.FullName, sb.ToString(), true);
File.Copy(tmp.FullName, sb.ToString(), true);
Assert.That(CommitUrlCacheEntry(url, sb.ToString()), ResultIs.Successful);
Assert.That(FindUrlCacheEntries().Where(e => e.lpszSourceUrlName == url), Is.Not.Empty);
using (var mem = new SafeHGlobalHandle(4096))
{
using var mem = new SafeHGlobalHandle(4096);
uint sz = mem.Size;
Assert.That(GetUrlCacheEntryInfo(url, mem, ref sz), ResultIs.Successful);
var ei = mem.ToStructure<INTERNET_CACHE_ENTRY_INFO>();
INTERNET_CACHE_ENTRY_INFO ei = mem.ToStructure<INTERNET_CACHE_ENTRY_INFO>();
new INTERNET_CACHE_ENTRY_INFO_MGD(ei).WriteValues();
ei.LastModifiedTime = DateTime.Now.ToFileTimeStruct();
@ -72,20 +72,16 @@ namespace Vanara.PInvoke.Tests
Assert.That(RetrieveUrlCacheEntryStream(url, default, ref sz, false), ResultIs.Not.ValidHandle);
using (var infomem = new SafeHGlobalHandle(sz))
{
using (var hStr = RetrieveUrlCacheEntryStream(url, infomem, ref sz, false))
{
using SafeHCACHEENTRYSTREAM hStr = RetrieveUrlCacheEntryStream(url, infomem, ref sz, false);
Assert.That(hStr, ResultIs.ValidHandle);
var info = new INTERNET_CACHE_ENTRY_INFO_MGD(infomem.ToStructure<INTERNET_CACHE_ENTRY_INFO>());
info.WriteValues();
using (var buf = new SafeHGlobalHandle(info.dwSize))
{
using var buf = new SafeHGlobalHandle(info.dwSize);
uint bufSz = buf.Size;
Assert.That(ReadUrlCacheEntryStream(hStr, 0, buf, ref bufSz), ResultIs.Successful);
TestContext.WriteLine(buf.DangerousGetHandle().ToHexDumpString(buf.Size));
}
}
}
sz = 0;
Assert.That(RetrieveUrlCacheEntryFile(url, default, ref sz), ResultIs.Failure);
@ -96,13 +92,11 @@ namespace Vanara.PInvoke.Tests
Assert.That(UnlockUrlCacheEntryFile(url), ResultIs.Successful);
}
}
}
finally
{
Assert.That(DeleteUrlCacheEntry(url), ResultIs.Successful);
}
}
}
[Test]
public void CreateUrlCacheGroupTest()
@ -131,13 +125,11 @@ namespace Vanara.PInvoke.Tests
public void FtpCommandTest(string host, string ip, string user, string domain, string pwd)
{
Assert.That(hOpen, ResultIs.ValidHandle);
using (var hCon = InternetConnect(hOpen, ip, INTERNET_PORT.INTERNET_DEFAULT_FTP_PORT, user, pwd, InternetService.INTERNET_SERVICE_FTP, InternetApiFlags.INTERNET_FLAG_PASSIVE))
{
using SafeHINTERNET hCon = InternetConnect(hOpen, ip, INTERNET_PORT.INTERNET_DEFAULT_FTP_PORT, user, pwd, InternetService.INTERNET_SERVICE_FTP, InternetApiFlags.INTERNET_FLAG_PASSIVE);
Assert.That(hCon, ResultIs.ValidHandle);
Assert.That(FtpCommand(hCon, true, FTP_TRANSER_TYPE.FTP_TRANSER_TYPE_BINARY, "SYST", default, out var hFtp), ResultIs.Successful);
Assert.That(FtpCommand(hCon, true, FTP_TRANSER_TYPE.FTP_TRANSER_TYPE_BINARY, "SYST", default, out SafeHINTERNET hFtp), ResultIs.Successful);
hFtp.Dispose();
}
}
[TestCaseSource(typeof(TestCaseSources), nameof(TestCaseSources.RemoteConnections), new object[] { true, 0b00111 })]
public void FtpTest(string host, string ip, string user, string domain, string pwd)
@ -149,8 +141,7 @@ namespace Vanara.PInvoke.Tests
try
{
Assert.That(hOpen, ResultIs.ValidHandle);
using (var hCon = InternetConnect(hOpen, ip, INTERNET_PORT.INTERNET_DEFAULT_FTP_PORT, user, pwd, InternetService.INTERNET_SERVICE_FTP, InternetApiFlags.INTERNET_FLAG_PASSIVE))
{
using SafeHINTERNET hCon = InternetConnect(hOpen, ip, INTERNET_PORT.INTERNET_DEFAULT_FTP_PORT, user, pwd, InternetService.INTERNET_SERVICE_FTP, InternetApiFlags.INTERNET_FLAG_PASSIVE);
Assert.That(hCon, ResultIs.ValidHandle);
var sb = new StringBuilder(1024);
@ -159,13 +150,13 @@ namespace Vanara.PInvoke.Tests
Assert.That(FtpCreateDirectory(hCon, dirName), ResultIs.Successful);
Assert.That(FtpSetCurrentDirectory(hCon, dirName), ResultIs.Successful);
Assert.That(FtpPutFile(hCon, TestCaseSources.SmallFile, System.IO.Path.GetFileName(TestCaseSources.SmallFile), INTERNET_FLAG.INTERNET_FLAG_TRANSFER_BINARY), ResultIs.Successful);
var hFile = SafeHINTERNET.Null;
Assert.That(hFile = FtpFindFirstFile(hCon, System.IO.Path.GetFileName(TestCaseSources.SmallFile), out var fd, 0), ResultIs.ValidHandle);
Assert.That(FtpPutFile(hCon, TestCaseSources.SmallFile, Path.GetFileName(TestCaseSources.SmallFile), INTERNET_FLAG.INTERNET_FLAG_TRANSFER_BINARY), ResultIs.Successful);
SafeHINTERNET hFile = SafeHINTERNET.Null;
Assert.That(hFile = FtpFindFirstFile(hCon, Path.GetFileName(TestCaseSources.SmallFile), out WIN32_FIND_DATA fd, 0), ResultIs.ValidHandle);
Assert.That(InternetFindNextFile(hFile, out fd), ResultIs.Failure);
hFile.Dispose();
Assert.That(hFile = FtpOpenFile(hCon, System.IO.Path.GetFileName(TestCaseSources.SmallFile), ACCESS_MASK.GENERIC_READ, FTP_TRANSER_TYPE.FTP_TRANSER_TYPE_BINARY), ResultIs.ValidHandle);
Assert.That(hFile = FtpOpenFile(hCon, Path.GetFileName(TestCaseSources.SmallFile), ACCESS_MASK.GENERIC_READ, FTP_TRANSER_TYPE.FTP_TRANSER_TYPE_BINARY), ResultIs.ValidHandle);
uint low;
Assert.That(low = FtpGetFileSize(hFile, out var high), ResultIs.Not.Value(0U));
@ -182,60 +173,48 @@ namespace Vanara.PInvoke.Tests
Assert.That(FtpSetCurrentDirectory(hCon, sb.ToString()), ResultIs.Successful);
Assert.That(FtpRemoveDirectory(hCon, dirName), ResultIs.Successful);
}
}
finally
{
InternetSetStatusCallback(hOpen, null);
}
void Callback(HINTERNET hInternet, IntPtr dwContext, InternetStatus dwInternetStatus, IntPtr lpvStatusInformation, uint dwStatusInformationLength)
{
System.Diagnostics.Debug.WriteLine(dwInternetStatus);
}
static void Callback(HINTERNET hInternet, IntPtr dwContext, InternetStatus dwInternetStatus, IntPtr lpvStatusInformation, uint dwStatusInformationLength) => System.Diagnostics.Debug.WriteLine(dwInternetStatus);
}
[Test]
public void HttpSendRequestExTest()
{
using (var hCon = InternetConnect(hOpen, host, dwService: InternetService.INTERNET_SERVICE_HTTP))
{
using SafeHINTERNET hCon = InternetConnect(hOpen, "microsoft.com", dwService: InternetService.INTERNET_SERVICE_HTTP);
Assert.That(hCon, ResultIs.ValidHandle);
using (var hReq = HttpOpenRequest(hCon, null, "", null, ""))
{
using SafeHINTERNET hReq = HttpOpenRequest(hCon);
Assert.That(hReq, ResultIs.ValidHandle);
var ibuf = INTERNET_BUFFERS.Default;
INTERNET_BUFFERS ibuf = INTERNET_BUFFERS.Default;
ibuf.dwBufferTotal = 4096;
Assert.That(HttpSendRequestEx(hReq, ibuf, dwContext: new IntPtr(1)), ResultIs.Successful);
Assert.That(HttpEndRequest(hReq), ResultIs.Successful);
}
}
}
[Test]
public void HttpSendRequestTest()
{
using (var hCon = InternetConnect(hOpen, host, dwService: InternetService.INTERNET_SERVICE_HTTP))
{
using SafeHINTERNET hCon = InternetConnect(hOpen, "microsoft.com", dwService: InternetService.INTERNET_SERVICE_HTTP);
Assert.That(hCon, ResultIs.ValidHandle);
using (var hReq = HttpOpenRequest(hCon, null, "", null, ""))
{
using SafeHINTERNET hReq = HttpOpenRequest(hCon);
Assert.That(hReq, ResultIs.ValidHandle);
Assert.That(HttpAddRequestHeaders(hReq, "Accept: text/html, application/xhtml+xml, */*\r\n", -1, HTTP_ADDREQ_FLAG.HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG.HTTP_ADDREQ_FLAG_REPLACE), ResultIs.Successful);
Assert.That(HttpSendRequest(hReq), ResultIs.Successful);
foreach (var e in Enum.GetValues(typeof(HTTP_QUERY)).OfType<HTTP_QUERY>().Where(v => (int)v < 0x10000000))
foreach (HTTP_QUERY e in Enum.GetValues(typeof(HTTP_QUERY)).OfType<HTTP_QUERY>().Where(v => (int)v < 0x10000000))
{
uint idx = 0;
try
{
var mem = HttpQueryInfo(hReq, e, ref idx);
TestContext.WriteLine($"{e} = {HttpQueryInfo<string>(hReq, e, ref idx)}");
TestContext.WriteLine($"{e} = {HttpQueryInfo<string>(hReq, e)}");
}
catch (Exception ex)
{
@ -243,18 +222,26 @@ namespace Vanara.PInvoke.Tests
}
}
Assert.That(InternetSetFilePointer(hReq, 0, 0, SeekOrigin.Begin), ResultIs.Successful);
using (var mem = new SafeHGlobalHandle(1024))
TestContext.WriteLine("HTTP_QUERY_CUSTOM | HTTP_QUERY_FLAG_REQUEST_HEADERS Output\n===================");
uint idx = 0;
while (true)
{
try
{
TestContext.WriteLine(HttpQueryInfo<string>(hReq, HTTP_QUERY.HTTP_QUERY_CUSTOM | HTTP_QUERY.HTTP_QUERY_FLAG_REQUEST_HEADERS, ref idx));
}
catch { break; }
}
//Assert.That(InternetSetFilePointer(hReq, 0, 0, SeekOrigin.Begin), ResultIs.Value(0U));
using var mem = new SafeHGlobalHandle(1024);
Assert.That(InternetReadFile(hReq, mem, mem.Size, out var read), ResultIs.Successful);
}
}
TestContext.WriteLine($"Read {read} bytes: ");
TestContext.WriteLine(HexDempHelpers.ToHexDumpString(mem.DangerousGetHandle(), (int)read));
}
[Test]
public void InternetAttemptConnectTest()
{
Assert.That(InternetAttemptConnect(), ResultIs.Successful);
}
public void InternetAttemptConnectTest() => Assert.That(InternetAttemptConnect(), ResultIs.Successful);
[Test]
public void InternetAutodialTest()
@ -280,21 +267,15 @@ namespace Vanara.PInvoke.Tests
}
[Test]
public void InternetClearAllPerSiteCookieDecisionsTest()
{
Assert.That(InternetClearAllPerSiteCookieDecisions(), ResultIs.Successful);
}
public void InternetClearAllPerSiteCookieDecisionsTest() => Assert.That(InternetClearAllPerSiteCookieDecisions(), ResultIs.Successful);
[Test]
public void InternetConfirmZoneCrossingTest()
{
Assert.That(InternetConfirmZoneCrossing(HWND.NULL, url, "http://microsoft.com"), ResultIs.Successful);
}
public void InternetConfirmZoneCrossingTest() => Assert.That(InternetConfirmZoneCrossing(HWND.NULL, url, "http://microsoft.com"), ResultIs.Successful);
[Test]
public void InternetConnectTest()
{
using (var hCon = InternetConnect(hOpen, host, dwService: InternetService.INTERNET_SERVICE_HTTP))
using SafeHINTERNET hCon = InternetConnect(hOpen, host, dwService: InternetService.INTERNET_SERVICE_HTTP);
Assert.That(hCon, ResultIs.ValidHandle);
}
@ -329,7 +310,7 @@ namespace Vanara.PInvoke.Tests
public void InternetEnumPerSiteCookieDecisionTest()
{
Assert.That(InternetSetPerSiteCookieDecision("hpe.com", InternetCookieState.COOKIE_STATE_ACCEPT), ResultIs.Successful);
Assert.That(InternetGetPerSiteCookieDecision("hpe.com", out var state), ResultIs.Successful);
Assert.That(InternetGetPerSiteCookieDecision("hpe.com", out InternetCookieState state), ResultIs.Successful);
Assert.That(state, Is.EqualTo(InternetCookieState.COOKIE_STATE_ACCEPT));
var sb = new StringBuilder(1024);
@ -337,7 +318,7 @@ namespace Vanara.PInvoke.Tests
do
{
var sz = (uint)sb.Capacity;
if (!InternetEnumPerSiteCookieDecision(sb, ref sz, out var dec, i))
if (!InternetEnumPerSiteCookieDecision(sb, ref sz, out InternetCookieState dec, i))
Assert.That(Win32Error.GetLastError(), Is.EqualTo((Win32Error)Win32Error.ERROR_NO_MORE_ITEMS));
TestContext.Write($"{i}: {sb}; {dec}");
} while (i++ < 50);
@ -346,31 +327,27 @@ namespace Vanara.PInvoke.Tests
[Test]
public void InternetErrorDlgTest()
{
using (var hCon = InternetConnect(hOpen, host, dwService: InternetService.INTERNET_SERVICE_HTTP))
{
using SafeHINTERNET hCon = InternetConnect(hOpen, host, dwService: InternetService.INTERNET_SERVICE_HTTP);
Assert.That(hCon, ResultIs.ValidHandle);
using (var hReq = HttpOpenRequest(hCon, null, "", null, ""))
{
using SafeHINTERNET hReq = HttpOpenRequest(hCon);
Assert.That(hReq, ResultIs.ValidHandle);
Assert.That(HttpSendRequest(hReq), ResultIs.Successful);
Assert.That(InternetErrorDlg(HWND.NULL, hReq, Win32Error.ERROR_INTERNET_INCORRECT_PASSWORD, FLAGS_ERROR_UI.FLAGS_ERROR_UI_FLAGS_NO_UI, IntPtr.Zero), ResultIs.Successful);
}
}
}
[Test]
public void InternetGetConnectedStateExTest()
{
var sb = new StringBuilder(1024);
Assert.That(InternetGetConnectedStateEx(out var flags, sb, (uint)sb.Capacity), ResultIs.Successful);
Assert.That(InternetGetConnectedStateEx(out INTERNET_CONNECTION flags, sb, (uint)sb.Capacity), ResultIs.Successful);
TestContext.Write($"{flags}; {sb}");
}
[Test]
public void InternetGetConnectedStateTest()
{
Assert.That(InternetGetConnectedState(out var flags), ResultIs.Successful);
Assert.That(InternetGetConnectedState(out INTERNET_CONNECTION flags), ResultIs.Successful);
TestContext.Write(flags);
}
@ -399,47 +376,39 @@ namespace Vanara.PInvoke.Tests
{
var sb = new StringBuilder(1024);
var sz = (uint)sb.Capacity;
Assert.That(InternetGetLastResponseInfo(out var err, sb, ref sz), ResultIs.Successful);
Assert.That(InternetGetLastResponseInfo(out _, sb, ref sz), ResultIs.Successful);
}
[Test]
public void InternetGoOnlineTest()
{
Assert.That(InternetGoOnline(url, HWND.NULL), ResultIs.Successful);
}
public void InternetGoOnlineTest() => Assert.That(InternetGoOnline(url, HWND.NULL), ResultIs.Successful);
[Test]
public void InternetInitializeAutoProxyDllTest()
{
Assert.That(InternetInitializeAutoProxyDll(), ResultIs.Successful);
}
public void InternetInitializeAutoProxyDllTest() => Assert.That(InternetInitializeAutoProxyDll(), ResultIs.Successful);
[Test]
public void InternetLockRequestFileTest()
{
using (var hFile = InternetOpenUrl(hOpen, url, null, 0, 0))
{
using SafeHINTERNET hFile = InternetOpenUrl(hOpen, url, null, 0, 0);
Assert.That(hFile, ResultIs.ValidHandle);
Assert.That(InternetQueryDataAvailable(hFile, out var num), ResultIs.Successful);
TestContext.Write(num);
Assert.That(InternetLockRequestFile(hFile, out var hLock), ResultIs.Successful);
Assert.That(InternetLockRequestFile(hFile, out HANDLE hLock), ResultIs.Successful);
using (var mem = new SafeHGlobalHandle(1024))
{
var ib = INTERNET_BUFFERS.Default;
INTERNET_BUFFERS ib = INTERNET_BUFFERS.Default;
ib.dwBufferLength = mem.Size;
ib.lpvBuffer = mem;
Assert.That(InternetReadFileEx(hFile, ref ib, IRF.IRF_SYNC), ResultIs.Successful);
}
Assert.That(InternetUnlockRequestFile(hLock), ResultIs.Successful);
}
}
[Test()]
public void InternetOpenTest()
{
var hOpen2 = InternetOpen("Test", InternetOpenType.INTERNET_OPEN_TYPE_DIRECT, null, null, 0);
SafeHINTERNET hOpen2 = InternetOpen("Test", InternetOpenType.INTERNET_OPEN_TYPE_DIRECT, null, null, 0);
Assert.That(hOpen2, ResultIs.ValidHandle);
hOpen2.Dispose();
Assert.That(hOpen2.IsInvalid, Is.True);
@ -473,11 +442,11 @@ namespace Vanara.PInvoke.Tests
Assert.That(() => InternetQueryOption<IntPtr>(hOpen, InternetOptionFlags.INTERNET_OPTION_CACHE_STREAM_HANDLE), Throws.Exception);
var ver = InternetQueryOption<INTERNET_VERSION_INFO>(hOpen, InternetOptionFlags.INTERNET_OPTION_VERSION);
INTERNET_VERSION_INFO ver = InternetQueryOption<INTERNET_VERSION_INFO>(hOpen, InternetOptionFlags.INTERNET_OPTION_VERSION);
Assert.That(ver.dwMajorVersion, Is.Not.Zero);
TestContext.WriteLine($"Ver is {ver.dwMajorVersion}.{ver.dwMinorVersion}");
var pi = InternetQueryOption<INTERNET_PROXY_INFO>(HINTERNET.NULL, InternetOptionFlags.INTERNET_OPTION_PROXY);
INTERNET_PROXY_INFO pi = InternetQueryOption<INTERNET_PROXY_INFO>(HINTERNET.NULL, InternetOptionFlags.INTERNET_OPTION_PROXY);
Assert.That(pi.dwAccessType, Is.Not.Zero);
TestContext.WriteLine($"Proxy is {pi.dwAccessType}={pi.lpszProxy}");
}
@ -507,7 +476,7 @@ namespace Vanara.PInvoke.Tests
var st = new SYSTEMTIME(DateTime.Now, DateTimeKind.Local);
var sb = new StringBuilder(1024);
Assert.That(InternetTimeFromSystemTime(st, INTERNET_RFC.INTERNET_RFC1123_FORMAT, sb, (uint)sb.Capacity), ResultIs.Successful);
Assert.That(InternetTimeToSystemTime(sb.ToString(), out var st2), ResultIs.Successful);
Assert.That(InternetTimeToSystemTime(sb.ToString(), out SYSTEMTIME st2), ResultIs.Successful);
Assert.That(st.Equals(st2), Is.True);
}
@ -520,11 +489,11 @@ namespace Vanara.PInvoke.Tests
string pref = null;
var sb = new StringBuilder(1024);
foreach (var e in Enum.GetValues(typeof(URLZONE)).Cast<URLZONE>())
foreach (URLZONE e in Enum.GetValues(typeof(URLZONE)).Cast<URLZONE>())
{
var sz = (uint)sb.Capacity;
//Assert.That(PrivacyGetZonePreferenceW(e, priv, out var tmpl, sb, ref sz), ResultIs.Successful);
if (PrivacyGetZonePreferenceW(e, priv, out var tmpl, sb, ref sz).Succeeded)
if (PrivacyGetZonePreferenceW(e, priv, out PrivacyTemplate tmpl, sb, ref sz).Succeeded)
TestContext.WriteLine($"{e} : {tmpl} : {sb}");
if (e == zone) { pref = sb.ToString(); iTmpl = tmpl; }
}
@ -532,4 +501,3 @@ namespace Vanara.PInvoke.Tests
Assert.That(PrivacySetZonePreferenceW(zone, priv, iTmpl, pref), ResultIs.Successful);
}
}
}