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 ); // DWORD_PTR dwContext );
[DllImport(Lib.WinInet, SetLastError = true, CharSet = CharSet.Auto)] [DllImport(Lib.WinInet, SetLastError = true, CharSet = CharSet.Auto)]
[PInvokeData("wininet.h", MSDNShortId = "caaff8e8-7db9-4d6d-8ba2-d8d19475173a")] [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, public static extern SafeHINTERNET HttpOpenRequest(HINTERNET hConnect, string lpszVerb = null, string lpszObjectName = "/",
[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(StringPtrArrayMarshaler), MarshalCookie = "Auto"), Optional] string[] lplpszAcceptTypes, [Optional] INTERNET_FLAG dwFlags, [Optional] IntPtr dwContext); 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> /// <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> /// <param name="hRequest">A handle returned by a call to the HttpOpenRequest or InternetOpenUrl function.</param>

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

@ -5,13 +5,15 @@ using System.Linq;
using System.Text; using System.Text;
using Vanara.Extensions; using Vanara.Extensions;
using Vanara.InteropServices; using Vanara.InteropServices;
using Vanara.PInvoke;
using Vanara.PInvoke.Tests;
using static Vanara.PInvoke.WinINet; using static Vanara.PInvoke.WinINet;
namespace Vanara.PInvoke.Tests namespace WinINet;
[TestFixture]
public class WinInetTests
{ {
[TestFixture()]
public class WinInetTests
{
private const string exturl = "https://microsoft.com"; private const string exturl = "https://microsoft.com";
private const string host = "localhost"; private const string host = "localhost";
private const string url = "http://" + host; private const string url = "http://" + host;
@ -27,8 +29,8 @@ namespace Vanara.PInvoke.Tests
[Test] [Test]
public void CreateUrlCacheContainerTest() public void CreateUrlCacheContainerTest()
{ {
var icci = INTERNET_CACHE_CONFIG_INFO.Default; INTERNET_CACHE_CONFIG_INFO 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 | 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; 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); Assert.That(GetUrlCacheConfigInfo(ref icci, default, flags), ResultIs.Successful);
icci.WriteValues(); icci.WriteValues();
@ -41,24 +43,22 @@ namespace Vanara.PInvoke.Tests
[Test] [Test]
public void CreateUrlCacheEntryTest() public void CreateUrlCacheEntryTest()
{ {
using (var tmp = new TempFile()) using var tmp = new TempFile();
{
var url = "temp://" + Guid.NewGuid().ToString("N"); var url = "temp://" + Guid.NewGuid().ToString("N");
var sb = new StringBuilder(512); var sb = new StringBuilder(512);
Assert.That(CreateUrlCacheEntry(url, 0, "tmp", sb), ResultIs.Successful); Assert.That(CreateUrlCacheEntry(url, 0, "tmp", sb), ResultIs.Successful);
try 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(CommitUrlCacheEntry(url, sb.ToString()), ResultIs.Successful);
Assert.That(FindUrlCacheEntries().Where(e => e.lpszSourceUrlName == url), Is.Not.Empty); 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; uint sz = mem.Size;
Assert.That(GetUrlCacheEntryInfo(url, mem, ref sz), ResultIs.Successful); 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(); new INTERNET_CACHE_ENTRY_INFO_MGD(ei).WriteValues();
ei.LastModifiedTime = DateTime.Now.ToFileTimeStruct(); ei.LastModifiedTime = DateTime.Now.ToFileTimeStruct();
@ -72,20 +72,16 @@ namespace Vanara.PInvoke.Tests
Assert.That(RetrieveUrlCacheEntryStream(url, default, ref sz, false), ResultIs.Not.ValidHandle); Assert.That(RetrieveUrlCacheEntryStream(url, default, ref sz, false), ResultIs.Not.ValidHandle);
using (var infomem = new SafeHGlobalHandle(sz)) 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); Assert.That(hStr, ResultIs.ValidHandle);
var info = new INTERNET_CACHE_ENTRY_INFO_MGD(infomem.ToStructure<INTERNET_CACHE_ENTRY_INFO>()); var info = new INTERNET_CACHE_ENTRY_INFO_MGD(infomem.ToStructure<INTERNET_CACHE_ENTRY_INFO>());
info.WriteValues(); info.WriteValues();
using (var buf = new SafeHGlobalHandle(info.dwSize)) using var buf = new SafeHGlobalHandle(info.dwSize);
{
uint bufSz = buf.Size; uint bufSz = buf.Size;
Assert.That(ReadUrlCacheEntryStream(hStr, 0, buf, ref bufSz), ResultIs.Successful); Assert.That(ReadUrlCacheEntryStream(hStr, 0, buf, ref bufSz), ResultIs.Successful);
TestContext.WriteLine(buf.DangerousGetHandle().ToHexDumpString(buf.Size)); TestContext.WriteLine(buf.DangerousGetHandle().ToHexDumpString(buf.Size));
} }
}
}
sz = 0; sz = 0;
Assert.That(RetrieveUrlCacheEntryFile(url, default, ref sz), ResultIs.Failure); Assert.That(RetrieveUrlCacheEntryFile(url, default, ref sz), ResultIs.Failure);
@ -96,13 +92,11 @@ namespace Vanara.PInvoke.Tests
Assert.That(UnlockUrlCacheEntryFile(url), ResultIs.Successful); Assert.That(UnlockUrlCacheEntryFile(url), ResultIs.Successful);
} }
} }
}
finally finally
{ {
Assert.That(DeleteUrlCacheEntry(url), ResultIs.Successful); Assert.That(DeleteUrlCacheEntry(url), ResultIs.Successful);
} }
} }
}
[Test] [Test]
public void CreateUrlCacheGroupTest() public void CreateUrlCacheGroupTest()
@ -131,13 +125,11 @@ namespace Vanara.PInvoke.Tests
public void FtpCommandTest(string host, string ip, string user, string domain, string pwd) public void FtpCommandTest(string host, string ip, string user, string domain, string pwd)
{ {
Assert.That(hOpen, ResultIs.ValidHandle); 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(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(); hFtp.Dispose();
} }
}
[TestCaseSource(typeof(TestCaseSources), nameof(TestCaseSources.RemoteConnections), new object[] { true, 0b00111 })] [TestCaseSource(typeof(TestCaseSources), nameof(TestCaseSources.RemoteConnections), new object[] { true, 0b00111 })]
public void FtpTest(string host, string ip, string user, string domain, string pwd) public void FtpTest(string host, string ip, string user, string domain, string pwd)
@ -149,8 +141,7 @@ namespace Vanara.PInvoke.Tests
try try
{ {
Assert.That(hOpen, ResultIs.ValidHandle); 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(hCon, ResultIs.ValidHandle);
var sb = new StringBuilder(1024); var sb = new StringBuilder(1024);
@ -159,13 +150,13 @@ namespace Vanara.PInvoke.Tests
Assert.That(FtpCreateDirectory(hCon, dirName), ResultIs.Successful); Assert.That(FtpCreateDirectory(hCon, dirName), ResultIs.Successful);
Assert.That(FtpSetCurrentDirectory(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); Assert.That(FtpPutFile(hCon, TestCaseSources.SmallFile, Path.GetFileName(TestCaseSources.SmallFile), INTERNET_FLAG.INTERNET_FLAG_TRANSFER_BINARY), ResultIs.Successful);
var hFile = SafeHINTERNET.Null; SafeHINTERNET hFile = SafeHINTERNET.Null;
Assert.That(hFile = FtpFindFirstFile(hCon, System.IO.Path.GetFileName(TestCaseSources.SmallFile), out var fd, 0), ResultIs.ValidHandle); 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); Assert.That(InternetFindNextFile(hFile, out fd), ResultIs.Failure);
hFile.Dispose(); 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; uint low;
Assert.That(low = FtpGetFileSize(hFile, out var high), ResultIs.Not.Value(0U)); 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(FtpSetCurrentDirectory(hCon, sb.ToString()), ResultIs.Successful);
Assert.That(FtpRemoveDirectory(hCon, dirName), ResultIs.Successful); Assert.That(FtpRemoveDirectory(hCon, dirName), ResultIs.Successful);
} }
}
finally finally
{ {
InternetSetStatusCallback(hOpen, null); InternetSetStatusCallback(hOpen, null);
} }
void Callback(HINTERNET hInternet, IntPtr dwContext, InternetStatus dwInternetStatus, IntPtr lpvStatusInformation, uint dwStatusInformationLength) static void Callback(HINTERNET hInternet, IntPtr dwContext, InternetStatus dwInternetStatus, IntPtr lpvStatusInformation, uint dwStatusInformationLength) => System.Diagnostics.Debug.WriteLine(dwInternetStatus);
{
System.Diagnostics.Debug.WriteLine(dwInternetStatus);
}
} }
[Test] [Test]
public void HttpSendRequestExTest() 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); Assert.That(hCon, ResultIs.ValidHandle);
using (var hReq = HttpOpenRequest(hCon, null, "", null, "")) using SafeHINTERNET hReq = HttpOpenRequest(hCon);
{
Assert.That(hReq, ResultIs.ValidHandle); Assert.That(hReq, ResultIs.ValidHandle);
var ibuf = INTERNET_BUFFERS.Default; INTERNET_BUFFERS ibuf = INTERNET_BUFFERS.Default;
ibuf.dwBufferTotal = 4096; ibuf.dwBufferTotal = 4096;
Assert.That(HttpSendRequestEx(hReq, ibuf, dwContext: new IntPtr(1)), ResultIs.Successful); Assert.That(HttpSendRequestEx(hReq, ibuf, dwContext: new IntPtr(1)), ResultIs.Successful);
Assert.That(HttpEndRequest(hReq), ResultIs.Successful); Assert.That(HttpEndRequest(hReq), ResultIs.Successful);
} }
}
}
[Test] [Test]
public void HttpSendRequestTest() 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); Assert.That(hCon, ResultIs.ValidHandle);
using (var hReq = HttpOpenRequest(hCon, null, "", null, "")) using SafeHINTERNET hReq = HttpOpenRequest(hCon);
{
Assert.That(hReq, ResultIs.ValidHandle); 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(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); 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 try
{ {
var mem = HttpQueryInfo(hReq, e, ref idx); TestContext.WriteLine($"{e} = {HttpQueryInfo<string>(hReq, e)}");
TestContext.WriteLine($"{e} = {HttpQueryInfo<string>(hReq, e, ref idx)}");
} }
catch (Exception ex) catch (Exception ex)
{ {
@ -243,18 +222,26 @@ namespace Vanara.PInvoke.Tests
} }
} }
Assert.That(InternetSetFilePointer(hReq, 0, 0, SeekOrigin.Begin), ResultIs.Successful); TestContext.WriteLine("HTTP_QUERY_CUSTOM | HTTP_QUERY_FLAG_REQUEST_HEADERS Output\n===================");
using (var mem = new SafeHGlobalHandle(1024)) 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); 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] [Test]
public void InternetAttemptConnectTest() public void InternetAttemptConnectTest() => Assert.That(InternetAttemptConnect(), ResultIs.Successful);
{
Assert.That(InternetAttemptConnect(), ResultIs.Successful);
}
[Test] [Test]
public void InternetAutodialTest() public void InternetAutodialTest()
@ -280,21 +267,15 @@ namespace Vanara.PInvoke.Tests
} }
[Test] [Test]
public void InternetClearAllPerSiteCookieDecisionsTest() public void InternetClearAllPerSiteCookieDecisionsTest() => Assert.That(InternetClearAllPerSiteCookieDecisions(), ResultIs.Successful);
{
Assert.That(InternetClearAllPerSiteCookieDecisions(), ResultIs.Successful);
}
[Test] [Test]
public void InternetConfirmZoneCrossingTest() public void InternetConfirmZoneCrossingTest() => Assert.That(InternetConfirmZoneCrossing(HWND.NULL, url, "http://microsoft.com"), ResultIs.Successful);
{
Assert.That(InternetConfirmZoneCrossing(HWND.NULL, url, "http://microsoft.com"), ResultIs.Successful);
}
[Test] [Test]
public void InternetConnectTest() 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); Assert.That(hCon, ResultIs.ValidHandle);
} }
@ -329,7 +310,7 @@ namespace Vanara.PInvoke.Tests
public void InternetEnumPerSiteCookieDecisionTest() public void InternetEnumPerSiteCookieDecisionTest()
{ {
Assert.That(InternetSetPerSiteCookieDecision("hpe.com", InternetCookieState.COOKIE_STATE_ACCEPT), ResultIs.Successful); 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)); Assert.That(state, Is.EqualTo(InternetCookieState.COOKIE_STATE_ACCEPT));
var sb = new StringBuilder(1024); var sb = new StringBuilder(1024);
@ -337,7 +318,7 @@ namespace Vanara.PInvoke.Tests
do do
{ {
var sz = (uint)sb.Capacity; 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)); Assert.That(Win32Error.GetLastError(), Is.EqualTo((Win32Error)Win32Error.ERROR_NO_MORE_ITEMS));
TestContext.Write($"{i}: {sb}; {dec}"); TestContext.Write($"{i}: {sb}; {dec}");
} while (i++ < 50); } while (i++ < 50);
@ -346,31 +327,27 @@ namespace Vanara.PInvoke.Tests
[Test] [Test]
public void InternetErrorDlgTest() 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); Assert.That(hCon, ResultIs.ValidHandle);
using (var hReq = HttpOpenRequest(hCon, null, "", null, "")) using SafeHINTERNET hReq = HttpOpenRequest(hCon);
{
Assert.That(hReq, ResultIs.ValidHandle); Assert.That(hReq, ResultIs.ValidHandle);
Assert.That(HttpSendRequest(hReq), ResultIs.Successful); 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); 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] [Test]
public void InternetGetConnectedStateExTest() public void InternetGetConnectedStateExTest()
{ {
var sb = new StringBuilder(1024); 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}"); TestContext.Write($"{flags}; {sb}");
} }
[Test] [Test]
public void InternetGetConnectedStateTest() public void InternetGetConnectedStateTest()
{ {
Assert.That(InternetGetConnectedState(out var flags), ResultIs.Successful); Assert.That(InternetGetConnectedState(out INTERNET_CONNECTION flags), ResultIs.Successful);
TestContext.Write(flags); TestContext.Write(flags);
} }
@ -399,47 +376,39 @@ namespace Vanara.PInvoke.Tests
{ {
var sb = new StringBuilder(1024); var sb = new StringBuilder(1024);
var sz = (uint)sb.Capacity; 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] [Test]
public void InternetGoOnlineTest() public void InternetGoOnlineTest() => Assert.That(InternetGoOnline(url, HWND.NULL), ResultIs.Successful);
{
Assert.That(InternetGoOnline(url, HWND.NULL), ResultIs.Successful);
}
[Test] [Test]
public void InternetInitializeAutoProxyDllTest() public void InternetInitializeAutoProxyDllTest() => Assert.That(InternetInitializeAutoProxyDll(), ResultIs.Successful);
{
Assert.That(InternetInitializeAutoProxyDll(), ResultIs.Successful);
}
[Test] [Test]
public void InternetLockRequestFileTest() 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(hFile, ResultIs.ValidHandle);
Assert.That(InternetQueryDataAvailable(hFile, out var num), ResultIs.Successful); Assert.That(InternetQueryDataAvailable(hFile, out var num), ResultIs.Successful);
TestContext.Write(num); 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)) using (var mem = new SafeHGlobalHandle(1024))
{ {
var ib = INTERNET_BUFFERS.Default; INTERNET_BUFFERS ib = INTERNET_BUFFERS.Default;
ib.dwBufferLength = mem.Size; ib.dwBufferLength = mem.Size;
ib.lpvBuffer = mem; ib.lpvBuffer = mem;
Assert.That(InternetReadFileEx(hFile, ref ib, IRF.IRF_SYNC), ResultIs.Successful); Assert.That(InternetReadFileEx(hFile, ref ib, IRF.IRF_SYNC), ResultIs.Successful);
} }
Assert.That(InternetUnlockRequestFile(hLock), ResultIs.Successful); Assert.That(InternetUnlockRequestFile(hLock), ResultIs.Successful);
} }
}
[Test()] [Test()]
public void InternetOpenTest() 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); Assert.That(hOpen2, ResultIs.ValidHandle);
hOpen2.Dispose(); hOpen2.Dispose();
Assert.That(hOpen2.IsInvalid, Is.True); 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); 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); Assert.That(ver.dwMajorVersion, Is.Not.Zero);
TestContext.WriteLine($"Ver is {ver.dwMajorVersion}.{ver.dwMinorVersion}"); 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); Assert.That(pi.dwAccessType, Is.Not.Zero);
TestContext.WriteLine($"Proxy is {pi.dwAccessType}={pi.lpszProxy}"); 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 st = new SYSTEMTIME(DateTime.Now, DateTimeKind.Local);
var sb = new StringBuilder(1024); var sb = new StringBuilder(1024);
Assert.That(InternetTimeFromSystemTime(st, INTERNET_RFC.INTERNET_RFC1123_FORMAT, sb, (uint)sb.Capacity), ResultIs.Successful); 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); Assert.That(st.Equals(st2), Is.True);
} }
@ -520,16 +489,15 @@ namespace Vanara.PInvoke.Tests
string pref = null; string pref = null;
var sb = new StringBuilder(1024); 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; var sz = (uint)sb.Capacity;
//Assert.That(PrivacyGetZonePreferenceW(e, priv, out var tmpl, sb, ref sz), ResultIs.Successful); //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}"); TestContext.WriteLine($"{e} : {tmpl} : {sb}");
if (e == zone) { pref = sb.ToString(); iTmpl = tmpl; } if (e == zone) { pref = sb.ToString(); iTmpl = tmpl; }
} }
Assert.That(PrivacySetZonePreferenceW(zone, priv, iTmpl, pref), ResultIs.Successful); Assert.That(PrivacySetZonePreferenceW(zone, priv, iTmpl, pref), ResultIs.Successful);
} }
}
} }