[PATCH 0/8] MR6874: windows.devices.enumeration: Add a basic implementation for DeviceInformationStatics::FindAllAsync().

[Vibhav Pant (＠vibhavp)]

The basic `FindAllAsync()` method returns a collection of `DeviceInformation` objects representing all device interfaces on the system. This MR adds a basic implementation of this method, and the associated `IDeviceInformation` and `DeviceInformationCollection` objects it returns. For `IDeviceInformation`, this MR only implements the `Id()` method, which returns the symbolic link for the registered interface.

[PATCH 1/8] windows.devices.enumeration/tests: Add conformance tests for FindAllAsync().

[Vibhav Pant]

From: Vibhav Pant

---
 .../tests/devices.c                           | 235 ++++++++++++++++++
 1 file changed, 235 insertions(+)

diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index ae76e5d754a..fe986835d4b 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -135,6 +135,199 @@ static void device_watcher_handler_create( struct device_watcher_handler *impl )
     impl->ref = 1;
 }

+struct deviceinformationcollection_async_handler
+{
+    IAsyncOperationCompletedHandler_DeviceInformationCollection iface;
+
+    IAsyncOperation_DeviceInformationCollection *async;
+    AsyncStatus status;
+    BOOL invoked;
+    HANDLE event;
+    LONG ref;
+};
+
+static inline struct deviceinformationcollection_async_handler *
+impl_from_IAsyncOperationCompletedHandler_DeviceInformationCollection(
+    IAsyncOperationCompletedHandler_DeviceInformationCollection *iface )
+{
+    return CONTAINING_RECORD( iface, struct deviceinformationcollection_async_handler, iface );
+}
+
+static HRESULT WINAPI deviceinformationcollection_async_handler_QueryInterface(
+    IAsyncOperationCompletedHandler_DeviceInformationCollection *iface, REFIID iid, void **out )
+{
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, &IID_IAsyncOperationCompletedHandler_DeviceInformationCollection ))
+    {
+        IUnknown_AddRef( iface );
+        *out = iface;
+        return S_OK;
+    }
+
+    if (winetest_debug > 1) trace( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI deviceinformationcollection_async_handler_AddRef(
+    IAsyncOperationCompletedHandler_DeviceInformationCollection *iface )
+{
+    struct deviceinformationcollection_async_handler *impl;
+    impl = impl_from_IAsyncOperationCompletedHandler_DeviceInformationCollection( iface );
+    return InterlockedIncrement( &impl->ref );
+}
+
+static ULONG WINAPI deviceinformationcollection_async_handler_Release(
+    IAsyncOperationCompletedHandler_DeviceInformationCollection *iface )
+{
+    struct deviceinformationcollection_async_handler *impl;
+    ULONG ref;
+
+    impl = impl_from_IAsyncOperationCompletedHandler_DeviceInformationCollection( iface );
+    ref =  InterlockedDecrement( &impl->ref );
+    if (!ref)
+        free( impl );
+    return ref;
+}
+
+static HRESULT WINAPI deviceinformationcollection_async_handler_Invoke(
+    IAsyncOperationCompletedHandler_DeviceInformationCollection *iface,
+    IAsyncOperation_DeviceInformationCollection *async, AsyncStatus status )
+{
+    struct deviceinformationcollection_async_handler *impl;
+
+    impl = impl_from_IAsyncOperationCompletedHandler_DeviceInformationCollection( iface );
+    ok( !impl->invoked, "invoked twice\n" );
+    impl->invoked = TRUE;
+    impl->async = async;
+    impl->status = status;
+    if (impl->event) SetEvent( impl-> event );
+
+    return S_OK;
+}
+
+static IAsyncOperationCompletedHandler_DeviceInformationCollectionVtbl deviceinformationcollection_async_handler_vtbl =
+{
+    /* IUnknown */
+    deviceinformationcollection_async_handler_QueryInterface,
+    deviceinformationcollection_async_handler_AddRef,
+    deviceinformationcollection_async_handler_Release,
+    /* IAsyncOperationCompletedHandler<DeviceInformationCollection> */
+    deviceinformationcollection_async_handler_Invoke,
+};
+
+static IAsyncOperationCompletedHandler_DeviceInformationCollection *
+deviceinformationcollection_async_handler_create( HANDLE event )
+{
+    struct deviceinformationcollection_async_handler *impl;
+
+    impl = calloc( 1, sizeof( *impl ) );
+    if (!impl)
+        return NULL;
+    impl->iface.lpVtbl = &deviceinformationcollection_async_handler_vtbl;
+    impl->event = event;
+    impl->ref = 1;
+
+    return &impl->iface;
+}
+
+#define await_deviceinformationcollection( a ) await_deviceinformationcollection_( __LINE__, ( a ) )
+static void await_deviceinformationcollection_( int line, IAsyncOperation_DeviceInformationCollection *async )
+{
+    IAsyncOperationCompletedHandler_DeviceInformationCollection *handler;
+    HANDLE event;
+    HRESULT hr;
+    DWORD ret;
+
+    event = CreateEventW( NULL, FALSE, FALSE, NULL );
+    ok_(__FILE__, line)( !!event, "CreateEventW failed, error %lu\n", GetLastError() );
+
+    handler = deviceinformationcollection_async_handler_create( event );
+    ok_(__FILE__, line)( !!handler, "deviceinformationcollection_async_handler_create failed\n" );
+    hr = IAsyncOperation_DeviceInformationCollection_put_Completed( async, handler );
+    ok_(__FILE__, line)( hr == S_OK, "put_Completed returned %#lx\n", hr );
+    IAsyncOperationCompletedHandler_DeviceInformationCollection_Release( handler );
+
+    ret = WaitForSingleObject( event, 5000 );
+    ok_(__FILE__, line)( !ret, "WaitForSingleObject returned %#lx\n", ret );
+    ret = CloseHandle( event );
+    ok_(__FILE__, line)( ret, "CloseHandle failed, error %lu\n", GetLastError() );
+}
+
+#define check_deviceinformationcollection_async( a, b, c, d, e ) check_deviceinformationcollection_async_( __LINE__, a, b, c, d, e )
+static void check_deviceinformationcollection_async_(
+    int line, IAsyncOperation_DeviceInformationCollection *async, UINT32 expect_id,
+    AsyncStatus expect_status, HRESULT expect_hr, IVectorView_DeviceInformation **result )
+{
+    AsyncStatus async_status;
+    IAsyncInfo *async_info;
+    HRESULT hr, async_hr;
+    UINT32 async_id;
+
+    hr = IAsyncOperation_DeviceInformationCollection_QueryInterface( async, &IID_IAsyncInfo, (void **)&async_info );
+    ok_(__FILE__, line)( hr == S_OK, "QueryInterface returned %#lx\n", hr );
+
+    async_id = 0xdeadbeef;
+    hr = IAsyncInfo_get_Id( async_info, &async_id );
+    if (expect_status < 4) ok_(__FILE__, line)( hr == S_OK, "get_Id returned %#lx\n", hr );
+    else ok_(__FILE__, line)( hr == E_ILLEGAL_METHOD_CALL, "get_Id returned %#lx\n", hr );
+    ok_(__FILE__, line)( async_id == expect_id, "got id %u\n", async_id );
+
+    async_status = 0xdeadbeef;
+    hr = IAsyncInfo_get_Status( async_info, &async_status );
+    if (expect_status < 4) ok_(__FILE__, line)( hr == S_OK, "get_Status returned %#lx\n", hr );
+    else ok_(__FILE__, line)( hr == E_ILLEGAL_METHOD_CALL, "get_Status returned %#lx\n", hr );
+    ok_(__FILE__, line)( async_status == expect_status, "got status %u\n", async_status );
+
+    async_hr = 0xdeadbeef;
+    hr = IAsyncInfo_get_ErrorCode( async_info, &async_hr );
+    if (expect_status < 4) ok_(__FILE__, line)( hr == S_OK, "get_ErrorCode returned %#lx\n", hr );
+    else ok_(__FILE__, line)( hr == E_ILLEGAL_METHOD_CALL, "get_ErrorCode returned %#lx\n", hr );
+    if (expect_status < 4) todo_wine_if(FAILED(expect_hr)) ok_(__FILE__, line)( async_hr == expect_hr, "got error %#lx\n", async_hr );
+    else ok_(__FILE__, line)( async_hr == E_ILLEGAL_METHOD_CALL, "got error %#lx\n", async_hr );
+
+    IAsyncInfo_Release( async_info );
+
+    hr = IAsyncOperation_DeviceInformationCollection_GetResults( async, result );
+    switch (expect_status)
+    {
+    case Completed:
+    case Error:
+        todo_wine_if(FAILED(expect_hr))
+        ok_(__FILE__, line)( hr == expect_hr, "GetResults returned %#lx\n", hr );
+        break;
+    case Canceled:
+    case Started:
+    default:
+        ok_(__FILE__, line)( hr == E_ILLEGAL_METHOD_CALL, "GetResults returned %#lx\n", hr );
+        break;
+    }
+}
+
+static void test_DeviceInformation_obj( int line, IDeviceInformation *info )
+{
+    HRESULT hr;
+    HSTRING str;
+    boolean bool_val;
+
+    hr = IDeviceInformation_get_Id( info, &str );
+    ok_(__FILE__, line)( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+    trace_(__FILE__, line)( "id: %s\n", debugstr_hstring( str ) );
+    WindowsDeleteString( str );
+    str = NULL;
+    hr = IDeviceInformation_get_Name( info, &str );
+    todo_wine ok_(__FILE__, line)( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+    trace_(__FILE__, line)( "  name: %s\n", debugstr_hstring( str ) );
+    WindowsDeleteString( str );
+    hr = IDeviceInformation_get_IsEnabled( info, &bool_val );
+    todo_wine ok_(__FILE__, line)( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+    trace_(__FILE__, line)( "  enabled: %d\n", bool_val );
+    hr = IDeviceInformation_get_IsDefault( info, &bool_val );
+    todo_wine ok_(__FILE__, line)( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+    trace_(__FILE__, line)( "  default: %d\n", bool_val );
+}
+
 static void test_DeviceInformation( void )
 {
     static const WCHAR *device_info_name = L"Windows.Devices.Enumeration.DeviceInformation";
@@ -147,6 +340,8 @@ static void test_DeviceInformation( void )
     IDeviceInformationStatics *device_info_statics;
     IDeviceWatcher *device_watcher;
     DeviceWatcherStatus status = 0xdeadbeef;
+    IAsyncOperation_DeviceInformationCollection *infocollection_async = NULL;
+    IVectorView_DeviceInformation *info_collection = NULL;
     ULONG ref;
     HSTRING str;
     HRESULT hr;
@@ -273,6 +468,46 @@ static void test_DeviceInformation( void )
     ok( stopped_handler.args == NULL, "stopped_handler not invoked\n" );

IDeviceWatcher_Release( device_watcher );
+
+    hr = IDeviceInformationStatics_FindAllAsync( device_info_statics, &infocollection_async );
+    todo_wine ok( SUCCEEDED( hr ), "got %#lx\n", hr );
+    if (infocollection_async)
+    {
+        todo_wine await_deviceinformationcollection( infocollection_async );
+        todo_wine check_deviceinformationcollection_async( infocollection_async, 1, Completed, S_OK, &info_collection );
+        IAsyncOperation_DeviceInformationCollection_Release( infocollection_async );
+    }
+    if (info_collection)
+    {
+        UINT32 idx = 0, size = 0;
+
+        hr = IVectorView_DeviceInformation_get_Size( info_collection, &size );
+        todo_wine ok( SUCCEEDED( hr ), "got %#lx\n", hr );
+        for (idx = 0; idx < size ;idx++)
+        {
+            IDeviceInformation *info;
+            winetest_push_context("info_collection %u", idx);
+            hr = IVectorView_DeviceInformation_GetAt( info_collection, idx, &info );
+            ok( SUCCEEDED( hr ), "got %#lx\n", hr);
+            if (SUCCEEDED( hr ))
+            {
+                UINT32 idx2 = 0;
+                boolean found = FALSE;
+
+                test_DeviceInformation_obj(__LINE__, info);
+                IDeviceInformation_Release( info );
+                hr = IVectorView_DeviceInformation_IndexOf( info_collection, info, &idx2, &found );
+                ok( SUCCEEDED( hr ), "got %#lx\n", hr );
+                if (SUCCEEDED( hr ))
+                {
+                    ok( found, "Expected IndexOf to return true\n" );
+                    ok( idx == idx2, "%u != %u\n", idx, idx2);
+                }
+            }
+            winetest_pop_context();
+        }
+    }
+
     IDeviceInformationStatics_Release( device_info_statics );
 skip_device_statics:
     IInspectable_Release( inspectable );

[PATCH 2/8] windows.devices.enumeration/tests: Add conformance tests for GetMany() and IndexOf() methods in DeviceInformationCollection.

[Vibhav Pant]

From: Vibhav Pant

---
 .../tests/devices.c                           | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index fe986835d4b..50890212102 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -480,6 +480,7 @@ static void test_DeviceInformation( void )
     if (info_collection)
     {
         UINT32 idx = 0, size = 0;
+        IDeviceInformation **devices;

hr = IVectorView_DeviceInformation_get_Size( info_collection, &size );
         todo_wine ok( SUCCEEDED( hr ), "got %#lx\n", hr );
@@ -506,6 +507,49 @@ static void test_DeviceInformation( void )
             }
             winetest_pop_context();
         }
+
+        devices = calloc( 1, sizeof( *devices ) * size );
+        ok( !!devices, "Unable to allocate array\n" );
+        if (devices)
+        {
+            UINT32 copied = 0;
+
+            hr = IVectorView_DeviceInformation_GetMany( info_collection, 0, size, devices, &copied );
+            todo_wine ok( SUCCEEDED( hr ), "got %#lx\n", hr );
+            if (SUCCEEDED( hr ))
+                todo_wine ok( copied == size, "%u != %u\n", copied, size );
+            for(idx = 0; idx < copied; idx++)
+            {
+                IDeviceInformation *info = NULL;
+                HSTRING id1 = NULL, id2 = NULL;
+
+                winetest_push_context("devices %u", idx);
+                hr = IDeviceInformation_get_Id( devices[idx], &id1 );
+                ok( SUCCEEDED( hr ), "got %#lx\n" );
+                hr = IVectorView_DeviceInformation_GetAt( info_collection, idx, &info);
+                ok( SUCCEEDED( hr ), "got %#lx\n" );
+                if (SUCCEEDED( hr ))
+                {
+                    hr = IDeviceInformation_get_Id( info, &id2 );
+                    ok( SUCCEEDED( hr ), "got %#lx\n" );
+                }
+                if (id1 && id2)
+                {
+                    INT32 order = 1;
+                    WindowsCompareStringOrdinal( id1, id2, &order );
+                    ok( !order, "%s != %s\n", debugstr_hstring( id1 ), debugstr_hstring( id2 ) );
+                }
+                WindowsDeleteString( id1 );
+                WindowsDeleteString( id2 );
+                if (info)
+                    IDeviceInformation_Release( info );
+                IDeviceInformation_Release( devices[idx] );
+                winetest_pop_context();
+            }
+            free( devices );
+        }
+
+        IVectorView_DeviceInformation_Release( info_collection );
     }

IDeviceInformationStatics_Release( device_info_statics );

[PATCH 3/8] windows.devices.enumeration/tests: Add conformance tests for IIterable and IIterator interfaces in DeviceInformationCollection.

[Vibhav Pant]

From: Vibhav Pant

---
 .../tests/devices.c                           | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index 50890212102..5eaa274e4eb 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -342,6 +342,8 @@ static void test_DeviceInformation( void )
     DeviceWatcherStatus status = 0xdeadbeef;
     IAsyncOperation_DeviceInformationCollection *infocollection_async = NULL;
     IVectorView_DeviceInformation *info_collection = NULL;
+    IIterable_DeviceInformation *info_iterable = NULL;
+    IIterator_DeviceInformation *info_iterator = NULL;
     ULONG ref;
     HSTRING str;
     HRESULT hr;
@@ -549,7 +551,37 @@ static void test_DeviceInformation( void )
             free( devices );
         }

+        hr = IVectorView_DeviceInformation_QueryInterface(
+            info_collection, &IID_IIterable_DeviceInformation, (void **)&info_iterable );
         IVectorView_DeviceInformation_Release( info_collection );
+        todo_wine ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+    }
+    if (info_iterable)
+    {
+        hr = IIterable_DeviceInformation_First( info_iterable, &info_iterator );
+        todo_wine ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+        IIterable_DeviceInformation_Release( info_iterable );
+    }
+    if (info_iterator)
+    {
+        boolean exists;
+
+        hr = IIterator_DeviceInformation_get_HasCurrent( info_iterator, &exists );
+        todo_wine ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+        while (SUCCEEDED( hr ) && exists)
+        {
+            IDeviceInformation *info;
+
+            hr = IIterator_DeviceInformation_get_Current( info_iterator, &info );
+            todo_wine ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+            if (FAILED( hr )) break;
+            test_DeviceInformation_obj( __LINE__, info );
+            IDeviceInformation_Release( info );
+            hr = IIterator_DeviceInformation_MoveNext( info_iterator, &exists );
+            ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+        }
+
+        IIterator_DeviceInformation_Release( info_iterator );
     }

IDeviceInformationStatics_Release( device_info_statics );

[PATCH 4/8] windows.devices.enumeration: Add a stubbed implementation for FindAllAsync() and DeviceInformationCollection.

[Vibhav Pant]

From: Vibhav Pant

---
 dlls/windows.devices.enumeration/Makefile.in  |   7 +-
 dlls/windows.devices.enumeration/async.c      | 507 ++++++++++++++++++
 dlls/windows.devices.enumeration/async.idl    |  44 ++
 dlls/windows.devices.enumeration/collection.c | 164 ++++++
 dlls/windows.devices.enumeration/main.c       |  20 +-
 dlls/windows.devices.enumeration/private.h    |   6 +
 .../tests/devices.c                           |   6 +-
 7 files changed, 747 insertions(+), 7 deletions(-)
 create mode 100644 dlls/windows.devices.enumeration/async.c
 create mode 100644 dlls/windows.devices.enumeration/async.idl
 create mode 100644 dlls/windows.devices.enumeration/collection.c

diff --git a/dlls/windows.devices.enumeration/Makefile.in b/dlls/windows.devices.enumeration/Makefile.in
index 93c15dfcc64..fd40a90c98b 100644
--- a/dlls/windows.devices.enumeration/Makefile.in
+++ b/dlls/windows.devices.enumeration/Makefile.in
@@ -1,8 +1,11 @@
 MODULE = windows.devices.enumeration.dll
-IMPORTS = combase uuid
+IMPORTS = advapi32 combase setupapi uuid

SOURCES = \
    access.c \
+	async.c \
+	async.idl \
    classes.idl \
+	collection.c \
    event_handlers.c \
-	main.c
+	main.c \
diff --git a/dlls/windows.devices.enumeration/async.c b/dlls/windows.devices.enumeration/async.c
new file mode 100644
index 00000000000..a172dccaffc
--- /dev/null
+++ b/dlls/windows.devices.enumeration/async.c
@@ -0,0 +1,507 @@
+/* Copyright 2022 Bernhard Kölbl for CodeWeavers
+ * Copyright 2022 Rémi Bernon for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "private.h"
+#include <initguid.h>
+#include "async.h"
+
+#include <wine/debug.h>
+
+WINE_DEFAULT_DEBUG_CHANNEL(enumeration);
+
+#define Closed 4
+#define HANDLER_NOT_SET ((void *)~(ULONG_PTR)0)
+
+struct async_info
+{
+    IWineAsyncInfoImpl IWineAsyncInfoImpl_iface;
+    IAsyncInfo IAsyncInfo_iface;
+    IInspectable *IInspectable_outer;
+    LONG ref;
+
+    async_operation_callback callback;
+    TP_WORK *async_run_work;
+    IUnknown *invoker;
+    IUnknown *param;
+
+    CRITICAL_SECTION cs;
+    IWineAsyncOperationCompletedHandler *handler;
+    PROPVARIANT result;
+    AsyncStatus status;
+    HRESULT hr;
+};
+
+static inline struct async_info *impl_from_IWineAsyncInfoImpl( IWineAsyncInfoImpl *iface )
+{
+    return CONTAINING_RECORD( iface, struct async_info, IWineAsyncInfoImpl_iface );
+}
+
+static HRESULT WINAPI async_impl_QueryInterface( IWineAsyncInfoImpl *iface, REFIID iid, void **out )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+
+    TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, &IID_IWineAsyncInfoImpl ))
+    {
+        IInspectable_AddRef( (*out = &impl->IWineAsyncInfoImpl_iface) );
+        return S_OK;
+    }
+
+    if (IsEqualGUID( iid, &IID_IAsyncInfo ))
+    {
+        IInspectable_AddRef( (*out = &impl->IAsyncInfo_iface) );
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI async_impl_AddRef( IWineAsyncInfoImpl *iface )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p, ref %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI async_impl_Release( IWineAsyncInfoImpl *iface )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+    TRACE( "iface %p, ref %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        if (impl->handler && impl->handler != HANDLER_NOT_SET) IWineAsyncOperationCompletedHandler_Release( impl->handler );
+        IAsyncInfo_Close( &impl->IAsyncInfo_iface );
+        if (impl->param) IUnknown_Release( impl->param );
+        if (impl->invoker) IUnknown_Release( impl->invoker );
+        impl->cs.DebugInfo->Spare[0] = 0;
+        DeleteCriticalSection( &impl->cs );
+        free( impl );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI async_impl_put_Completed( IWineAsyncInfoImpl *iface, IWineAsyncOperationCompletedHandler *handler )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, handler %p.\n", iface, handler );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) hr = E_ILLEGAL_METHOD_CALL;
+    else if (impl->handler != HANDLER_NOT_SET) hr = E_ILLEGAL_DELEGATE_ASSIGNMENT;
+    else if ((impl->handler = handler))
+    {
+        IWineAsyncOperationCompletedHandler_AddRef( impl->handler );
+
+        if (impl->status > Started)
+        {
+            IInspectable *operation = impl->IInspectable_outer;
+            AsyncStatus status = impl->status;
+            impl->handler = NULL; /* Prevent concurrent invoke. */
+            LeaveCriticalSection( &impl->cs );
+
+            IWineAsyncOperationCompletedHandler_Invoke( handler, operation, status );
+            IWineAsyncOperationCompletedHandler_Release( handler );
+
+            return S_OK;
+        }
+    }
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_impl_get_Completed( IWineAsyncInfoImpl *iface, IWineAsyncOperationCompletedHandler **handler )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, handler %p.\n", iface, handler );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) hr = E_ILLEGAL_METHOD_CALL;
+    if (impl->handler == NULL || impl->handler == HANDLER_NOT_SET) *handler = NULL;
+    else IWineAsyncOperationCompletedHandler_AddRef( (*handler = impl->handler) );
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_impl_get_Result( IWineAsyncInfoImpl *iface, PROPVARIANT *result )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    HRESULT hr = E_ILLEGAL_METHOD_CALL;
+
+    TRACE( "iface %p, result %p.\n", iface, result );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Completed || impl->status == Error)
+    {
+        PropVariantCopy( result, &impl->result );
+        hr = impl->hr;
+    }
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_impl_Start( IWineAsyncInfoImpl *iface )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+
+    TRACE( "iface %p.\n", iface );
+
+    /* keep the async alive in the callback */
+    IInspectable_AddRef( impl->IInspectable_outer );
+    SubmitThreadpoolWork( impl->async_run_work );
+
+    return S_OK;
+}
+
+static const struct IWineAsyncInfoImplVtbl async_impl_vtbl =
+{
+    /* IUnknown methods */
+    async_impl_QueryInterface,
+    async_impl_AddRef,
+    async_impl_Release,
+    /* IWineAsyncInfoImpl */
+    async_impl_put_Completed,
+    async_impl_get_Completed,
+    async_impl_get_Result,
+    async_impl_Start,
+};
+
+DEFINE_IINSPECTABLE_OUTER( async_info, IAsyncInfo, struct async_info, IInspectable_outer )
+
+static HRESULT WINAPI async_info_get_Id( IAsyncInfo *iface, UINT32 *id )
+{
+    struct async_info *impl = impl_from_IAsyncInfo( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, id %p.\n", iface, id );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) hr = E_ILLEGAL_METHOD_CALL;
+    *id = 1;
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_info_get_Status( IAsyncInfo *iface, AsyncStatus *status )
+{
+    struct async_info *impl = impl_from_IAsyncInfo( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, status %p.\n", iface, status );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) hr = E_ILLEGAL_METHOD_CALL;
+    *status = impl->status;
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_info_get_ErrorCode( IAsyncInfo *iface, HRESULT *error_code )
+{
+    struct async_info *impl = impl_from_IAsyncInfo( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, error_code %p.\n", iface, error_code );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) *error_code = hr = E_ILLEGAL_METHOD_CALL;
+    else *error_code = impl->hr;
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_info_Cancel( IAsyncInfo *iface )
+{
+    struct async_info *impl = impl_from_IAsyncInfo( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p.\n", iface );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Closed) hr = E_ILLEGAL_METHOD_CALL;
+    else if (impl->status == Started) impl->status = Canceled;
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static HRESULT WINAPI async_info_Close( IAsyncInfo *iface )
+{
+    struct async_info *impl = impl_from_IAsyncInfo( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p.\n", iface );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status == Started)
+        hr = E_ILLEGAL_STATE_CHANGE;
+    else if (impl->status != Closed)
+    {
+        CloseThreadpoolWork( impl->async_run_work );
+        impl->async_run_work = NULL;
+        impl->status = Closed;
+    }
+    LeaveCriticalSection( &impl->cs );
+
+    return hr;
+}
+
+static const struct IAsyncInfoVtbl async_info_vtbl =
+{
+    /* IUnknown methods */
+    async_info_QueryInterface,
+    async_info_AddRef,
+    async_info_Release,
+    /* IInspectable methods */
+    async_info_GetIids,
+    async_info_GetRuntimeClassName,
+    async_info_GetTrustLevel,
+    /* IAsyncInfo */
+    async_info_get_Id,
+    async_info_get_Status,
+    async_info_get_ErrorCode,
+    async_info_Cancel,
+    async_info_Close,
+};
+
+static void CALLBACK async_info_callback( TP_CALLBACK_INSTANCE *instance, void *iface, TP_WORK *work )
+{
+    struct async_info *impl = impl_from_IWineAsyncInfoImpl( iface );
+    IInspectable *operation = impl->IInspectable_outer;
+    PROPVARIANT result;
+    HRESULT hr;
+
+    hr = impl->callback( impl->invoker, impl->param, &result );
+
+    EnterCriticalSection( &impl->cs );
+    if (impl->status != Closed) impl->status = FAILED(hr) ? Error : Completed;
+    PropVariantCopy( &impl->result, &result );
+    impl->hr = hr;
+
+    if (impl->handler != NULL && impl->handler != HANDLER_NOT_SET)
+    {
+        IWineAsyncOperationCompletedHandler *handler = impl->handler;
+        AsyncStatus status = impl->status;
+        impl->handler = NULL; /* Prevent concurrent invoke. */
+        LeaveCriticalSection( &impl->cs );
+
+        IWineAsyncOperationCompletedHandler_Invoke( handler, operation, status );
+        IWineAsyncOperationCompletedHandler_Release( handler );
+    }
+    else LeaveCriticalSection( &impl->cs );
+
+    /* release refcount acquired in Start */
+    IInspectable_Release( operation );
+
+    PropVariantClear( &result );
+}
+
+static HRESULT async_info_create( IUnknown *invoker, IUnknown *param, async_operation_callback callback,
+                                  IInspectable *outer, IWineAsyncInfoImpl **out )
+{
+    struct async_info *impl;
+    HRESULT hr;
+
+    if (!(impl = calloc( 1, sizeof(struct async_info) ))) return E_OUTOFMEMORY;
+    impl->IWineAsyncInfoImpl_iface.lpVtbl = &async_impl_vtbl;
+    impl->IAsyncInfo_iface.lpVtbl = &async_info_vtbl;
+    impl->IInspectable_outer = outer;
+    impl->ref = 1;
+
+    impl->callback = callback;
+    impl->handler = HANDLER_NOT_SET;
+    impl->status = Started;
+    if (!(impl->async_run_work = CreateThreadpoolWork( async_info_callback, &impl->IWineAsyncInfoImpl_iface, NULL )))
+    {
+        hr = HRESULT_FROM_WIN32( GetLastError() );
+        free( impl );
+        return hr;
+    }
+
+    if ((impl->invoker = invoker)) IUnknown_AddRef( impl->invoker );
+    if ((impl->param = param)) IUnknown_AddRef( impl->param );
+
+    InitializeCriticalSectionEx( &impl->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO );
+    impl->cs.DebugInfo->Spare[0] = (DWORD_PTR)( __FILE__ ": async_info.cs" );
+
+    *out = &impl->IWineAsyncInfoImpl_iface;
+    return S_OK;
+}
+
+struct async_result
+{
+    IAsyncOperation_DeviceInformationCollection IAsyncOperation_DeviceInformationCollection_iface;
+    IWineAsyncInfoImpl *IWineAsyncInfoImpl_inner;
+    LONG ref;
+};
+
+static inline struct async_result *impl_from_IAsyncOperation_DeviceInformationCollection( IAsyncOperation_DeviceInformationCollection *iface )
+{
+    return CONTAINING_RECORD( iface, struct async_result, IAsyncOperation_DeviceInformationCollection_iface );
+}
+
+static HRESULT WINAPI async_result_QueryInterface( IAsyncOperation_DeviceInformationCollection *iface, REFIID iid, void **out )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+
+    TRACE( "iface %p, iid %s, out %p.\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, &IID_IAsyncOperation_DeviceInformationCollection ))
+    {
+        IInspectable_AddRef( (*out = &impl->IAsyncOperation_DeviceInformationCollection_iface) );
+        return S_OK;
+    }
+
+    return IWineAsyncInfoImpl_QueryInterface( impl->IWineAsyncInfoImpl_inner, iid, out );
+}
+
+static ULONG WINAPI async_result_AddRef( IAsyncOperation_DeviceInformationCollection *iface )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p, ref %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI async_result_Release( IAsyncOperation_DeviceInformationCollection *iface )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+    TRACE( "iface %p, ref %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        /* guard against re-entry if inner releases an outer iface */
+        InterlockedIncrement( &impl->ref );
+        IWineAsyncInfoImpl_Release( impl->IWineAsyncInfoImpl_inner );
+        free( impl );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI async_result_GetIids( IAsyncOperation_DeviceInformationCollection *iface, ULONG *iid_count, IID **iids )
+{
+    FIXME( "iface %p, iid_count %p, iids %p stub!\n", iface, iid_count, iids );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI async_result_GetRuntimeClassName( IAsyncOperation_DeviceInformationCollection *iface, HSTRING *class_name )
+{
+    return WindowsCreateString( L"Windows.Foundation.IAsyncOperation`1<Windows.Devices.Enumeration.DeviceInformationCollection>",
+                                ARRAY_SIZE(L"Windows.Foundation.IAsyncOperation`1<Windows.Devices.Enumeration.DeviceInformationCollection>"),
+                                class_name );
+}
+
+static HRESULT WINAPI async_result_GetTrustLevel( IAsyncOperation_DeviceInformationCollection *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI async_result_put_Completed( IAsyncOperation_DeviceInformationCollection *iface, IAsyncOperationCompletedHandler_DeviceInformationCollection *handler )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+    TRACE( "iface %p, handler %p.\n", iface, handler );
+    return IWineAsyncInfoImpl_put_Completed( impl->IWineAsyncInfoImpl_inner, (IWineAsyncOperationCompletedHandler *)handler );
+}
+
+static HRESULT WINAPI async_result_get_Completed( IAsyncOperation_DeviceInformationCollection *iface, IAsyncOperationCompletedHandler_DeviceInformationCollection **handler )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+    TRACE( "iface %p, handler %p.\n", iface, handler );
+    return IWineAsyncInfoImpl_get_Completed( impl->IWineAsyncInfoImpl_inner, (IWineAsyncOperationCompletedHandler **)handler );
+}
+
+static HRESULT WINAPI async_result_GetResults( IAsyncOperation_DeviceInformationCollection *iface, IVectorView_DeviceInformation **results )
+{
+    struct async_result *impl = impl_from_IAsyncOperation_DeviceInformationCollection( iface );
+    PROPVARIANT result = {.vt = VT_UNKNOWN};
+    HRESULT hr;
+
+    TRACE( "iface %p, results %p.\n", iface, results );
+
+    hr = IWineAsyncInfoImpl_get_Result( impl->IWineAsyncInfoImpl_inner, &result );
+    if (SUCCEEDED( hr ))
+        hr = IUnknown_QueryInterface( result.punkVal, &IID_IVectorView_DeviceInformation, (void **)results );
+    PropVariantClear( &result );
+    return hr;
+}
+
+static const struct IAsyncOperation_DeviceInformationCollectionVtbl async_result_vtbl =
+{
+    /* IUnknown methods */
+    async_result_QueryInterface,
+    async_result_AddRef,
+    async_result_Release,
+    /* IInspectable methods */
+    async_result_GetIids,
+    async_result_GetRuntimeClassName,
+    async_result_GetTrustLevel,
+    /* IAsyncOperation<DeviceInformationCollection> */
+    async_result_put_Completed,
+    async_result_get_Completed,
+    async_result_GetResults,
+};
+
+HRESULT async_operation_device_info_collection_result_create(
+    IUnknown *invoker, IUnknown *param, async_operation_callback callback,
+    IAsyncOperation_DeviceInformationCollection **out )
+{
+    struct async_result *impl;
+    HRESULT hr;
+
+    *out = NULL;
+    if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
+    impl->IAsyncOperation_DeviceInformationCollection_iface.lpVtbl = &async_result_vtbl;
+    impl->ref = 1;
+
+    if (FAILED(hr = async_info_create( invoker, param, callback, (IInspectable *)&impl->IAsyncOperation_DeviceInformationCollection_iface, &impl->IWineAsyncInfoImpl_inner )) ||
+        FAILED(hr = IWineAsyncInfoImpl_Start( impl->IWineAsyncInfoImpl_inner )))
+    {
+        if (impl->IWineAsyncInfoImpl_inner) IWineAsyncInfoImpl_Release( impl->IWineAsyncInfoImpl_inner );
+        free( impl );
+        return hr;
+    }
+
+    *out = &impl->IAsyncOperation_DeviceInformationCollection_iface;
+    TRACE( "created IAsyncOperation_DeviceInformationCollection %p\n", *out );
+    return S_OK;
+}
diff --git a/dlls/windows.devices.enumeration/async.idl b/dlls/windows.devices.enumeration/async.idl
new file mode 100644
index 00000000000..88e1a76f547
--- /dev/null
+++ b/dlls/windows.devices.enumeration/async.idl
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2022 Rémi Bernon for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#pragma makedep header
+
+#ifdef __WIDL__
+#pragma winrt ns_prefix
+#endif
+
+import "propidl.idl";
+import "inspectable.idl";
+import "asyncinfo.idl";
+import "windowscontracts.idl";
+
+namespace Windows.Devices.Enumeration {
+    /* type-pruning version of AsyncOperationCompletedHandler<T> */
+    delegate HRESULT WineAsyncOperationCompletedHandler([in] IInspectable *async, [in] AsyncStatus status);
+
+    [
+        uuid(d81ab70d-82e0-481c-983d-401225d98a2c)
+    ]
+    interface IWineAsyncInfoImpl : IUnknown
+    {
+        [propput] HRESULT Completed([in] WineAsyncOperationCompletedHandler *handler);
+        [propget] HRESULT Completed([out, retval] WineAsyncOperationCompletedHandler **handler);
+        [propget] HRESULT Result([out, retval] PROPVARIANT *result);
+        HRESULT Start();
+    }
+}
diff --git a/dlls/windows.devices.enumeration/collection.c b/dlls/windows.devices.enumeration/collection.c
new file mode 100644
index 00000000000..a14dfdb27c2
--- /dev/null
+++ b/dlls/windows.devices.enumeration/collection.c
@@ -0,0 +1,164 @@
+/* DeviceInformationCollection implementation
+ *
+ * Copyright 2024 Vibhav Pant
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "private.h"
+#include "windows.foundation.collections.h"
+
+#include <wine/debug.h>
+
+WINE_DEFAULT_DEBUG_CHANNEL(enumeration);
+
+struct vectorview_DeviceInformation
+{
+    IVectorView_DeviceInformation IVectorView_DeviceInformation_iface;
+    LONG ref;
+};
+
+static inline struct vectorview_DeviceInformation *
+impl_from_IVectorView_DeviceInformation( IVectorView_DeviceInformation *iface )
+{
+    return CONTAINING_RECORD( iface, struct vectorview_DeviceInformation, IVectorView_DeviceInformation_iface );
+}
+
+static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_QueryInterface(
+    IVectorView_DeviceInformation *iface, REFIID iid, void **out )
+{
+    TRACE( "(%p, %s, %p)\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, &IID_IVectorView_DeviceInformation ))
+    {
+        IUnknown_AddRef( iface );
+        *out = iface;
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG STDMETHODCALLTYPE vectorview_DeviceInformation_AddRef( IVectorView_DeviceInformation *iface )
+{
+    struct vectorview_DeviceInformation *impl;
+
+    TRACE( "(%p)\n", iface );
+
+    impl = impl_from_IVectorView_DeviceInformation( iface );
+    return InterlockedIncrement( &impl->ref );
+}
+
+static ULONG STDMETHODCALLTYPE vectorview_DeviceInformation_Release( IVectorView_DeviceInformation *iface )
+{
+    struct vectorview_DeviceInformation *impl;
+    ULONG ref;
+
+    TRACE( "(%p)\n", iface );
+
+    impl = impl_from_IVectorView_DeviceInformation( iface );
+    ref = InterlockedDecrement( &impl->ref );
+    if (!ref)
+        free( impl );
+    return ref;
+}
+
+static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_GetIids( IVectorView_DeviceInformation *iface,
+                                                                       ULONG *iid_count, IID **iids )
+{
+    FIXME( "(%p, %p, %p) stub!\n", iface, iid_count, iids );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_GetRuntimeClassName( IVectorView_DeviceInformation *iface,
+                                                                                   HSTRING *class_name )
+{
+    const static WCHAR name[] = L"Windows.Foundation.Collections.IVectorView`1<Windows.Devices.Enumeration.DeviceInformation>";
+    TRACE( "(%p, %p)\n", iface, class_name );
+    return WindowsCreateString( name, ARRAY_SIZE( name ), class_name );
+}
+
+static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_GetTrustLevel( IVectorView_DeviceInformation *iface,
+                                                                             TrustLevel *trust_level )
+{
+    FIXME( "(%p, %p) stub!\n", iface, trust_level);
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_GetAt( IVectorView_DeviceInformation *iface, UINT32 index,
+                                                                     IDeviceInformation **value )
+{
+    FIXME( "(%p, %u, %p) stub!\n", iface, index, value );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_get_Size( IVectorView_DeviceInformation *iface,
+                                                                        UINT32 *value )
+{
+    FIXME( "(%p, %p) stub!\n", iface, value );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_IndexOf( IVectorView_DeviceInformation *iface,
+                                                                       IDeviceInformation *elem, UINT32 *index,
+                                                                       boolean *found )
+{
+    FIXME( "(%p, %p, %p, %p) stub!\n", iface, elem, index, found );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_GetMany( IVectorView_DeviceInformation *iface,
+                                                                       UINT32 start, UINT32 size,
+                                                                       IDeviceInformation **items, UINT32 *copied )
+{
+    FIXME( "(%p, %u, %u, %p, %p): stub!\n", iface, start, size, items, copied );
+    return E_NOTIMPL;
+}
+
+const static IVectorView_DeviceInformationVtbl vectorview_DeviceInformation_vtbl =
+{
+    /* IUnknown */
+    vectorview_DeviceInformation_QueryInterface,
+    vectorview_DeviceInformation_AddRef,
+    vectorview_DeviceInformation_Release,
+    /* IInspectable */
+    vectorview_DeviceInformation_GetIids,
+    vectorview_DeviceInformation_GetRuntimeClassName,
+    vectorview_DeviceInformation_GetTrustLevel,
+    /* IVectorView<DeviceInformation> */
+    vectorview_DeviceInformation_GetAt,
+    vectorview_DeviceInformation_get_Size,
+    vectorview_DeviceInformation_IndexOf,
+    vectorview_DeviceInformation_GetMany
+};
+
+HRESULT vectorview_deviceinformation_create( IVectorView_DeviceInformation **view )
+{
+    struct vectorview_DeviceInformation *impl;
+
+    impl = calloc( 1, sizeof( *impl ) );
+    if (!impl)
+        return E_OUTOFMEMORY;
+
+    impl->IVectorView_DeviceInformation_iface.lpVtbl = &vectorview_DeviceInformation_vtbl;
+    impl->ref = 1;
+    *view = &impl->IVectorView_DeviceInformation_iface;
+    return S_OK;
+}
diff --git a/dlls/windows.devices.enumeration/main.c b/dlls/windows.devices.enumeration/main.c
index e1f8b5c5ae5..0b705679283 100644
--- a/dlls/windows.devices.enumeration/main.c
+++ b/dlls/windows.devices.enumeration/main.c
@@ -333,11 +333,27 @@ static HRESULT WINAPI device_statics_CreateFromIdAsyncAdditionalProperties( IDev
     return E_NOTIMPL;
 }

+static HRESULT WINAPI findall_async( IUnknown *invoker, IUnknown *param, PROPVARIANT *result )
+{
+    HRESULT hr;
+    IVectorView_DeviceInformation *view;
+
+    FIXME( "invoker %p, param %p, result %p semi-stub!\n", invoker, param, result );
+
+    hr = vectorview_deviceinformation_create( &view );
+    if (SUCCEEDED( hr ))
+    {
+        result->vt = VT_UNKNOWN;
+        result->punkVal = (IUnknown *)view;
+    }
+    return hr;
+}
+
 static HRESULT WINAPI device_statics_FindAllAsync( IDeviceInformationStatics *iface,
                                                    IAsyncOperation_DeviceInformationCollection **op )
 {
-    FIXME( "iface %p, op %p stub!\n", iface, op );
-    return E_NOTIMPL;
+    TRACE( "iface %p, op %p\n", iface, op );
+    return async_operation_device_info_collection_result_create( (IUnknown *)iface, NULL, findall_async, op );
 }

static HRESULT WINAPI device_statics_FindAllAsyncDeviceClass( IDeviceInformationStatics *iface, DeviceClass class,
diff --git a/dlls/windows.devices.enumeration/private.h b/dlls/windows.devices.enumeration/private.h
index 06234e984e0..9e4ff6b20ea 100644
--- a/dlls/windows.devices.enumeration/private.h
+++ b/dlls/windows.devices.enumeration/private.h
@@ -28,6 +28,7 @@
 #include "winbase.h"
 #include "winstring.h"
 #include "objbase.h"
+#include "setupapi.h"

#include "activation.h"

@@ -46,6 +47,11 @@ HRESULT typed_event_handlers_remove( struct list *list, EventRegistrationToken *
 HRESULT typed_event_handlers_notify( struct list *list, IInspectable *sender, IInspectable *args );
 HRESULT typed_event_handlers_clear( struct list *list );

+typedef HRESULT (WINAPI *async_operation_callback)( IUnknown *invoker, IUnknown *param, PROPVARIANT *result );
+extern HRESULT async_operation_device_info_collection_result_create(
+    IUnknown *invoker, IUnknown *param, async_operation_callback callback,
+    IAsyncOperation_DeviceInformationCollection **out );
+extern HRESULT vectorview_deviceinformation_create( IVectorView_DeviceInformation **view );
 #define DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from, iface_mem, expr )             \
     static inline impl_type *impl_from( iface_type *iface )                                        \
     {                                                                                              \
diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index 5eaa274e4eb..4a22a4dd34d 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -472,11 +472,11 @@ static void test_DeviceInformation( void )
     IDeviceWatcher_Release( device_watcher );

hr = IDeviceInformationStatics_FindAllAsync( device_info_statics, &infocollection_async );
-    todo_wine ok( SUCCEEDED( hr ), "got %#lx\n", hr );
+    ok( SUCCEEDED( hr ), "got %#lx\n", hr );
     if (infocollection_async)
     {
-        todo_wine await_deviceinformationcollection( infocollection_async );
-        todo_wine check_deviceinformationcollection_async( infocollection_async, 1, Completed, S_OK, &info_collection );
+        await_deviceinformationcollection( infocollection_async );
+        check_deviceinformationcollection_async( infocollection_async, 1, Completed, S_OK, &info_collection );
         IAsyncOperation_DeviceInformationCollection_Release( infocollection_async );
     }
     if (info_collection)

[PATCH 5/8] windows.devices.enumeration: Add a stubbed IDeviceInformation implementation for device interfaces.

[Vibhav Pant]

From: Vibhav Pant

---
 dlls/windows.devices.enumeration/Makefile.in  |   1 +
 dlls/windows.devices.enumeration/collection.c |  38 +++-
 .../windows.devices.enumeration/information.c | 203 ++++++++++++++++++
 dlls/windows.devices.enumeration/main.c       |  21 +-
 dlls/windows.devices.enumeration/private.h    |   5 +-
 .../tests/devices.c                           |   6 +-
 6 files changed, 262 insertions(+), 12 deletions(-)
 create mode 100644 dlls/windows.devices.enumeration/information.c

diff --git a/dlls/windows.devices.enumeration/Makefile.in b/dlls/windows.devices.enumeration/Makefile.in
index fd40a90c98b..ba3bc7a4b6c 100644
--- a/dlls/windows.devices.enumeration/Makefile.in
+++ b/dlls/windows.devices.enumeration/Makefile.in
@@ -8,4 +8,5 @@ SOURCES = \
    classes.idl \
    collection.c \
    event_handlers.c \
+	information.c \
    main.c \
diff --git a/dlls/windows.devices.enumeration/collection.c b/dlls/windows.devices.enumeration/collection.c
index a14dfdb27c2..ac0ea8c7fe4 100644
--- a/dlls/windows.devices.enumeration/collection.c
+++ b/dlls/windows.devices.enumeration/collection.c
@@ -27,6 +27,10 @@ WINE_DEFAULT_DEBUG_CHANNEL(enumeration);
 struct vectorview_DeviceInformation
 {
     IVectorView_DeviceInformation IVectorView_DeviceInformation_iface;
+
+    IDeviceInformation **devices;
+    SIZE_T len;
+
     LONG ref;
 };

@@ -76,7 +80,12 @@ static ULONG STDMETHODCALLTYPE vectorview_DeviceInformation_Release( IVectorView
     impl = impl_from_IVectorView_DeviceInformation( iface );
     ref = InterlockedDecrement( &impl->ref );
     if (!ref)
+    {
+        while (impl->len--)
+            IDeviceInformation_Release( impl->devices[impl->len] );
+        free( impl->devices );
         free( impl );
+    }
     return ref;
 }

@@ -105,15 +114,29 @@ static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_GetTrustLevel( IVe
 static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_GetAt( IVectorView_DeviceInformation *iface, UINT32 index,
                                                                      IDeviceInformation **value )
 {
-    FIXME( "(%p, %u, %p) stub!\n", iface, index, value );
-    return E_NOTIMPL;
+    struct vectorview_DeviceInformation *impl;
+
+    TRACE( "(%p, %u, %p)\n", iface, index, value );
+
+    impl = impl_from_IVectorView_DeviceInformation( iface );
+    *value = NULL;
+    if (index >= impl->len)
+        return E_BOUNDS;
+    *value = impl->devices[index];
+    IDeviceInformation_AddRef( *value );
+    return S_OK;
 }

static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_get_Size( IVectorView_DeviceInformation *iface,
                                                                         UINT32 *value )
 {
-    FIXME( "(%p, %p) stub!\n", iface, value );
-    return E_NOTIMPL;
+    struct vectorview_DeviceInformation *impl;
+
+    TRACE( "(%p, %p)\n", iface, value );
+
+    impl = impl_from_IVectorView_DeviceInformation( iface );
+    *value = impl->len;
+    return S_OK;
 }

static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_IndexOf( IVectorView_DeviceInformation *iface,
@@ -128,7 +151,7 @@ static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_GetMany( IVectorVi
                                                                        UINT32 start, UINT32 size,
                                                                        IDeviceInformation **items, UINT32 *copied )
 {
-    FIXME( "(%p, %u, %u, %p, %p): stub!\n", iface, start, size, items, copied );
+    FIXME( "(%p, %u, %u, %p, %p) stub!\n", iface, start, size, items, copied );
     return E_NOTIMPL;
 }

@@ -149,7 +172,8 @@ const static IVectorView_DeviceInformationVtbl vectorview_DeviceInformation_vtbl
     vectorview_DeviceInformation_GetMany
 };

-HRESULT vectorview_deviceinformation_create( IVectorView_DeviceInformation **view )
+HRESULT vectorview_deviceinformation_create( IDeviceInformation **devices, SIZE_T len,
+                                             IVectorView_DeviceInformation **view )
 {
     struct vectorview_DeviceInformation *impl;

@@ -158,6 +182,8 @@ HRESULT vectorview_deviceinformation_create( IVectorView_DeviceInformation **vie
         return E_OUTOFMEMORY;

impl->IVectorView_DeviceInformation_iface.lpVtbl = &vectorview_DeviceInformation_vtbl;
+    impl->devices = devices;
+    impl->len = len;
     impl->ref = 1;
     *view = &impl->IVectorView_DeviceInformation_iface;
     return S_OK;
diff --git a/dlls/windows.devices.enumeration/information.c b/dlls/windows.devices.enumeration/information.c
new file mode 100644
index 00000000000..b6e03f4fae8
--- /dev/null
+++ b/dlls/windows.devices.enumeration/information.c
@@ -0,0 +1,203 @@
+/* DeviceInformation implementation.
+ *
+ * Copyright 2024 Vibhav Pant
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include "private.h"
+
+#include <roapi.h>
+#include <setupapi.h>
+#include <cfgmgr32.h>
+
+#include <wine/debug.h>
+#include <wine/rbtree.h>
+
+WINE_DEFAULT_DEBUG_CHANNEL(enumeration);
+
+/* DeviceInformation implementation for objects with kind DeviceInformationKind_DeviceInterface. */
+struct devinfo_DeviceInterface
+{
+    IDeviceInformation IDeviceInformation_iface;
+    LONG ref;
+};
+
+static inline struct devinfo_DeviceInterface *impl_DeviceInterface_from_IDeviceInformation( IDeviceInformation *iface )
+{
+    return CONTAINING_RECORD( iface, struct devinfo_DeviceInterface, IDeviceInformation_iface );
+}
+
+static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_QueryInterface( IDeviceInformation *iface, REFIID iid,
+                                                                         void **out )
+{
+    TRACE( "(%p, %s, %p)\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
+        IsEqualGUID( iid, &IID_IDeviceInformation ))
+    {
+        IUnknown_AddRef( iface );
+        *out = iface;
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG STDMETHODCALLTYPE devinfo_DeviceInterface_AddRef( IDeviceInformation *iface )
+{
+    struct devinfo_DeviceInterface *impl;
+
+    TRACE( "(%p)\n", iface );
+
+    impl = impl_DeviceInterface_from_IDeviceInformation( iface );
+    return InterlockedIncrement( &impl->ref );
+}
+
+static ULONG STDMETHODCALLTYPE devinfo_DeviceInterface_Release( IDeviceInformation *iface )
+{
+    struct devinfo_DeviceInterface *impl;
+    ULONG ref;
+
+    TRACE( "(%p)\n", iface );
+
+    impl = impl_DeviceInterface_from_IDeviceInformation( iface );
+    ref = InterlockedDecrement( &impl->ref );
+    if (!ref)
+        free( impl );
+
+    return ref;
+}
+
+static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_GetIids( IDeviceInformation *iface,
+                                                                  ULONG *iid_count, IID **iids )
+{
+    FIXME( "(%p, %p, %p) stub!\n", iface, iid_count, iids );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI devinfo_DeviceInterface_GetRuntimeClassName( IDeviceInformation *iface, HSTRING *class_name )
+{
+    const static WCHAR *name = RuntimeClass_Windows_Devices_Enumeration_DeviceInformation;
+
+    TRACE( "(%p, %p)\n", iface, class_name );
+
+    return WindowsCreateString( name, wcslen( name ), class_name );
+}
+
+static HRESULT STDMETHODCALLTYPE device_information_GetTrustLevel(
+        IDeviceInformation *iface, TrustLevel *trust_level)
+{
+    FIXME("(%p, %p) stub!\n", iface, trust_level);
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_Id( IDeviceInformation *iface, HSTRING *id )
+{
+    FIXME( "(%p, %p) stub!\n", iface, id );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_Name( IDeviceInformation *iface, HSTRING *name )
+{
+    FIXME( "(%p, %p) stub!\n", iface, name );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_IsEnabled( IDeviceInformation *iface, boolean *value )
+{
+    FIXME( "(%p, %p) stub!\n", iface, value );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_IsDefault( IDeviceInformation *iface, boolean *value )
+{
+    FIXME( "(%p, %p) stub!\n", iface, value );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_EnclosureLocation( IDeviceInformation *iface,
+                                                                                IEnclosureLocation **location )
+{
+    FIXME( "(%p, %p) stub!\n", iface, location );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_Properties( IDeviceInformation *iface,
+                                                                         IMapView_HSTRING_IInspectable **properties )
+{
+    FIXME( "(%p, %p) stub!\n", iface, properties );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_Update( IDeviceInformation *iface,
+                                                                 IDeviceInformationUpdate *update )
+{
+    FIXME( "(%p, %p) stub!\n", iface, update );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_GetThumbnailAsync( IDeviceInformation *iface,
+                                                                            IAsyncOperation_DeviceThumbnail **async )
+{
+    FIXME( "(%p, %p) stub!\n", iface, async );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE
+devinfo_DeviceInterface_GetGlyphThumbnailAsync( IDeviceInformation *iface, IAsyncOperation_DeviceThumbnail **async )
+{
+    FIXME( "(%p, %p) stub!\n", iface, async );
+    return E_NOTIMPL;
+}
+
+static const struct IDeviceInformationVtbl devinfo_DeviceInterface_vtbl = {
+    /* IUnknown */
+    devinfo_DeviceInterface_QueryInterface,
+    devinfo_DeviceInterface_AddRef,
+    devinfo_DeviceInterface_Release,
+    /* IInspectable */
+    devinfo_DeviceInterface_GetIids,
+    devinfo_DeviceInterface_GetRuntimeClassName,
+    device_information_GetTrustLevel,
+    /* IDeviceInformation */
+    devinfo_DeviceInterface_get_Id,
+    devinfo_DeviceInterface_get_Name,
+    devinfo_DeviceInterface_get_IsEnabled,
+    devinfo_DeviceInterface_IsDefault,
+    devinfo_DeviceInterface_get_EnclosureLocation,
+    devinfo_DeviceInterface_get_Properties,
+    devinfo_DeviceInterface_Update,
+    devinfo_DeviceInterface_GetThumbnailAsync,
+    devinfo_DeviceInterface_GetGlyphThumbnailAsync,
+};
+
+HRESULT deviceinformation_iface_create( IDeviceInformation **info )
+{
+    struct devinfo_DeviceInterface *impl;
+
+    impl = calloc( 1, sizeof( *impl ) );
+    if (!impl)
+        return E_OUTOFMEMORY;
+
+    impl->IDeviceInformation_iface.lpVtbl = &devinfo_DeviceInterface_vtbl;
+    impl->ref = 1;
+    *info = &impl->IDeviceInformation_iface;
+    return S_OK;
+}
diff --git a/dlls/windows.devices.enumeration/main.c b/dlls/windows.devices.enumeration/main.c
index 0b705679283..8b198387155 100644
--- a/dlls/windows.devices.enumeration/main.c
+++ b/dlls/windows.devices.enumeration/main.c
@@ -335,17 +335,34 @@ static HRESULT WINAPI device_statics_CreateFromIdAsyncAdditionalProperties( IDev

static HRESULT WINAPI findall_async( IUnknown *invoker, IUnknown *param, PROPVARIANT *result )
 {
-    HRESULT hr;
+    IDeviceInformation **devices;
     IVectorView_DeviceInformation *view;
+    HRESULT hr = S_OK;

FIXME( "invoker %p, param %p, result %p semi-stub!\n", invoker, param, result );

-    hr = vectorview_deviceinformation_create( &view );
+    devices = calloc( 1, sizeof( *devices ) );
+    if (!devices)
+        return E_OUTOFMEMORY;
+
+    hr = deviceinformation_iface_create( &devices[0] );
+    if (FAILED( hr ))
+    {
+        free( devices );
+        return hr;
+    }
+
+    hr = vectorview_deviceinformation_create( devices, 1, &view );
     if (SUCCEEDED( hr ))
     {
         result->vt = VT_UNKNOWN;
         result->punkVal = (IUnknown *)view;
     }
+    else
+    {
+        IDeviceInformation_Release( devices[0] );
+        free( devices );
+    }
     return hr;
 }

diff --git a/dlls/windows.devices.enumeration/private.h b/dlls/windows.devices.enumeration/private.h
index 9e4ff6b20ea..585763fa744 100644
--- a/dlls/windows.devices.enumeration/private.h
+++ b/dlls/windows.devices.enumeration/private.h
@@ -51,7 +51,10 @@ typedef HRESULT (WINAPI *async_operation_callback)( IUnknown *invoker, IUnknown
 extern HRESULT async_operation_device_info_collection_result_create(
     IUnknown *invoker, IUnknown *param, async_operation_callback callback,
     IAsyncOperation_DeviceInformationCollection **out );
-extern HRESULT vectorview_deviceinformation_create( IVectorView_DeviceInformation **view );
+extern HRESULT vectorview_deviceinformation_create( IDeviceInformation **devices, SIZE_T len,
+                                                    IVectorView_DeviceInformation **view );
+extern HRESULT deviceinformation_iface_create( IDeviceInformation **info );
+
 #define DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from, iface_mem, expr )             \
     static inline impl_type *impl_from( iface_type *iface )                                        \
     {                                                                                              \
diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index 4a22a4dd34d..d656ca84320 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -485,7 +485,7 @@ static void test_DeviceInformation( void )
         IDeviceInformation **devices;

hr = IVectorView_DeviceInformation_get_Size( info_collection, &size );
-        todo_wine ok( SUCCEEDED( hr ), "got %#lx\n", hr );
+        ok( SUCCEEDED( hr ), "got %#lx\n", hr );
         for (idx = 0; idx < size ;idx++)
         {
             IDeviceInformation *info;
@@ -497,10 +497,10 @@ static void test_DeviceInformation( void )
                 UINT32 idx2 = 0;
                 boolean found = FALSE;

-                test_DeviceInformation_obj(__LINE__, info);
+                todo_wine test_DeviceInformation_obj(__LINE__, info);
                 IDeviceInformation_Release( info );
                 hr = IVectorView_DeviceInformation_IndexOf( info_collection, info, &idx2, &found );
-                ok( SUCCEEDED( hr ), "got %#lx\n", hr );
+                todo_wine ok( SUCCEEDED( hr ), "got %#lx\n", hr );
                 if (SUCCEEDED( hr ))
                 {
                     ok( found, "Expected IndexOf to return true\n" );

[PATCH 6/8] windows.devices.enumeration: Create IDeviceInformation objects from all present device interfaces.

[Vibhav Pant]

From: Vibhav Pant

---
 .../windows.devices.enumeration/information.c |  26 +++-
 dlls/windows.devices.enumeration/main.c       | 130 ++++++++++++++++--
 dlls/windows.devices.enumeration/private.h    |   3 +-
 .../tests/devices.c                           |   2 +-
 4 files changed, 141 insertions(+), 20 deletions(-)

diff --git a/dlls/windows.devices.enumeration/information.c b/dlls/windows.devices.enumeration/information.c
index b6e03f4fae8..82e1f6197ee 100644
--- a/dlls/windows.devices.enumeration/information.c
+++ b/dlls/windows.devices.enumeration/information.c
@@ -32,6 +32,10 @@ WINE_DEFAULT_DEBUG_CHANNEL(enumeration);
 struct devinfo_DeviceInterface
 {
     IDeviceInformation IDeviceInformation_iface;
+
+    WCHAR instance_id[MAX_DEVICE_ID_LEN];
+
+    HSTRING path;
     LONG ref;
 };

@@ -80,7 +84,10 @@ static ULONG STDMETHODCALLTYPE devinfo_DeviceInterface_Release( IDeviceInformati
     impl = impl_DeviceInterface_from_IDeviceInformation( iface );
     ref = InterlockedDecrement( &impl->ref );
     if (!ref)
+    {
+        WindowsDeleteString( impl->path );
         free( impl );
+    }

return ref;
 }
@@ -110,8 +117,12 @@ static HRESULT STDMETHODCALLTYPE device_information_GetTrustLevel(

static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_Id( IDeviceInformation *iface, HSTRING *id )
 {
-    FIXME( "(%p, %p) stub!\n", iface, id );
-    return E_NOTIMPL;
+    struct devinfo_DeviceInterface *impl;
+
+    TRACE( "(%p, %p)\n", iface, id );
+
+    impl = impl_DeviceInterface_from_IDeviceInformation( iface );
+    return WindowsDuplicateString( impl->path, id );
 }

static HRESULT STDMETHODCALLTYPE devinfo_DeviceInterface_get_Name( IDeviceInformation *iface, HSTRING *name )
@@ -188,15 +199,24 @@ static const struct IDeviceInformationVtbl devinfo_DeviceInterface_vtbl = {
     devinfo_DeviceInterface_GetGlyphThumbnailAsync,
 };

-HRESULT deviceinformation_iface_create( IDeviceInformation **info )
+HRESULT deviceinformation_iface_create( const SP_DEVICE_INTERFACE_DETAIL_DATA_W *iface_detail,
+                                        IDeviceInformation **info )
 {
     struct devinfo_DeviceInterface *impl;
+    HRESULT res;

impl = calloc( 1, sizeof( *impl ) );
     if (!impl)
         return E_OUTOFMEMORY;

impl->IDeviceInformation_iface.lpVtbl = &devinfo_DeviceInterface_vtbl;
+    res = WindowsCreateString( iface_detail->DevicePath, wcslen( iface_detail->DevicePath ),
+                               &impl->path );
+    if (FAILED( res ))
+    {
+        free( impl );
+        return res;
+    }
     impl->ref = 1;
     *info = &impl->IDeviceInformation_iface;
     return S_OK;
diff --git a/dlls/windows.devices.enumeration/main.c b/dlls/windows.devices.enumeration/main.c
index 8b198387155..3bdfb8dba8b 100644
--- a/dlls/windows.devices.enumeration/main.c
+++ b/dlls/windows.devices.enumeration/main.c
@@ -335,34 +335,134 @@ static HRESULT WINAPI device_statics_CreateFromIdAsyncAdditionalProperties( IDev

static HRESULT WINAPI findall_async( IUnknown *invoker, IUnknown *param, PROPVARIANT *result )
 {
-    IDeviceInformation **devices;
-    IVectorView_DeviceInformation *view;
+    IDeviceInformation **devices = NULL;
+    HKEY iface_key;
     HRESULT hr = S_OK;
+    SIZE_T devices_len = 0;
+    DWORD i;

-    FIXME( "invoker %p, param %p, result %p semi-stub!\n", invoker, param, result );
+    TRACE( "invoker %p, param %p, result %p\n", invoker, param, result );

-    devices = calloc( 1, sizeof( *devices ) );
-    if (!devices)
-        return E_OUTOFMEMORY;
-
-    hr = deviceinformation_iface_create( &devices[0] );
-    if (FAILED( hr ))
+    iface_key =
+        SetupDiOpenClassRegKeyExW( NULL, KEY_ENUMERATE_SUB_KEYS, DIOCR_INTERFACE, NULL, NULL );
+    if (!iface_key)
+        return HRESULT_FROM_WIN32( GetLastError() );
+    for (i = 0;SUCCEEDED( hr );i++)
     {
-        free( devices );
-        return hr;
+        WCHAR keyName[40];
+        DWORD keylen = 40;
+        GUID iface_class;
+        LSTATUS ret;
+        HDEVINFO devinfo;
+        DWORD j;
+
+        ret = RegEnumKeyExW( iface_key, i, keyName, &keylen, NULL, NULL, NULL, NULL );
+        if (ret == ERROR_NO_MORE_ITEMS)
+            break;
+        else if (ret)
+        {
+            hr = HRESULT_FROM_WIN32( ret );
+            break;
+        }
+        hr = CLSIDFromString( keyName, &iface_class );
+        if (FAILED( hr ))
+        {
+            ERR( "Could not parse interface GUID string %s: %#lx\n", debugstr_w( keyName ), hr );
+            continue;
+        }
+
+        devinfo = SetupDiGetClassDevsW( &iface_class, NULL, NULL, DIGCF_DEVICEINTERFACE );
+        if (devinfo == INVALID_HANDLE_VALUE)
+        {
+            DWORD err = GetLastError();
+            ERR( "Could not get device list for interface %s: %lu\n", debugstr_guid( &iface_class ), err );
+            hr = HRESULT_FROM_WIN32( err );
+            break;
+        }
+
+        for (j = 0; ;j++)
+        {
+
+            SP_DEVICE_INTERFACE_DATA iface_data = {0};
+            SP_DEVICE_INTERFACE_DETAIL_DATA_W *iface_detail_data;
+            SIZE_T size =
+                offsetof( SP_DEVICE_INTERFACE_DETAIL_DATA_W, DevicePath[MAX_PATH + 1] );
+            void *addr;
+            BOOL success;
+            IDeviceInformation *info;
+
+            iface_data.cbSize = sizeof( iface_data );
+            iface_detail_data = malloc( size );
+            if (!iface_detail_data)
+            {
+
+                hr = E_OUTOFMEMORY;
+                break;
+            }
+            iface_detail_data->cbSize = sizeof( *iface_detail_data );
+
+            success = SetupDiEnumDeviceInterfaces( devinfo, NULL, &iface_class, j,
+                                                   &iface_data );
+            if (!success)
+            {
+
+                DWORD err = GetLastError();
+                free( iface_detail_data );
+
+                if (err == ERROR_NO_MORE_ITEMS)
+                    break;
+                ERR( "Could not enumerate device interfaces: %lu\n", err );
+                    hr = HRESULT_FROM_WIN32( err );
+                    break;
+            }
+
+            success = SetupDiGetDeviceInterfaceDetailW( devinfo, &iface_data, iface_detail_data,
+                                                        size, NULL, NULL );
+            if (!success)
+            {
+
+                DWORD err = GetLastError();
+                free( iface_detail_data );
+                ERR( "Could not get interface details for %s: %lu\n",
+                     debugstr_guid( &iface_class ), err );
+                hr = HRESULT_FROM_WIN32( err );
+                    break;
+            }
+
+            hr = deviceinformation_iface_create( iface_detail_data, &info );
+            free( iface_detail_data );
+            if (FAILED( hr ))
+                break;
+
+            addr = realloc( devices, sizeof( *devices ) * (devices_len + 1) );
+            if (!addr)
+            {
+                IDeviceInformation_Release( info );
+                hr = E_OUTOFMEMORY;
+                break;
+            }
+            devices = addr;
+            devices[devices_len++] = info;
+        }
     }

-    hr = vectorview_deviceinformation_create( devices, 1, &view );
     if (SUCCEEDED( hr ))
     {
-        result->vt = VT_UNKNOWN;
-        result->punkVal = (IUnknown *)view;
+        IVectorView_DeviceInformation *view;
+        hr = vectorview_deviceinformation_create( devices, devices_len, &view );
+        if (SUCCEEDED( hr ))
+        {
+            result->vt = VT_UNKNOWN;
+            result->punkVal = (IUnknown *)view;
+        }
     }
     else
     {
-        IDeviceInformation_Release( devices[0] );
+        while (devices_len--)
+            IDeviceInformation_Release( devices[devices_len] );
         free( devices );
     }
+    RegCloseKey( iface_key );
     return hr;
 }

diff --git a/dlls/windows.devices.enumeration/private.h b/dlls/windows.devices.enumeration/private.h
index 585763fa744..71fed550a55 100644
--- a/dlls/windows.devices.enumeration/private.h
+++ b/dlls/windows.devices.enumeration/private.h
@@ -53,7 +53,8 @@ extern HRESULT async_operation_device_info_collection_result_create(
     IAsyncOperation_DeviceInformationCollection **out );
 extern HRESULT vectorview_deviceinformation_create( IDeviceInformation **devices, SIZE_T len,
                                                     IVectorView_DeviceInformation **view );
-extern HRESULT deviceinformation_iface_create( IDeviceInformation **info );
+extern HRESULT deviceinformation_iface_create( const SP_DEVICE_INTERFACE_DETAIL_DATA_W *iface_detail,
+                                               IDeviceInformation **info );

#define DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from, iface_mem, expr )             \
     static inline impl_type *impl_from( iface_type *iface )                                        \
diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index d656ca84320..eb865d8c5ba 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -497,7 +497,7 @@ static void test_DeviceInformation( void )
                 UINT32 idx2 = 0;
                 boolean found = FALSE;

-                todo_wine test_DeviceInformation_obj(__LINE__, info);
+                test_DeviceInformation_obj(__LINE__, info);
                 IDeviceInformation_Release( info );
                 hr = IVectorView_DeviceInformation_IndexOf( info_collection, info, &idx2, &found );
                 todo_wine ok( SUCCEEDED( hr ), "got %#lx\n", hr );

[PATCH 7/8] windows.devices.enumeration: Implement IndexOf() and GetMany() for DeviceInformationCollection.

[Vibhav Pant]

From: Vibhav Pant

---
 dlls/windows.devices.enumeration/collection.c | 40 +++++++++++++++++--
 .../tests/devices.c                           |  6 +--
 2 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/dlls/windows.devices.enumeration/collection.c b/dlls/windows.devices.enumeration/collection.c
index ac0ea8c7fe4..5b893735a42 100644
--- a/dlls/windows.devices.enumeration/collection.c
+++ b/dlls/windows.devices.enumeration/collection.c
@@ -143,16 +143,48 @@ static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_IndexOf( IVectorVi
                                                                        IDeviceInformation *elem, UINT32 *index,
                                                                        boolean *found )
 {
-    FIXME( "(%p, %p, %p, %p) stub!\n", iface, elem, index, found );
-    return E_NOTIMPL;
+    struct vectorview_DeviceInformation *impl;
+    UINT32 i;
+
+    TRACE( "(%p, %p, %p, %p)\n", iface, elem, index, found );
+
+    impl = impl_from_IVectorView_DeviceInformation( iface );
+    for (i = 0; i < impl->len; i++)
+        if (elem == impl->devices[i])
+            break;
+
+    if (i < impl->len)
+    {
+        *found = TRUE;
+        *index = i;
+    }
+    else
+    {
+        *found = FALSE;
+        *index = 0;
+    }
+
+    return S_OK;
 }

static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_GetMany( IVectorView_DeviceInformation *iface,
                                                                        UINT32 start, UINT32 size,
                                                                        IDeviceInformation **items, UINT32 *copied )
 {
-    FIXME( "(%p, %u, %u, %p, %p) stub!\n", iface, start, size, items, copied );
-    return E_NOTIMPL;
+    struct vectorview_DeviceInformation *impl;
+    UINT32 i;
+
+    TRACE( "(%p, %u, %u, %p, %p)\n", iface, start, size, items, copied );
+    impl = impl_from_IVectorView_DeviceInformation( iface );
+    memset( items, 0, size * sizeof( *items ) );
+
+    for (i = start; i < impl->len && i < start + size; i++)
+    {
+        items[i] = impl->devices[i - start];
+        IUnknown_AddRef( items[i] );
+    }
+    *copied = i - start;
+    return S_OK;
 }

const static IVectorView_DeviceInformationVtbl vectorview_DeviceInformation_vtbl =
diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index eb865d8c5ba..4d04e1582a9 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -500,7 +500,7 @@ static void test_DeviceInformation( void )
                 test_DeviceInformation_obj(__LINE__, info);
                 IDeviceInformation_Release( info );
                 hr = IVectorView_DeviceInformation_IndexOf( info_collection, info, &idx2, &found );
-                todo_wine ok( SUCCEEDED( hr ), "got %#lx\n", hr );
+                ok( SUCCEEDED( hr ), "got %#lx\n", hr );
                 if (SUCCEEDED( hr ))
                 {
                     ok( found, "Expected IndexOf to return true\n" );
@@ -517,9 +517,9 @@ static void test_DeviceInformation( void )
             UINT32 copied = 0;

hr = IVectorView_DeviceInformation_GetMany( info_collection, 0, size, devices, &copied );
-            todo_wine ok( SUCCEEDED( hr ), "got %#lx\n", hr );
+            ok( SUCCEEDED( hr ), "got %#lx\n", hr );
             if (SUCCEEDED( hr ))
-                todo_wine ok( copied == size, "%u != %u\n", copied, size );
+                ok( copied == size, "%u != %u\n", copied, size );
             for(idx = 0; idx < copied; idx++)
             {
                 IDeviceInformation *info = NULL;

[PATCH 8/8] windows.devices.enumeration: Implement IIterable<IDeviceInformation *> for DeviceInformationCollection.

[Vibhav Pant]

From: Vibhav Pant

---
 dlls/windows.devices.enumeration/collection.c | 197 ++++++++++++++++++
 .../tests/devices.c                           |   8 +-
 2 files changed, 201 insertions(+), 4 deletions(-)

diff --git a/dlls/windows.devices.enumeration/collection.c b/dlls/windows.devices.enumeration/collection.c
index 5b893735a42..8ca3bf9b77a 100644
--- a/dlls/windows.devices.enumeration/collection.c
+++ b/dlls/windows.devices.enumeration/collection.c
@@ -24,9 +24,159 @@

WINE_DEFAULT_DEBUG_CHANNEL(enumeration);

+struct iterator_DeviceInformation
+{
+    IIterator_DeviceInformation Iterator_DeviceInformation_iface;
+
+    IVectorView_DeviceInformation *IVectorView_DeviceInformation_iface;
+    UINT32 idx;
+    UINT32 len;
+    LONG ref;
+};
+
+static inline struct iterator_DeviceInformation *
+impl_from_Iterator_DeviceInformation( IIterator_DeviceInformation *iface )
+{
+    return CONTAINING_RECORD( iface, struct iterator_DeviceInformation, Iterator_DeviceInformation_iface );
+}
+
+static HRESULT STDMETHODCALLTYPE iterator_DeviceInformation_QueryInterface( IIterator_DeviceInformation *iface,
+                                                                            REFIID iid, void **out )
+{
+    TRACE( "(%p, %s, %p)\n", iface, debugstr_guid( iid ), out );
+
+    if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IInspectable ) ||
+        IsEqualGUID( iid, &IID_IIterator_DeviceInformation ))
+    {
+        IUnknown_AddRef( iface );
+        *out = iface;
+        return S_OK;
+    }
+
+    FIXME("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG STDMETHODCALLTYPE iterator_DeviceInformation_AddRef( IIterator_DeviceInformation *iface )
+{
+    struct iterator_DeviceInformation *impl;
+
+    TRACE( "(%p)\n", iface );
+
+    impl = impl_from_Iterator_DeviceInformation( iface );
+    return InterlockedIncrement( &impl->ref );
+}
+
+static ULONG STDMETHODCALLTYPE iterator_DeviceInformation_Release( IIterator_DeviceInformation *iface )
+{
+    struct iterator_DeviceInformation *impl;
+    ULONG ref;
+
+    TRACE( "(%p)\n", iface );
+
+    impl = impl_from_Iterator_DeviceInformation( iface );
+    ref = InterlockedDecrement( &impl->ref );
+    if (!ref)
+    {
+        IVectorView_DeviceInformation_Release( impl->IVectorView_DeviceInformation_iface );
+        free( impl );
+    }
+    return ref;
+}
+
+static HRESULT STDMETHODCALLTYPE iterator_DeviceInformation_GetIids( IIterator_DeviceInformation *iface,
+                                                                     ULONG *iid_count, IID **iids )
+{
+    FIXME( "(%p, %p, %p) stub!\n", iface, iid_count, iids );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI iterator_DeviceInformation_GetRuntimeClassName( IIterator_DeviceInformation *iface,
+                                                                      HSTRING *class_name )
+{
+    const static WCHAR name[] = L"Windows.Foundation.Collections.IIterator`1<Windows.Devices.Enumeration.DeviceInformation>";
+    TRACE( "(%p, %p)\n", iface, class_name );
+    return WindowsCreateString( name, ARRAY_SIZE( name ), class_name );
+}
+
+static HRESULT STDMETHODCALLTYPE iterator_DeviceInformation_GetTrustLevel( IIterator_DeviceInformation *iface,
+                                                                           TrustLevel *trust_level )
+{
+    FIXME( "(%p, %p) stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE iterator_DeviceInformation_get_Current( IIterator_DeviceInformation *iface,
+                                                                         IDeviceInformation **info )
+{
+    struct iterator_DeviceInformation *impl;
+
+    TRACE( "(%p, %p)\n", iface, info );
+
+    impl = impl_from_Iterator_DeviceInformation( iface );
+    return IVectorView_DeviceInformation_GetAt( impl->IVectorView_DeviceInformation_iface,
+                                                impl->idx, info );
+}
+
+static HRESULT STDMETHODCALLTYPE iterator_DeviceInformation_get_HasCurrent( IIterator_DeviceInformation *iface,
+                                                                            boolean *exists )
+{
+    struct iterator_DeviceInformation *impl;
+
+    TRACE( "(%p, %p)\n", iface, exists );
+
+    impl = impl_from_Iterator_DeviceInformation( iface );
+    *exists = impl->idx < impl->len;
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE iterator_DeviceInformation_MoveNext( IIterator_DeviceInformation *iface,
+                                                                      boolean *exists )
+{
+    struct iterator_DeviceInformation *impl;
+
+    TRACE( "(%p, %p)\n", iface, exists );
+
+    impl = impl_from_Iterator_DeviceInformation( iface );
+    if (impl->idx < impl->len) impl->idx++;
+    return IIterator_DeviceInformation_get_HasCurrent( iface, exists );
+}
+
+static HRESULT STDMETHODCALLTYPE iterator_DeviceInformation_GetMany( IIterator_DeviceInformation *iface, UINT32 size,
+                                                                     IDeviceInformation **info, UINT32 *copied )
+{
+    struct iterator_DeviceInformation *impl;
+
+    TRACE( "(%p, %u, %p, %p)\n", iface, size, info, copied );
+
+    impl = impl_from_Iterator_DeviceInformation( iface );
+    return IVectorView_DeviceInformation_GetMany( impl->IVectorView_DeviceInformation_iface,
+                                                  impl->idx, size, info, copied );
+}
+
+const static IIterator_DeviceInformationVtbl iterator_DeviceInformation_vtbl =
+{
+    /* IUnknown */
+    iterator_DeviceInformation_QueryInterface,
+    iterator_DeviceInformation_AddRef,
+    iterator_DeviceInformation_Release,
+    /* IInspectable */
+    iterator_DeviceInformation_GetIids,
+    iterator_DeviceInformation_GetRuntimeClassName,
+    iterator_DeviceInformation_GetTrustLevel,
+    /* IIterator<DeviceInformation> */
+    iterator_DeviceInformation_get_Current,
+    iterator_DeviceInformation_get_HasCurrent,
+    iterator_DeviceInformation_MoveNext,
+    iterator_DeviceInformation_GetMany,
+};
+
 struct vectorview_DeviceInformation
 {
     IVectorView_DeviceInformation IVectorView_DeviceInformation_iface;
+    IIterable_DeviceInformation IIterable_DeviceInformation_iface;

IDeviceInformation **devices;
     SIZE_T len;
@@ -54,6 +204,13 @@ static HRESULT STDMETHODCALLTYPE vectorview_DeviceInformation_QueryInterface(
         *out = iface;
         return S_OK;
     }
+    if (IsEqualGUID( iid, &IID_IIterable_DeviceInformation ))
+    {
+        struct vectorview_DeviceInformation *impl = impl_from_IVectorView_DeviceInformation( iface );
+        *out = &impl->IIterable_DeviceInformation_iface;
+        IUnknown_AddRef( iface );
+        return S_OK;
+    }

FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
     *out = NULL;
@@ -204,6 +361,45 @@ const static IVectorView_DeviceInformationVtbl vectorview_DeviceInformation_vtbl
     vectorview_DeviceInformation_GetMany
 };

+DEFINE_IINSPECTABLE( iterable_view_DeviceInformation, IIterable_DeviceInformation, struct vectorview_DeviceInformation,
+                     IVectorView_DeviceInformation_iface );
+
+static HRESULT STDMETHODCALLTYPE iterable_view_DeviceInformation_First( IIterable_DeviceInformation *iface,
+                                                                        IIterator_DeviceInformation **iter )
+
+{
+    struct vectorview_DeviceInformation *impl;
+    struct iterator_DeviceInformation *impl_iter;
+
+    TRACE( "(%p, %p)\n", iface, iter );
+
+    impl = impl_from_IIterable_DeviceInformation( iface );
+    impl_iter = calloc( 1, sizeof( *impl_iter ) );
+    if (!impl_iter)
+        return E_OUTOFMEMORY;
+    impl_iter->Iterator_DeviceInformation_iface.lpVtbl = &iterator_DeviceInformation_vtbl;
+    impl_iter->IVectorView_DeviceInformation_iface = &impl->IVectorView_DeviceInformation_iface;
+    IUnknown_AddRef( iface );
+    impl_iter->len = impl->len;
+    impl_iter->ref = 1;
+    *iter = &impl_iter->Iterator_DeviceInformation_iface;
+    return S_OK;
+}
+
+const static IIterable_DeviceInformationVtbl iterable_view_DeviceInformation_vtbl =
+{
+    /* IUnknown */
+    iterable_view_DeviceInformation_QueryInterface,
+    iterable_view_DeviceInformation_AddRef,
+    iterable_view_DeviceInformation_Release,
+    /* IInspectable */
+    iterable_view_DeviceInformation_GetIids,
+    iterable_view_DeviceInformation_GetRuntimeClassName,
+    iterable_view_DeviceInformation_GetTrustLevel,
+    /* IIterable<DeviceInformation> */
+    iterable_view_DeviceInformation_First,
+};
+
 HRESULT vectorview_deviceinformation_create( IDeviceInformation **devices, SIZE_T len,
                                              IVectorView_DeviceInformation **view )
 {
@@ -214,6 +410,7 @@ HRESULT vectorview_deviceinformation_create( IDeviceInformation **devices, SIZE_
         return E_OUTOFMEMORY;

impl->IVectorView_DeviceInformation_iface.lpVtbl = &vectorview_DeviceInformation_vtbl;
+    impl->IIterable_DeviceInformation_iface.lpVtbl = &iterable_view_DeviceInformation_vtbl;
     impl->devices = devices;
     impl->len = len;
     impl->ref = 1;
diff --git a/dlls/windows.devices.enumeration/tests/devices.c b/dlls/windows.devices.enumeration/tests/devices.c
index 4d04e1582a9..6ca74cbbc97 100644
--- a/dlls/windows.devices.enumeration/tests/devices.c
+++ b/dlls/windows.devices.enumeration/tests/devices.c
@@ -554,12 +554,12 @@ static void test_DeviceInformation( void )
         hr = IVectorView_DeviceInformation_QueryInterface(
             info_collection, &IID_IIterable_DeviceInformation, (void **)&info_iterable );
         IVectorView_DeviceInformation_Release( info_collection );
-        todo_wine ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+        ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
     }
     if (info_iterable)
     {
         hr = IIterable_DeviceInformation_First( info_iterable, &info_iterator );
-        todo_wine ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+        ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
         IIterable_DeviceInformation_Release( info_iterable );
     }
     if (info_iterator)
@@ -567,13 +567,13 @@ static void test_DeviceInformation( void )
         boolean exists;

hr = IIterator_DeviceInformation_get_HasCurrent( info_iterator, &exists );
-        todo_wine ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+        ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
         while (SUCCEEDED( hr ) && exists)
         {
             IDeviceInformation *info;

hr = IIterator_DeviceInformation_get_Current( info_iterator, &info );
-            todo_wine ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
+            ok( SUCCEEDED( hr ), "got hr %#lx\n", hr );
             if (FAILED( hr )) break;
             test_DeviceInformation_obj( __LINE__, info );
             IDeviceInformation_Release( info );

[PATCH 8/8] windows.devices.enumeration: Implement IIterable<IDeviceInformation *> for DeviceInformationCollection.

[Marvin]

Hi,

It looks like your patch introduced the new failures shown below.
Please investigate and fix them before resubmitting your patch.
If they are not new, fixing them anyway would help a lot. Otherwise
please ask for the known failures list to be updated.

The full results can be found at:
https://testbot.winehq.org/JobDetails.pl?Key=149837

Your paranoid android.

=== build (build log) ===

error: patch failed: dlls/windows.devices.enumeration/Makefile.in:1
error: patch failed: dlls/windows.devices.enumeration/main.c:333
error: patch failed: dlls/windows.devices.enumeration/private.h:28
error: patch failed: dlls/windows.devices.enumeration/tests/devices.c:472
error: patch failed: dlls/windows.devices.enumeration/Makefile.in:8
error: patch failed: dlls/windows.devices.enumeration/collection.c:27
error: patch failed: dlls/windows.devices.enumeration/main.c:335
error: patch failed: dlls/windows.devices.enumeration/private.h:51
error: patch failed: dlls/windows.devices.enumeration/main.c:335
error: patch failed: dlls/windows.devices.enumeration/private.h:53
error: patch failed: dlls/windows.devices.enumeration/collection.c:143
error: patch failed: dlls/windows.devices.enumeration/collection.c:24
Task: Patch failed to apply

=== debian11 (build log) ===

error: patch failed: dlls/windows.devices.enumeration/Makefile.in:1
error: patch failed: dlls/windows.devices.enumeration/main.c:333
error: patch failed: dlls/windows.devices.enumeration/private.h:28
error: patch failed: dlls/windows.devices.enumeration/tests/devices.c:472
error: patch failed: dlls/windows.devices.enumeration/Makefile.in:8
error: patch failed: dlls/windows.devices.enumeration/collection.c:27
error: patch failed: dlls/windows.devices.enumeration/main.c:335
error: patch failed: dlls/windows.devices.enumeration/private.h:51
error: patch failed: dlls/windows.devices.enumeration/main.c:335
error: patch failed: dlls/windows.devices.enumeration/private.h:53
error: patch failed: dlls/windows.devices.enumeration/collection.c:143
error: patch failed: dlls/windows.devices.enumeration/collection.c:24
Task: Patch failed to apply

=== debian11b (build log) ===

error: patch failed: dlls/windows.devices.enumeration/Makefile.in:1
error: patch failed: dlls/windows.devices.enumeration/main.c:333
error: patch failed: dlls/windows.devices.enumeration/private.h:28
error: patch failed: dlls/windows.devices.enumeration/tests/devices.c:472
error: patch failed: dlls/windows.devices.enumeration/Makefile.in:8
error: patch failed: dlls/windows.devices.enumeration/collection.c:27
error: patch failed: dlls/windows.devices.enumeration/main.c:335
error: patch failed: dlls/windows.devices.enumeration/private.h:51
error: patch failed: dlls/windows.devices.enumeration/main.c:335
error: patch failed: dlls/windows.devices.enumeration/private.h:53
error: patch failed: dlls/windows.devices.enumeration/collection.c:143
error: patch failed: dlls/windows.devices.enumeration/collection.c:24
Task: Patch failed to apply