[PATCH v3 0/4] MR8895: wintypes: Implement a generic IMap<HSTRING, IInspectable>.

[Vibhav Pant (＠vibhavp)]

--
  v3: wintypes: Implement a generic IMap<HSTRING, IInspectable>.
      wintypes/tests: Add tests for IMapView.
      wintypes: Introduce a generic IMap stub implementation.

https://gitlab.winehq.org/wine/wine/-/merge_requests/8895

[PATCH v3 1/4] wintypes/tests: Add tests for PropertySet::{Insert, Lookup, HasKey}.

[Vibhav Pant]

From: Vibhav Pant

---
 dlls/wintypes/tests/wintypes.c | 148 ++++++++++++++++++++++++++++++++-
 1 file changed, 146 insertions(+), 2 deletions(-)

diff --git a/dlls/wintypes/tests/wintypes.c b/dlls/wintypes/tests/wintypes.c
index ebdf5acbadf..81e7d65a494 100644
--- a/dlls/wintypes/tests/wintypes.c
+++ b/dlls/wintypes/tests/wintypes.c
@@ -1256,15 +1256,17 @@ static void test_IPropertySet(void)
 {
     static const WCHAR *class_name = RuntimeClass_Windows_Foundation_Collections_PropertySet;
     IActivationFactory *propset_factory;
-    IInspectable *inspectable;
+    IPropertyValueStatics *propval_statics;
+    IInspectable *inspectable, *val, *val1, *val2, *val3;
     IPropertySet *propset;
     IMap_HSTRING_IInspectable *map;
     IMapView_HSTRING_IInspectable *map_view;
     IObservableMap_HSTRING_IInspectable *observable_map;
     IIterable_IKeyValuePair_HSTRING_IInspectable *iterable;
     IIterator_IKeyValuePair_HSTRING_IInspectable *iterator;
+    BOOLEAN boolean;
     HRESULT hr;
-    HSTRING name;
+    HSTRING name, key1, key2;

hr = RoInitialize( RO_INIT_MULTITHREADED );
     ok( hr == S_OK, "got %#lx\n", hr );
@@ -1280,6 +1282,19 @@ static void test_IPropertySet(void)
         goto done;
     }

+    class_name = RuntimeClass_Windows_Foundation_PropertyValue;
+    hr = WindowsCreateString( class_name, wcslen( class_name ), &name );
+    ok( hr == S_OK, "got %#lx\n", hr );
+    hr = RoGetActivationFactory( name, &IID_IPropertyValueStatics, (void **)&propval_statics);
+    WindowsDeleteString( name );
+    ok( hr == S_OK || broken( hr == REGDB_E_CLASSNOTREG ), "RoGetActivationFactory failed, hr %#lx.\n", hr );
+    if (hr != S_OK)
+    {
+        win_skip( "%s runtimeclass not registered, skipping tests.\n", wine_dbgstr_w( class_name ) );
+        IActivationFactory_Release( propset_factory );
+        goto done;
+    }
+
     hr = IActivationFactory_ActivateInstance( propset_factory, &inspectable );
     IActivationFactory_Release( propset_factory );
     ok( hr == S_OK, "got %#lx\n", hr );
@@ -1296,6 +1311,134 @@ static void test_IPropertySet(void)
     IPropertySet_Release( propset );
     ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );

+    boolean = TRUE;
+    hr = IMap_HSTRING_IInspectable_HasKey( map, NULL, &boolean );
+    todo_wine
+    ok( hr == S_OK, "HasKey failed, got %#lx\n", hr );
+    todo_wine
+    ok( !boolean, "Got boolean %d.\n", boolean );
+    hr = IMap_HSTRING_IInspectable_Lookup( map, NULL, &val );
+    todo_wine
+    ok( hr == E_BOUNDS, "Got hr %#lx\n", hr );
+
+    hr = IPropertyValueStatics_CreateUInt32( propval_statics, 0xdeadbeef, &val1 );
+    ok( hr == S_OK, "CreateUInt32 failed, got %#lx\n", hr );
+    boolean = TRUE;
+    hr = IMap_HSTRING_IInspectable_Insert( map, NULL, val1, &boolean );
+    todo_wine
+    ok( hr == S_OK, "Insert failed, got %#lx\n", hr );
+    todo_wine
+    ok( !boolean, "Got boolean %d.\n", boolean );
+
+    hr = IPropertyValueStatics_CreateUInt32( propval_statics, 0xc0decafe, &val2 );
+    ok( hr == S_OK, "CreateUInt32 failed, got %#lx\n", hr );
+    boolean = FALSE;
+    hr = IMap_HSTRING_IInspectable_Insert( map, NULL, val2, &boolean );
+    IInspectable_Release( val2 );
+    todo_wine
+    ok( boolean, "Got boolean %d.\n", boolean );
+    todo_wine
+    ok( hr == S_OK, "Insert failed, got %#lx\n", hr );
+    boolean = FALSE;
+    hr = IMap_HSTRING_IInspectable_HasKey( map, NULL, &boolean );
+    todo_wine
+    ok( hr == S_OK, "HasKey failed, got %#lx\n", hr );
+    todo_wine
+    ok( boolean, "Got boolean %d.\n", boolean );
+    hr = IMap_HSTRING_IInspectable_Lookup( map, NULL, &val );
+    todo_wine
+    ok( hr == S_OK, "Lookup failed, got %#lx\n", hr );
+    if (SUCCEEDED(hr))
+    {
+        IPropertyValue *propval;
+        UINT32 uint32 = 0;
+
+        hr = IInspectable_QueryInterface( val, &IID_IPropertyValue, (void **)&propval );
+        IInspectable_Release( val );
+        ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
+        hr = IPropertyValue_GetUInt32( propval, &uint32 );
+        IPropertyValue_Release( propval );
+        ok( hr == S_OK, "GetUInt32, got %#lx\n", hr );
+        ok( uint32 == 0xc0decafe, "Got uint32 %u\n", uint32 );
+    }
+
+    hr = WindowsCreateString( L"foo", 3, &key1 );
+    ok( hr == S_OK, "WindowsCreateString failed, got %#lx\n", hr );
+    boolean = TRUE;
+    hr = IMap_HSTRING_IInspectable_Lookup( map, key1, &val );
+    todo_wine
+    ok( hr == E_BOUNDS, "Got hr %#lx\n", hr );
+    hr = IMap_HSTRING_IInspectable_Insert( map, key1, val1, &boolean );
+    IInspectable_Release( val1 );
+    todo_wine
+    ok( hr == S_OK, "Insert failed, got %#lx\n", hr );
+    todo_wine
+    ok( !boolean, "Got boolean %d.\n", boolean );
+    boolean = FALSE;
+    hr = IMap_HSTRING_IInspectable_HasKey( map, key1, &boolean );
+    todo_wine
+    ok( hr == S_OK, "HasKey failed, got %#lx\n", hr );
+    todo_wine
+    ok( boolean, "Got boolean %d.\n", boolean );
+    hr = IMap_HSTRING_IInspectable_Lookup( map, key1, &val );
+    todo_wine
+    ok( hr == S_OK, "Lookup failed, got %#lx\n", hr );
+    if (SUCCEEDED(hr))
+    {
+        IPropertyValue *propval;
+        UINT32 uint32 = 0;
+
+        hr = IInspectable_QueryInterface( val, &IID_IPropertyValue, (void **)&propval );
+        IInspectable_Release( val );
+        ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
+        hr = IPropertyValue_GetUInt32( propval, &uint32 );
+        IPropertyValue_Release( propval );
+        ok( hr == S_OK, "GetUInt32, got %#lx\n", hr );
+        ok( uint32 == 0xdeadbeef, "Got uint32 %u\n", uint32 );
+    }
+    WindowsDeleteString( key1 );
+
+    hr = WindowsCreateString( L"bar", 3, &key2 );
+    ok( hr == S_OK, "WindowsCreateString failed, got %#lx\n", hr );
+    boolean = TRUE;
+    hr = IMap_HSTRING_IInspectable_HasKey( map, key2, &boolean );
+    todo_wine
+    ok( hr == S_OK, "HasKey failed, got %#lx\n", hr );
+    todo_wine
+    ok( !boolean, "Got boolean %d.\n", boolean );
+    hr = IPropertyValueStatics_CreateUInt64( propval_statics, 0xdeadbeefdeadbeef, &val3 );
+    ok( hr == S_OK, "CreateUInt32 failed, got %#lx\n", hr );
+    boolean = TRUE;
+    hr = IMap_HSTRING_IInspectable_Insert( map, key2, val3, &boolean );
+    IInspectable_Release( val3 );
+    todo_wine
+    ok( hr == S_OK, "Insert failed, got %#lx\n", hr );
+    todo_wine
+    ok( !boolean, "Got boolean %d.\n", boolean );
+    boolean = FALSE;
+    hr = IMap_HSTRING_IInspectable_HasKey( map, key2, &boolean );
+    todo_wine
+    ok( hr == S_OK, "HasKey failed, got %#lx\n", hr );
+    todo_wine
+    ok( boolean, "Got boolean %d.\n", boolean );
+    hr = IMap_HSTRING_IInspectable_Lookup( map, key2, &val );
+    todo_wine
+    ok( hr == S_OK, "Lookup failed, got %#lx\n", hr );
+    if (SUCCEEDED(hr))
+    {
+        IPropertyValue *propval;
+        UINT64 uint64 = 0;
+
+        hr = IInspectable_QueryInterface( val, &IID_IPropertyValue, (void **)&propval );
+        IInspectable_Release( val );
+        ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
+        hr = IPropertyValue_GetUInt64( propval, &uint64 );
+        IPropertyValue_Release( propval );
+        ok( hr == S_OK, "GetUInt32, got %#lx\n", hr );
+        ok( uint64 == 0xdeadbeefdeadbeef, "Got uint64 %I64u\n", uint64 );
+    }
+    WindowsDeleteString( key2 );
+
     hr = IMap_HSTRING_IInspectable_QueryInterface( map, &IID_IIterable_IKeyValuePair_HSTRING_IInspectable,
                                                    (void **)&iterable );
     ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
@@ -1327,6 +1470,7 @@ static void test_IPropertySet(void)
         IMapView_HSTRING_IInspectable_Release( map_view );
     }
     IMap_HSTRING_IInspectable_Release( map );
+    IPropertyValueStatics_Release( propval_statics );
 done:
     RoUninitialize();
 }

[PATCH v3 2/4] wintypes: Introduce a generic IMap stub implementation.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/wintypes/Makefile.in          |   1 +
 dlls/wintypes/map.c                | 638 ++++++++++++++++++++++++++++
 dlls/wintypes/private.h            |  50 +++
 dlls/wintypes/propertyset.c        | 656 ++++++++++++++++++++++++-----
 dlls/wintypes/tests/wintypes.c     |  30 +-
 dlls/wintypes/wintypes_private.idl |  39 --
 6 files changed, 1256 insertions(+), 158 deletions(-)
 create mode 100644 dlls/wintypes/map.c

diff --git a/dlls/wintypes/Makefile.in b/dlls/wintypes/Makefile.in
index fd370133cf8..883d02f8b83 100644
--- a/dlls/wintypes/Makefile.in
+++ b/dlls/wintypes/Makefile.in
@@ -6,6 +6,7 @@ SOURCES = \
    buffer.c \
    classes.idl \
    main.c \
+	map.c \
    propertyset.c \
    storage.c \
    wintypes_private.idl
diff --git a/dlls/wintypes/map.c b/dlls/wintypes/map.c
new file mode 100644
index 00000000000..e49e933274a
--- /dev/null
+++ b/dlls/wintypes/map.c
@@ -0,0 +1,638 @@
+/*
+ * Copyright 2025 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
+ */
+
+#define COBJMACROS
+#include <winstring.h>
+#include <wine/debug.h>
+
+#include "private.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(combase);
+
+struct pair
+{
+    IKeyValuePair_HSTRING_IInspectable IKeyValuePair_HSTRING_IInspectable_iface;
+    const GUID *iid;
+    LONG ref;
+};
+
+static struct pair *impl_from_IKeyValuePair_HSTRING_IInspectable( IKeyValuePair_HSTRING_IInspectable *iface )
+{
+    return CONTAINING_RECORD( iface, struct pair, IKeyValuePair_HSTRING_IInspectable_iface );
+}
+
+static HRESULT WINAPI pair_QueryInterface( IKeyValuePair_HSTRING_IInspectable *iface, REFIID iid, void **out )
+{
+    struct pair *impl = impl_from_IKeyValuePair_HSTRING_IInspectable( 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, impl->iid ))
+    {
+        IInspectable_AddRef( (*out = &impl->IKeyValuePair_HSTRING_IInspectable_iface) );
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI pair_AddRef( IKeyValuePair_HSTRING_IInspectable *iface )
+{
+    struct pair *impl = impl_from_IKeyValuePair_HSTRING_IInspectable( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI pair_Release( IKeyValuePair_HSTRING_IInspectable *iface )
+{
+    struct pair *impl = impl_from_IKeyValuePair_HSTRING_IInspectable( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        free( impl );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI pair_GetIids( IKeyValuePair_HSTRING_IInspectable *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 pair_GetRuntimeClassName( IKeyValuePair_HSTRING_IInspectable *iface, HSTRING *class_name )
+{
+    FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI pair_GetTrustLevel( IKeyValuePair_HSTRING_IInspectable *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI pair_get_Key( IKeyValuePair_HSTRING_IInspectable *iface, HSTRING *value )
+{
+    FIXME( "iface %p, value %p stub!\n", iface, value );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI pair_get_Value( IKeyValuePair_HSTRING_IInspectable *iface, IInspectable **value )
+{
+    TRACE( "iface %p, value %p stub!\n", iface, value );
+    return E_NOTIMPL;
+}
+
+static const IKeyValuePair_HSTRING_IInspectableVtbl pair_vtbl =
+{
+    pair_QueryInterface,
+    pair_AddRef,
+    pair_Release,
+    /* IInspectable methods */
+    pair_GetIids,
+    pair_GetRuntimeClassName,
+    pair_GetTrustLevel,
+    /* IKeyValuePair<HSTRING,IInspectable*> methods */
+    pair_get_Key,
+    pair_get_Value,
+};
+
+static HRESULT pair_create( const GUID *iid, IKeyValuePair_HSTRING_IInspectable **out )
+{
+    struct pair *pair;
+
+    if (!(pair = calloc(1, sizeof(*pair)))) return E_OUTOFMEMORY;
+    pair->IKeyValuePair_HSTRING_IInspectable_iface.lpVtbl = &pair_vtbl;
+    pair->iid = iid;
+    pair->ref = 1;
+
+    return S_OK;
+}
+
+struct map_view
+{
+    IMapView_HSTRING_IInspectable IMapView_HSTRING_IInspectable_iface;
+    IIterable_IKeyValuePair_HSTRING_IInspectable IIterable_IKeyValuePair_HSTRING_IInspectable_iface;
+    struct map_iids iids;
+    LONG ref;
+};
+
+static struct map_view *impl_from_IMapView_HSTRING_IInspectable( IMapView_HSTRING_IInspectable *iface )
+{
+    return CONTAINING_RECORD( iface, struct map_view, IMapView_HSTRING_IInspectable_iface );
+}
+
+struct iterator
+{
+    IIterator_IKeyValuePair_HSTRING_IInspectable IIterator_IKeyValuePair_HSTRING_IInspectable_iface;
+    const GUID *iid;
+    LONG ref;
+
+    IMapView_HSTRING_IInspectable *view;
+};
+
+static struct iterator *impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( IIterator_IKeyValuePair_HSTRING_IInspectable *iface )
+{
+    return CONTAINING_RECORD( iface, struct iterator, IIterator_IKeyValuePair_HSTRING_IInspectable_iface );
+}
+
+static HRESULT WINAPI iterator_QueryInterface( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, REFIID iid, void **out )
+{
+    struct iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( 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, impl->iid ))
+    {
+        IInspectable_AddRef( (*out = &impl->IIterator_IKeyValuePair_HSTRING_IInspectable_iface) );
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI iterator_AddRef( IIterator_IKeyValuePair_HSTRING_IInspectable *iface )
+{
+    struct iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI iterator_Release( IIterator_IKeyValuePair_HSTRING_IInspectable *iface )
+{
+    struct iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        IMapView_HSTRING_IInspectable_Release( impl->view );
+        free( impl );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI iterator_GetIids( IIterator_IKeyValuePair_HSTRING_IInspectable *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 iterator_GetRuntimeClassName( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, HSTRING *class_name )
+{
+    FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI iterator_GetTrustLevel( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI iterator_get_Current( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, IKeyValuePair_HSTRING_IInspectable **value )
+{
+    struct iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    struct map_view *view = impl_from_IMapView_HSTRING_IInspectable( impl->view );
+    FIXME( "iface %p, value %p stub!\n", iface, value );
+    return pair_create( view->iids.pair, value );
+}
+
+static HRESULT WINAPI iterator_get_HasCurrent( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, boolean *value )
+{
+    TRACE( "iface %p, value %p stub!\n", iface, value );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI iterator_MoveNext( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, boolean *value )
+{
+    FIXME( "iface %p, value %p stub!\n", iface, value );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI iterator_GetMany( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, UINT32 items_size,
+                                        IKeyValuePair_HSTRING_IInspectable **items, UINT *count )
+{
+    FIXME( "iface %p, items_size %u, items %p, count %p stub!\n", iface, items_size, items, count );
+    return E_NOTIMPL;
+}
+
+static const IIterator_IKeyValuePair_HSTRING_IInspectableVtbl iterator_vtbl =
+{
+    iterator_QueryInterface,
+    iterator_AddRef,
+    iterator_Release,
+    /* IInspectable methods */
+    iterator_GetIids,
+    iterator_GetRuntimeClassName,
+    iterator_GetTrustLevel,
+    /* IIterator<IInspectable*> methods */
+    iterator_get_Current,
+    iterator_get_HasCurrent,
+    iterator_MoveNext,
+    iterator_GetMany,
+};
+
+static HRESULT WINAPI map_view_QueryInterface( IMapView_HSTRING_IInspectable *iface, REFIID iid, void **out )
+{
+    struct map_view *impl = impl_from_IMapView_HSTRING_IInspectable( 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, impl->iids.view ))
+    {
+        IInspectable_AddRef( (*out = &impl->IMapView_HSTRING_IInspectable_iface) );
+        return S_OK;
+    }
+
+    if (IsEqualGUID( iid, impl->iids.iterable ))
+    {
+        IInspectable_AddRef( (*out = &impl->IIterable_IKeyValuePair_HSTRING_IInspectable_iface) );
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI map_view_AddRef( IMapView_HSTRING_IInspectable *iface )
+{
+    struct map_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI map_view_Release( IMapView_HSTRING_IInspectable *iface )
+{
+    struct map_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
+
+    if (!ref) free( impl );
+    return ref;
+}
+
+static HRESULT WINAPI map_view_GetIids( IMapView_HSTRING_IInspectable *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 map_view_GetRuntimeClassName( IMapView_HSTRING_IInspectable *iface, HSTRING *class_name )
+{
+    FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI map_view_GetTrustLevel( IMapView_HSTRING_IInspectable *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI map_view_Lookup( IMapView_HSTRING_IInspectable *iface, HSTRING key, IInspectable **value )
+{
+    FIXME( "iface %p, key %s, value %p stub!\n", iface, debugstr_hstring( key ), value );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI map_view_get_Size( IMapView_HSTRING_IInspectable *iface, UINT32 *value )
+{
+    FIXME( "iface %p, value %p stub!\n", iface, value );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI map_view_HasKey( IMapView_HSTRING_IInspectable *iface, HSTRING key, boolean *found )
+{
+    FIXME( "iface %p, key %s, found %p stub!\n", iface, debugstr_hstring( key ), found );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI map_view_Split( IMapView_HSTRING_IInspectable *iface, IMapView_HSTRING_IInspectable **first,
+                                      IMapView_HSTRING_IInspectable **second )
+{
+    FIXME( "iface %p, first %p, second %p stub!\n", iface, first, second );
+    return E_NOTIMPL;
+}
+
+static const struct IMapView_HSTRING_IInspectableVtbl map_view_vtbl =
+{
+    map_view_QueryInterface,
+    map_view_AddRef,
+    map_view_Release,
+    /* IInspectable methods */
+    map_view_GetIids,
+    map_view_GetRuntimeClassName,
+    map_view_GetTrustLevel,
+    /* IMapView_HSTRING<IInspectable*> methods */
+    map_view_Lookup,
+    map_view_get_Size,
+    map_view_HasKey,
+    map_view_Split,
+};
+
+DEFINE_IINSPECTABLE_( iterable_view, IIterable_IKeyValuePair_HSTRING_IInspectable, struct map_view, view_impl_from_IIterable_IKeyValuePair_HSTRING_IInspectable,
+                      IIterable_IKeyValuePair_HSTRING_IInspectable_iface, &impl->IMapView_HSTRING_IInspectable_iface )
+
+static HRESULT WINAPI iterable_view_First( IIterable_IKeyValuePair_HSTRING_IInspectable *iface, IIterator_IKeyValuePair_HSTRING_IInspectable **value )
+{
+    struct map_view *impl = view_impl_from_IIterable_IKeyValuePair_HSTRING_IInspectable( iface );
+    struct iterator *iter;
+
+    TRACE( "iface %p, value %p.\n", iface, value );
+
+    if (!(iter = calloc( 1, sizeof(struct iterator) ))) return E_OUTOFMEMORY;
+    iter->IIterator_IKeyValuePair_HSTRING_IInspectable_iface.lpVtbl = &iterator_vtbl;
+    iter->iid = impl->iids.iterator;
+    iter->ref = 1;
+
+    IMapView_HSTRING_IInspectable_AddRef( (iter->view = &impl->IMapView_HSTRING_IInspectable_iface) );
+    *value = &iter->IIterator_IKeyValuePair_HSTRING_IInspectable_iface;
+    return S_OK;
+}
+
+static const struct IIterable_IKeyValuePair_HSTRING_IInspectableVtbl iterable_view_vtbl =
+{
+    iterable_view_QueryInterface,
+    iterable_view_AddRef,
+    iterable_view_Release,
+    /* IInspectable methods */
+    iterable_view_GetIids,
+    iterable_view_GetRuntimeClassName,
+    iterable_view_GetTrustLevel,
+    /* IIterable<T> methods */
+    iterable_view_First,
+};
+
+static HRESULT map_view_create( const struct map_iids *iids, IMapView_HSTRING_IInspectable **out )
+{
+    struct map_view *view;
+
+    if (!(view = calloc( 1, sizeof(*view) ))) return E_OUTOFMEMORY;
+    view->IMapView_HSTRING_IInspectable_iface.lpVtbl = &map_view_vtbl;
+    view->IIterable_IKeyValuePair_HSTRING_IInspectable_iface.lpVtbl = &iterable_view_vtbl;
+    view->iids = *iids;
+    view->ref = 1;
+
+    *out = &view->IMapView_HSTRING_IInspectable_iface;
+    return S_OK;
+}
+
+struct map
+{
+    IInspectable IInspectable_iface;
+    IMap_HSTRING_IInspectable IMap_HSTRING_IInspectable_iface;
+    IIterable_IKeyValuePair_HSTRING_IInspectable IIterable_IKeyValuePair_HSTRING_IInspectable_iface;
+    IInspectable *IInspectable_outer;
+    struct map_iids iids;
+    LONG ref;
+};
+
+static struct map *impl_from_IInspectable( IInspectable *iface )
+{
+    return CONTAINING_RECORD( iface, struct map, IInspectable_iface );
+}
+
+static HRESULT WINAPI map_inner_QueryInterface( IInspectable *iface, REFIID iid, void **out )
+{
+    struct map *impl = impl_from_IInspectable( 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 ))
+    {
+        IInspectable_AddRef( (*out = &impl->IInspectable_iface) );
+        return S_OK;
+    }
+
+    if (IsEqualGUID( iid, impl->iids.map ))
+    {
+        IInspectable_AddRef( (*out = &impl->IMap_HSTRING_IInspectable_iface) );
+        return S_OK;
+    }
+
+    if (IsEqualGUID( iid, impl->iids.iterable ))
+    {
+        IInspectable_AddRef( (*out = &impl->IIterable_IKeyValuePair_HSTRING_IInspectable_iface) );
+        return S_OK;
+    }
+
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    *out = NULL;
+    return E_NOINTERFACE;
+}
+
+static ULONG WINAPI map_inner_AddRef( IInspectable *iface )
+{
+    struct map *impl = impl_from_IInspectable( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG WINAPI map_inner_Release( IInspectable *iface )
+{
+    struct map *impl = impl_from_IInspectable( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        IMap_HSTRING_IInspectable_Clear( &impl->IMap_HSTRING_IInspectable_iface );
+        free( impl );
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI map_inner_GetIids( IInspectable *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 map_inner_GetRuntimeClassName( IInspectable *iface, HSTRING *class_name )
+{
+    FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI map_inner_GetTrustLevel( IInspectable *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+const static IInspectableVtbl map_inner_vtbl =
+{
+    /* IUnknown */
+    map_inner_QueryInterface,
+    map_inner_AddRef,
+    map_inner_Release,
+    /* IInspectable */
+    map_inner_GetIids,
+    map_inner_GetRuntimeClassName,
+    map_inner_GetTrustLevel,
+};
+
+DEFINE_IINSPECTABLE_OUTER( map, IMap_HSTRING_IInspectable, struct map, IInspectable_outer )
+
+static HRESULT WINAPI map_Lookup( IMap_HSTRING_IInspectable *iface, HSTRING key, IInspectable **value )
+{
+    FIXME( "iface %p, key %s, value %p stub!\n", iface, debugstr_hstring( key ), value );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI map_get_Size( IMap_HSTRING_IInspectable *iface, UINT32 *size )
+{
+    FIXME( "iface %p, size %p stub!\n", iface, size );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI map_HasKey( IMap_HSTRING_IInspectable *iface, HSTRING key, boolean *exists )
+{
+    FIXME( "iface %p, key %s, exists %p stub!\n", iface, debugstr_hstring( key ), exists );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI map_GetView( IMap_HSTRING_IInspectable *iface, IMapView_HSTRING_IInspectable **value )
+{
+    struct map *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    TRACE( "iface %p, value %p.\n", iface, value );
+    return map_view_create( &impl->iids, value );
+}
+
+static HRESULT WINAPI map_Insert( IMap_HSTRING_IInspectable *iface, HSTRING key, IInspectable *value, boolean *replaced )
+{
+    FIXME( "iface %p, key %p, value %p, replaced %p stub!\n", iface, key, value, replaced );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI map_Remove( IMap_HSTRING_IInspectable *iface, HSTRING key )
+{
+    FIXME( "iface %p, key %s stub!\n", iface, debugstr_hstring( key ) );
+    return E_NOTIMPL;
+}
+
+static HRESULT WINAPI map_Clear( IMap_HSTRING_IInspectable *iface )
+{
+    FIXME( "iface %p stub!\n", iface );
+    return E_NOTIMPL;
+}
+
+const static IMap_HSTRING_IInspectableVtbl map_vtbl =
+{
+    /* IUnknown */
+    map_QueryInterface,
+    map_AddRef,
+    map_Release,
+    /* IInspectable */
+    map_GetIids,
+    map_GetRuntimeClassName,
+    map_GetTrustLevel,
+    /* IMap<HSTRING, IInspectable *> */
+    map_Lookup,
+    map_get_Size,
+    map_HasKey,
+    map_GetView,
+    map_Insert,
+    map_Remove,
+    map_Clear,
+};
+
+DEFINE_IINSPECTABLE_OUTER( iterable, IIterable_IKeyValuePair_HSTRING_IInspectable, struct map, IInspectable_outer )
+
+static HRESULT WINAPI iterable_First( IIterable_IKeyValuePair_HSTRING_IInspectable *iface, IIterator_IKeyValuePair_HSTRING_IInspectable **value )
+{
+    struct map *impl = impl_from_IIterable_IKeyValuePair_HSTRING_IInspectable( iface );
+    IIterable_IKeyValuePair_HSTRING_IInspectable *iterable;
+    IMapView_HSTRING_IInspectable *view;
+    HRESULT hr;
+
+    TRACE( "iface %p, value %p.\n", iface, value );
+
+    if (FAILED(hr = IMap_HSTRING_IInspectable_GetView( &impl->IMap_HSTRING_IInspectable_iface, &view ))) return hr;
+
+    hr = IMapView_HSTRING_IInspectable_QueryInterface( view, impl->iids.iterable, (void **)&iterable );
+    IMapView_HSTRING_IInspectable_Release( view );
+    if (FAILED(hr)) return hr;
+
+    hr = IIterable_IKeyValuePair_HSTRING_IInspectable_First( iterable, value );
+    IIterable_IKeyValuePair_HSTRING_IInspectable_Release( iterable );
+    return hr;
+}
+
+static const struct IIterable_IKeyValuePair_HSTRING_IInspectableVtbl iterable_vtbl =
+{
+    iterable_QueryInterface,
+    iterable_AddRef,
+    iterable_Release,
+    /* IInspectable methods */
+    iterable_GetIids,
+    iterable_GetRuntimeClassName,
+    iterable_GetTrustLevel,
+    /* IIterable<T> methods */
+    iterable_First,
+};
+
+HRESULT map_create( const struct map_iids *iids, IInspectable *outer, void **out )
+{
+    struct map *impl;
+
+    TRACE( "iid %s, out %p.\n", debugstr_guid( iids->map ), out );
+
+    if (!(impl = calloc( 1, sizeof(*impl) ))) return E_OUTOFMEMORY;
+    impl->IInspectable_iface.lpVtbl = &map_inner_vtbl;
+    impl->IMap_HSTRING_IInspectable_iface.lpVtbl = &map_vtbl;
+    impl->IIterable_IKeyValuePair_HSTRING_IInspectable_iface.lpVtbl = &iterable_vtbl;
+    impl->IInspectable_outer = outer ? outer : (IInspectable *)&impl->IInspectable_iface;
+    impl->iids = *iids;
+    impl->ref = 1;
+
+    *out = &impl->IInspectable_iface;
+    TRACE( "created %p\n", *out );
+    return S_OK;
+}
diff --git a/dlls/wintypes/private.h b/dlls/wintypes/private.h
index fe9e8cb951c..898b68c441b 100644
--- a/dlls/wintypes/private.h
+++ b/dlls/wintypes/private.h
@@ -39,6 +39,56 @@
 #include "windows.storage.streams.h"
 #include "wintypes_private.h"

+struct map_iids
+{
+    const GUID *map;
+    const GUID *view;
+    const GUID *iterable;
+    const GUID *iterator;
+    const GUID *pair;
+};
+extern HRESULT map_create( const struct map_iids *iids, IInspectable *outer, void **out );
+
 extern IActivationFactory *data_writer_activation_factory;
 extern IActivationFactory *buffer_activation_factory;
 extern IActivationFactory *property_set_factory;
+
+#define DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from, iface_mem, expr )             \
+    static inline impl_type *impl_from( iface_type *iface )                                        \
+    {                                                                                              \
+        return CONTAINING_RECORD( iface, impl_type, iface_mem );                                   \
+    }                                                                                              \
+    static HRESULT WINAPI pfx##_QueryInterface( iface_type *iface, REFIID iid, void **out )        \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_QueryInterface( (IInspectable *)(expr), iid, out );                    \
+    }                                                                                              \
+    static ULONG WINAPI pfx##_AddRef( iface_type *iface )                                          \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_AddRef( (IInspectable *)(expr) );                                      \
+    }                                                                                              \
+    static ULONG WINAPI pfx##_Release( iface_type *iface )                                         \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_Release( (IInspectable *)(expr) );                                     \
+    }                                                                                              \
+    static HRESULT WINAPI pfx##_GetIids( iface_type *iface, ULONG *iid_count, IID **iids )         \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_GetIids( (IInspectable *)(expr), iid_count, iids );                    \
+    }                                                                                              \
+    static HRESULT WINAPI pfx##_GetRuntimeClassName( iface_type *iface, HSTRING *class_name )      \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_GetRuntimeClassName( (IInspectable *)(expr), class_name );             \
+    }                                                                                              \
+    static HRESULT WINAPI pfx##_GetTrustLevel( iface_type *iface, TrustLevel *trust_level )        \
+    {                                                                                              \
+        impl_type *impl = impl_from( iface );                                                      \
+        return IInspectable_GetTrustLevel( (IInspectable *)(expr), trust_level );                  \
+    }
+#define DEFINE_IINSPECTABLE( pfx, iface_type, impl_type, base_iface )                              \
+    DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from_##iface_type, iface_type##_iface, &impl->base_iface )
+#define DEFINE_IINSPECTABLE_OUTER( pfx, iface_type, impl_type, outer_iface )                       \
+    DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from_##iface_type, iface_type##_iface, impl->outer_iface )
diff --git a/dlls/wintypes/propertyset.c b/dlls/wintypes/propertyset.c
index 6a0ccc30c2b..52f345766ce 100644
--- a/dlls/wintypes/propertyset.c
+++ b/dlls/wintypes/propertyset.c
@@ -32,6 +32,9 @@ struct propertyset
     IObservableMap_HSTRING_IInspectable IObservableMap_HSTRING_IInspectable_iface;
     IMap_HSTRING_IInspectable IMap_HSTRING_IInspectable_iface;
     IIterable_IKeyValuePair_HSTRING_IInspectable IIterable_IKeyValuePair_HSTRING_IInspectable_iface;
+    SRWLOCK lock;
+    IMap_HSTRING_IInspectable *map; /* Guarded by lock */
+    IIterable_IKeyValuePair_HSTRING_IInspectable *iterable; /* Guarded by lock */
     LONG ref;
 };

@@ -40,6 +43,356 @@ static inline struct propertyset *impl_from_IPropertySet( IPropertySet *iface )
     return CONTAINING_RECORD( iface, struct propertyset, IPropertySet_iface );
 }

+struct propertyset_view
+{
+    IMapView_HSTRING_IInspectable IMapView_HSTRING_IInspectable_iface;
+    IIterable_IKeyValuePair_HSTRING_IInspectable IIterable_IKeyValuePair_HSTRING_IInspectable_iface;
+    struct propertyset *set;
+    IMapView_HSTRING_IInspectable *view;
+    IIterable_IKeyValuePair_HSTRING_IInspectable *view_iterable;
+    LONG ref;
+};
+
+static inline struct propertyset_view *impl_from_IMapView_HSTRING_IInspectable( IMapView_HSTRING_IInspectable *iface )
+{
+    return CONTAINING_RECORD( iface, struct propertyset_view, IMapView_HSTRING_IInspectable_iface );
+}
+
+struct propertyset_iterator
+{
+    IIterator_IKeyValuePair_HSTRING_IInspectable IIterator_IKeyValuePair_HSTRING_IInspectable_iface;
+    struct propertyset *set;
+    IIterator_IKeyValuePair_HSTRING_IInspectable *iterator;
+    LONG ref;
+};
+
+static inline struct propertyset_iterator *impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( IIterator_IKeyValuePair_HSTRING_IInspectable *iface )
+{
+    return CONTAINING_RECORD( iface, struct propertyset_iterator, IIterator_IKeyValuePair_HSTRING_IInspectable_iface );
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_iterator_QueryInterface( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, REFIID iid, void **out )
+{
+    struct propertyset_iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+
+    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_IIterator_IKeyValuePair_HSTRING_IInspectable ))
+    {
+        IIterator_IKeyValuePair_HSTRING_IInspectable_AddRef(( *out = &impl->IIterator_IKeyValuePair_HSTRING_IInspectable_iface ));
+        return S_OK;
+    }
+
+    *out = NULL;
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    return S_OK;
+}
+
+static ULONG STDMETHODCALLTYPE propertyset_iterator_AddRef( IIterator_IKeyValuePair_HSTRING_IInspectable *iface )
+{
+    struct propertyset_iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG STDMETHODCALLTYPE propertyset_iterator_Release( IIterator_IKeyValuePair_HSTRING_IInspectable *iface )
+{
+    struct propertyset_iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        IIterator_IKeyValuePair_HSTRING_IInspectable_Release( impl->iterator );
+        IPropertySet_Release( &impl->set->IPropertySet_iface );
+        free( impl );
+    }
+    return ref;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_iterator_GetIids( IIterator_IKeyValuePair_HSTRING_IInspectable *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 STDMETHODCALLTYPE propertyset_iterator_GetRuntimeClassName( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, HSTRING *class_name )
+{
+    FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_iterator_GetTrustLevel( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_iterator_get_Current( IIterator_IKeyValuePair_HSTRING_IInspectable *iface,
+                                                                   IKeyValuePair_HSTRING_IInspectable **value )
+{
+    struct propertyset_iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    HRESULT hr;
+
+    TRACE( "iface %p, value %p\n", iface, value );
+
+    AcquireSRWLockShared( &impl->set->lock );
+    hr = IIterator_IKeyValuePair_HSTRING_IInspectable_get_Current( impl->iterator, value );
+    ReleaseSRWLockShared( &impl->set->lock );
+    return hr;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_iterator_get_HasCurrent( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, boolean *value )
+{
+    struct propertyset_iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    HRESULT hr;
+
+    TRACE( "iface %p, value %p\n", iface, value );
+
+    AcquireSRWLockShared( &impl->set->lock );
+    hr = IIterator_IKeyValuePair_HSTRING_IInspectable_get_HasCurrent( impl->iterator, value );
+    ReleaseSRWLockShared( &impl->set->lock );
+    return hr;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_iterator_MoveNext( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, boolean *value )
+{
+    struct propertyset_iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, value %p\n", iface, value );
+
+    AcquireSRWLockShared( &impl->set->lock );
+    hr = IIterator_IKeyValuePair_HSTRING_IInspectable_MoveNext( impl->iterator, value );
+    ReleaseSRWLockShared( &impl->set->lock );
+    return hr;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_iterator_GetMany( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, UINT32 items_size,
+                                                               IKeyValuePair_HSTRING_IInspectable **items, UINT *count )
+{
+    struct propertyset_iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    HRESULT hr;
+
+    TRACE( "iface %p, items_size %u, items %p, count %p\n", iface, items_size, items, count );
+
+    AcquireSRWLockShared( &impl->set->lock );
+    hr = IIterator_IKeyValuePair_HSTRING_IInspectable_GetMany( impl->iterator, items_size, items, count );
+    ReleaseSRWLockShared( &impl->set->lock );
+    return hr;
+}
+
+static const IIterator_IKeyValuePair_HSTRING_IInspectableVtbl propertyset_IIterator_vtbl =
+{
+    /* IUnknown */
+    propertyset_iterator_QueryInterface,
+    propertyset_iterator_AddRef,
+    propertyset_iterator_Release,
+    /* IInspectable */
+    propertyset_iterator_GetIids,
+    propertyset_iterator_GetRuntimeClassName,
+    propertyset_iterator_GetTrustLevel,
+    /* IIterable*/
+    propertyset_iterator_get_Current,
+    propertyset_iterator_get_HasCurrent,
+    propertyset_iterator_MoveNext,
+    propertyset_iterator_GetMany
+};
+
+static HRESULT create_propertyset_iterator( struct propertyset *set, IIterable_IKeyValuePair_HSTRING_IInspectable *iterable,
+                                            IIterator_IKeyValuePair_HSTRING_IInspectable **out )
+{
+    struct propertyset_iterator *impl;
+    HRESULT hr;
+
+    *out = NULL;
+    if (!(impl = calloc( 1, sizeof( *impl )))) return E_OUTOFMEMORY;
+
+    impl->IIterator_IKeyValuePair_HSTRING_IInspectable_iface.lpVtbl = &propertyset_IIterator_vtbl;
+    impl->ref = 1;
+    impl->set = set;
+    IPropertySet_AddRef( &set->IPropertySet_iface );
+    AcquireSRWLockShared( &set->lock );
+    hr = IIterable_IKeyValuePair_HSTRING_IInspectable_First( iterable, &impl->iterator );
+    ReleaseSRWLockShared( &set->lock );
+    if (FAILED(hr))
+    {
+        IPropertySet_Release( &set->IPropertySet_iface );
+        free( impl );
+        return hr;
+    }
+    *out = &impl->IIterator_IKeyValuePair_HSTRING_IInspectable_iface;
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_view_QueryInterface( IMapView_HSTRING_IInspectable *iface, REFIID iid, void **out )
+{
+    struct propertyset_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+
+    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_IMapView_HSTRING_IInspectable ))
+    {
+        IMapView_HSTRING_IInspectable_AddRef(( *out = &impl->IMapView_HSTRING_IInspectable_iface ));
+        return S_OK;
+    }
+    if (IsEqualGUID( iid, &IID_IIterable_IKeyValuePair_HSTRING_IInspectable ))
+    {
+        IIterable_IKeyValuePair_HSTRING_IInspectable_AddRef(( *out = &impl->IIterable_IKeyValuePair_HSTRING_IInspectable_iface ));
+        return S_OK;
+    }
+
+    *out = NULL;
+    FIXME( "%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid( iid ) );
+    return S_OK;
+}
+
+static ULONG STDMETHODCALLTYPE propertyset_view_AddRef( IMapView_HSTRING_IInspectable *iface )
+{
+    struct propertyset_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
+}
+
+static ULONG STDMETHODCALLTYPE propertyset_view_Release( IMapView_HSTRING_IInspectable *iface )
+{
+    struct propertyset_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+    ULONG ref = InterlockedDecrement( &impl->ref );
+
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );
+
+    if (!ref)
+    {
+        IMapView_HSTRING_IInspectable_Release( impl->view );
+        IIterable_IKeyValuePair_HSTRING_IInspectable_Release( impl->view_iterable );
+        IPropertySet_Release( &impl->set->IPropertySet_iface );
+        free( impl );
+    }
+    return ref;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_view_GetIids( IMapView_HSTRING_IInspectable *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 STDMETHODCALLTYPE propertyset_view_GetRuntimeClassName( IMapView_HSTRING_IInspectable *iface, HSTRING *class_name )
+{
+    FIXME( "iface %p, class_name %p stub!\n", iface, class_name );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_view_GetTrustLevel( IMapView_HSTRING_IInspectable *iface, TrustLevel *trust_level )
+{
+    FIXME( "iface %p, trust_level %p stub!\n", iface, trust_level );
+    return E_NOTIMPL;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_view_Lookup( IMapView_HSTRING_IInspectable *iface, HSTRING key, IInspectable **value )
+{
+    struct propertyset_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+    HRESULT hr;
+
+    TRACE( "iface %p, key %s, value %p\n", iface, debugstr_hstring( key ), value );
+
+    AcquireSRWLockShared( &impl->set->lock );
+    hr = IMapView_HSTRING_IInspectable_Lookup( impl->view, key, value );
+    ReleaseSRWLockShared( &impl->set->lock );
+    return hr;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_view_get_Size( IMapView_HSTRING_IInspectable *iface, UINT32 *value )
+{
+    struct propertyset_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+    HRESULT hr = S_OK;
+
+    TRACE( "iface %p, value %p\n", iface, value );
+
+    AcquireSRWLockShared( &impl->set->lock );
+    hr = IMapView_HSTRING_IInspectable_get_Size( impl->view, value );
+    ReleaseSRWLockShared( &impl->set->lock );
+    return hr;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_view_HasKey( IMapView_HSTRING_IInspectable *iface, HSTRING key, boolean *found )
+{
+    struct propertyset_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+    HRESULT hr;
+
+    TRACE( "iface %p, key %s, found %p\n", iface, debugstr_hstring( key ), found );
+
+    AcquireSRWLockShared( &impl->set->lock );
+    hr = IMapView_HSTRING_IInspectable_HasKey( impl->view, key, found );
+    ReleaseSRWLockShared( &impl->set->lock );
+    return hr;
+}
+
+static HRESULT STDMETHODCALLTYPE propertyset_view_Split( IMapView_HSTRING_IInspectable *iface, IMapView_HSTRING_IInspectable **first,
+                                                         IMapView_HSTRING_IInspectable **second )
+{
+    struct propertyset_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+    HRESULT hr;
+
+    TRACE( "iface %p, first %p, second %p\n", iface, first, second );
+
+    AcquireSRWLockShared( &impl->set->lock );
+    hr = IMapView_HSTRING_IInspectable_Split( impl->view, first, second);
+    ReleaseSRWLockShared( &impl->set->lock );
+    return hr;
+}
+
+DEFINE_IINSPECTABLE_( propertyset_view_iterable, IIterable_IKeyValuePair_HSTRING_IInspectable, struct propertyset_view,
+                      view_impl_from_IIterable_IKeyValuePair_HSTRING_IInspectable, IIterable_IKeyValuePair_HSTRING_IInspectable_iface,
+                      &impl->IMapView_HSTRING_IInspectable_iface );
+
+static HRESULT STDMETHODCALLTYPE propertyset_view_iterable_First( IIterable_IKeyValuePair_HSTRING_IInspectable *iface,
+                                                                  IIterator_IKeyValuePair_HSTRING_IInspectable **value )
+{
+    struct propertyset_view *impl = view_impl_from_IIterable_IKeyValuePair_HSTRING_IInspectable( iface );
+    TRACE( "iface %p, value %p\n", iface, value );
+    return create_propertyset_iterator( impl->set, impl->view_iterable, value );
+}
+
+static const struct IIterable_IKeyValuePair_HSTRING_IInspectableVtbl propertyset_view_IIterable_vtbl =
+{
+    /* IUnknown */
+    propertyset_view_iterable_QueryInterface,
+    propertyset_view_iterable_AddRef,
+    propertyset_view_iterable_Release,
+    /* IInspectable */
+    propertyset_view_iterable_GetIids,
+    propertyset_view_iterable_GetRuntimeClassName,
+    propertyset_view_iterable_GetTrustLevel,
+    /* IIterable_HSTRING_IInspectable */
+    propertyset_view_iterable_First
+};
+
+static const IMapView_HSTRING_IInspectableVtbl propertyset_view_vtbl =
+{
+    /* IUnknown */
+    propertyset_view_QueryInterface,
+    propertyset_view_AddRef,
+    propertyset_view_Release,
+    /* IMapView_HSTRING_IInspectable */
+    propertyset_view_GetIids,
+    propertyset_view_GetRuntimeClassName,
+    propertyset_view_GetTrustLevel,
+    propertyset_view_Lookup,
+    propertyset_view_get_Size,
+    propertyset_view_HasKey,
+    propertyset_view_Split,
+};
+
 static HRESULT STDMETHODCALLTYPE propertyset_QueryInterface( IPropertySet *iface, REFIID iid, void **out )
 {
     struct propertyset *impl = impl_from_IPropertySet( iface );
@@ -48,6 +401,7 @@ static HRESULT STDMETHODCALLTYPE propertyset_QueryInterface( IPropertySet *iface

*out = NULL;
     if (IsEqualGUID( iid, &IID_IUnknown ) ||
+        IsEqualGUID( iid, &IID_IAgileObject ) ||
         IsEqualGUID( iid, &IID_IInspectable ) ||
         IsEqualGUID( iid, &IID_IPropertySet ))
     {
@@ -64,13 +418,13 @@ static HRESULT STDMETHODCALLTYPE propertyset_QueryInterface( IPropertySet *iface
     else if (IsEqualGUID( iid, &IID_IMap_HSTRING_IInspectable ))
     {
         *out = &impl->IMap_HSTRING_IInspectable_iface;
-        IUnknown_AddRef( (IUnknown *)iface );
+        IUnknown_AddRef( (IUnknown *)*out );
         return S_OK;
     }
     else if (IsEqualGUID( iid, &IID_IIterable_IKeyValuePair_HSTRING_IInspectable ))
     {
         *out = &impl->IIterable_IKeyValuePair_HSTRING_IInspectable_iface;
-        IUnknown_AddRef( (IUnknown *)iface );
+        IUnknown_AddRef( (IUnknown *)*out );
         return S_OK;
     }

@@ -81,22 +435,25 @@ static HRESULT STDMETHODCALLTYPE propertyset_QueryInterface( IPropertySet *iface
 static ULONG STDMETHODCALLTYPE propertyset_AddRef( IPropertySet *iface )
 {
     struct propertyset *impl = impl_from_IPropertySet( iface );
-
-    TRACE( "(%p)\n", iface );
-
-    return InterlockedIncrement( &impl->ref );
+    ULONG ref = InterlockedIncrement( &impl->ref );
+    TRACE( "iface %p increasing refcount to %lu.\n", iface, ref );
+    return ref;
 }

static ULONG STDMETHODCALLTYPE propertyset_Release( IPropertySet *iface )
 {
     struct propertyset *impl = impl_from_IPropertySet( iface );
-    ULONG ref;
+    ULONG ref = InterlockedDecrement( &impl->ref );

-    TRACE( "(%p)\n", iface );
+    TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );

-    ref = InterlockedDecrement( &impl->ref );
     if (!ref)
+    {
+        IMap_HSTRING_IInspectable_Release( impl->map );
+        IIterable_IKeyValuePair_HSTRING_IInspectable_Release( impl->iterable );
         free( impl );
+    }
+
     return ref;
 }

@@ -118,137 +475,209 @@ static HRESULT STDMETHODCALLTYPE propertyset_GetTrustLevel( IPropertySet *iface,
     return E_NOTIMPL;
 }

-static const IPropertySetVtbl propertyset_vtbl =
+DEFINE_IINSPECTABLE_( propertyset_map, IMap_HSTRING_IInspectable, struct propertyset, impl_from_IMap_HSTRING_IInspectable, IMap_HSTRING_IInspectable_iface,
+                      &impl->IPropertySet_iface )
+
+static HRESULT STDMETHODCALLTYPE propertyset_map_Lookup( IMap_HSTRING_IInspectable *iface, HSTRING key, IInspectable **value )
 {
-    /* IUnknown */
-    propertyset_QueryInterface,
-    propertyset_AddRef,
-    propertyset_Release,
-    /* IInspectable */
-    propertyset_GetIids,
-    propertyset_GetRuntimeClassName,
-    propertyset_GetTrustLevel,
-};
+    struct propertyset *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    HRESULT hr;

-DEFINE_IINSPECTABLE( propertyset_IObservableMap, IObservableMap_HSTRING_IInspectable, struct propertyset, IPropertySet_iface );
+    TRACE( "iface %p, key %s, value %p\n", iface, debugstr_hstring( key ), value );

-static HRESULT STDMETHODCALLTYPE propertyset_IObservableMap_add_MapChanged( IObservableMap_HSTRING_IInspectable *iface,
-                                                                            IMapChangedEventHandler_HSTRING_IInspectable *handler,
-                                                                            EventRegistrationToken *token )
-{
-    FIXME( "(%p, %p, %p) stub!\n", iface, handler, token );
-    return E_NOTIMPL;
+    AcquireSRWLockShared( &impl->lock );
+    hr = IMap_HSTRING_IInspectable_Lookup( impl->map, key, value );
+    ReleaseSRWLockShared( &impl->lock );
+    return hr;
 }

-static HRESULT STDMETHODCALLTYPE propertyset_IObservableMap_remove_MapChanged( IObservableMap_HSTRING_IInspectable *iface, EventRegistrationToken token )
+static HRESULT STDMETHODCALLTYPE propertyset_map_get_Size( IMap_HSTRING_IInspectable *iface, UINT32 *size )
 {
-    FIXME( "(%p, %I64d) stub!\n", iface, token.value );
-    return E_NOTIMPL;
+    struct propertyset *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    HRESULT hr;
+
+    TRACE( "iface %p, size %p\n", iface, size );
+
+    AcquireSRWLockShared( &impl->lock );
+    hr = IMap_HSTRING_IInspectable_get_Size( impl->map, size );
+    ReleaseSRWLockShared( &impl->lock );
+    return hr;
 }

-const static IObservableMap_HSTRING_IInspectableVtbl propertyset_IObservableMap_vtbl =
+static HRESULT STDMETHODCALLTYPE propertyset_map_HasKey( IMap_HSTRING_IInspectable *iface, HSTRING key, boolean *exists )
 {
-    /* IUnknown */
-    propertyset_IObservableMap_QueryInterface,
-    propertyset_IObservableMap_AddRef,
-    propertyset_IObservableMap_Release,
-    /* IInspectable */
-    propertyset_IObservableMap_GetIids,
-    propertyset_IObservableMap_GetRuntimeClassName,
-    propertyset_IObservableMap_GetTrustLevel,
-    /* IObservableMap<HSTRING, IInspectable*> */
-    propertyset_IObservableMap_add_MapChanged,
-    propertyset_IObservableMap_remove_MapChanged,
-};
+    struct propertyset *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    HRESULT hr;

-DEFINE_IINSPECTABLE( propertyset_IMap, IMap_HSTRING_IInspectable, struct propertyset,
-                     IPropertySet_iface );
+    TRACE( "iface %p, key %s, exists %p\n", iface, debugstr_hstring( key ), exists );

-static HRESULT STDMETHODCALLTYPE propertyset_Lookup( IMap_HSTRING_IInspectable *iface, HSTRING key, IInspectable **value )
-{
-    FIXME( "(%p, %s, %p) stub!\n", iface, debugstr_hstring( key ), value );
-    return E_NOTIMPL;
+    AcquireSRWLockShared( &impl->lock );
+    hr = IMap_HSTRING_IInspectable_HasKey( impl->map, key, exists );
+    ReleaseSRWLockShared( &impl->lock );
+    return hr;
 }

-static HRESULT STDMETHODCALLTYPE propertyset_get_Size( IMap_HSTRING_IInspectable *iface, UINT32 *size )
+static HRESULT STDMETHODCALLTYPE propertyset_map_GetView( IMap_HSTRING_IInspectable *iface, IMapView_HSTRING_IInspectable **value )
 {
-    FIXME( "(%p, %p) stub!\n", iface, size );
-    return E_NOTIMPL;
+    struct propertyset *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    struct propertyset_view *view;
+    HRESULT hr;
+
+    TRACE( "iface %p, value %p.\n", iface, value );
+
+    if (!(view = calloc( 1, sizeof(*view) ))) return E_OUTOFMEMORY;
+    view->IMapView_HSTRING_IInspectable_iface.lpVtbl = &propertyset_view_vtbl;
+    view->IIterable_IKeyValuePair_HSTRING_IInspectable_iface.lpVtbl = &propertyset_view_IIterable_vtbl;
+    view->ref = 1;
+    view->set = impl;
+    IPropertySet_AddRef( &view->set->IPropertySet_iface );
+    AcquireSRWLockShared( &impl->lock );
+    hr = IMap_HSTRING_IInspectable_GetView( impl->map, &view->view );
+    ReleaseSRWLockShared( &impl->lock );
+    if (FAILED(hr))
+    {
+        IPropertySet_Release( &view->set->IPropertySet_iface );
+        free( view );
+        return hr;
+    }
+    hr = IMapView_HSTRING_IInspectable_QueryInterface( view->view, &IID_IIterable_IKeyValuePair_HSTRING_IInspectable, (void **)&view->view_iterable );
+    if (FAILED(hr))
+    {
+        IMapView_HSTRING_IInspectable_Release( view->view );
+        IPropertySet_Release( &view->set->IPropertySet_iface );
+        free( view );
+        return hr;
+    }
+    *value = &view->IMapView_HSTRING_IInspectable_iface;
+    return S_OK;
 }

-static HRESULT STDMETHODCALLTYPE propertyset_HasKey( IMap_HSTRING_IInspectable *iface, HSTRING key, boolean *exists )
+static HRESULT STDMETHODCALLTYPE propertymap_map_Insert( IMap_HSTRING_IInspectable *iface, HSTRING key, IInspectable *value, boolean *replaced )
 {
-    FIXME( "(%p, %s, %p) stub!\n", iface, debugstr_hstring( key ), exists );
-    return E_NOTIMPL;
+    struct propertyset *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    HRESULT hr;
+
+    TRACE( "iface %p, key %p, value %p, replaced %p\n", iface, key, value, replaced );
+
+    AcquireSRWLockExclusive( &impl->lock );
+    hr = IMap_HSTRING_IInspectable_Insert( impl->map, key, value, replaced );
+    ReleaseSRWLockExclusive( &impl->lock );
+    return hr;
 }

-static HRESULT STDMETHODCALLTYPE propertyset_GetView( IMap_HSTRING_IInspectable *iface, IMapView_HSTRING_IInspectable **view )
+static HRESULT STDMETHODCALLTYPE propertyset_map_Remove( IMap_HSTRING_IInspectable *iface, HSTRING key )
 {
-    FIXME( "(%p, %p) stub!\n", iface, view );
-    return E_NOTIMPL;
+    struct propertyset *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    HRESULT hr;
+
+    TRACE( "iface %p, key %s\n", iface, debugstr_hstring( key ) );
+
+    AcquireSRWLockExclusive( &impl->lock );
+    hr = IMap_HSTRING_IInspectable_Remove( impl->map, key );
+    ReleaseSRWLockExclusive( &impl->lock );
+    return hr;
 }

-static HRESULT STDMETHODCALLTYPE propertyset_Insert( IMap_HSTRING_IInspectable *iface, HSTRING key, IInspectable *value, boolean *replaced )
+static HRESULT STDMETHODCALLTYPE propertyset_map_Clear( IMap_HSTRING_IInspectable *iface )
 {
-    FIXME( "(%p, %s, %p, %p) stub!\n", iface, debugstr_hstring( key ), value, replaced );
-    return E_NOTIMPL;
+    struct propertyset *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    HRESULT hr;
+
+    TRACE( "iface %p\n", iface );
+
+    AcquireSRWLockExclusive( &impl->lock );
+    hr = IMap_HSTRING_IInspectable_Clear( impl->map );
+    ReleaseSRWLockExclusive( &impl->lock );
+    return hr;
 }

-static HRESULT STDMETHODCALLTYPE propertyset_Remove( IMap_HSTRING_IInspectable *iface, HSTRING key )
+static const IMap_HSTRING_IInspectableVtbl propertyset_IMap_vtbl =
 {
-    FIXME( "(%p, %s) stub!\n", iface, debugstr_hstring( key ) );
-    return E_NOTIMPL;
-}
+    /* IUnknown */
+    propertyset_map_QueryInterface,
+    propertyset_map_AddRef,
+    propertyset_map_Release,
+    /* IInspectable */
+    propertyset_map_GetIids,
+    propertyset_map_GetRuntimeClassName,
+    propertyset_map_GetTrustLevel,
+    /* IMap_HSTRING_IInspectable */
+    propertyset_map_Lookup,
+    propertyset_map_get_Size,
+    propertyset_map_HasKey,
+    propertyset_map_GetView,
+    propertymap_map_Insert,
+    propertyset_map_Remove,
+    propertyset_map_Clear
+};
+
+DEFINE_IINSPECTABLE_( propertyset_map_iterable, IIterable_IKeyValuePair_HSTRING_IInspectable, struct propertyset,
+                      map_impl_from_IIterable_IKeyValuePair_HSTRING_IInspectable, IIterable_IKeyValuePair_HSTRING_IInspectable_iface,
+                      &impl->IPropertySet_iface )

-static HRESULT STDMETHODCALLTYPE propertyset_Clear( IMap_HSTRING_IInspectable *iface )
+static HRESULT STDMETHODCALLTYPE propertyset_map_iterable_First( IIterable_IKeyValuePair_HSTRING_IInspectable *iface,
+                                                                 IIterator_IKeyValuePair_HSTRING_IInspectable **value )
 {
-    FIXME( "(%p) stub!\n", iface );
-    return E_NOTIMPL;
+    struct propertyset *impl = map_impl_from_IIterable_IKeyValuePair_HSTRING_IInspectable( iface );
+    TRACE( "iface %p, value %p\n", iface, value );
+    return create_propertyset_iterator( impl, impl->iterable, value );
 }

-const static IMap_HSTRING_IInspectableVtbl propertyset_IMap_vtbl =
+static const IIterable_IKeyValuePair_HSTRING_IInspectableVtbl propertyset_IIterable_vtbl =
 {
     /* IUnknown */
-    propertyset_IMap_QueryInterface,
-    propertyset_IMap_AddRef,
-    propertyset_IMap_Release,
+    propertyset_map_iterable_QueryInterface,
+    propertyset_map_iterable_AddRef,
+    propertyset_map_iterable_Release,
     /* IInspectable */
-    propertyset_IMap_GetIids,
-    propertyset_IMap_GetRuntimeClassName,
-    propertyset_IMap_GetTrustLevel,
-    /* IMap<HSTRING, IInspectable*> */
-    propertyset_Lookup,
-    propertyset_get_Size,
-    propertyset_HasKey,
-    propertyset_GetView,
-    propertyset_Insert,
-    propertyset_Remove,
-    propertyset_Clear,
+    propertyset_map_iterable_GetIids,
+    propertyset_map_iterable_GetRuntimeClassName,
+    propertyset_map_iterable_GetTrustLevel,
+    /* IIterable_IKeyValuePair_HSTRING_IInspectable */
+    propertyset_map_iterable_First,
 };

-DEFINE_IINSPECTABLE_( iterable_kvpair_HSTRING_IInspectable, IIterable_IKeyValuePair_HSTRING_IInspectable, struct propertyset,
-                      impl_from_IIterable_IKeyValuePair_HSTRING_IInspectable, IIterable_IKeyValuePair_HSTRING_IInspectable_iface,
-                      &impl->IMap_HSTRING_IInspectable_iface );
+static const IPropertySetVtbl propertyset_vtbl =
+{
+    /* IUnknown */
+    propertyset_QueryInterface,
+    propertyset_AddRef,
+    propertyset_Release,
+    /* IInspectable */
+    propertyset_GetIids,
+    propertyset_GetRuntimeClassName,
+    propertyset_GetTrustLevel,
+};
+
+DEFINE_IINSPECTABLE( propertyset_IObservableMap, IObservableMap_HSTRING_IInspectable, struct propertyset, IPropertySet_iface );
+
+static HRESULT STDMETHODCALLTYPE propertyset_IObservableMap_add_MapChanged( IObservableMap_HSTRING_IInspectable *iface,
+                                                                            IMapChangedEventHandler_HSTRING_IInspectable *handler,
+                                                                            EventRegistrationToken *token )
+{
+    FIXME( "(%p, %p, %p) stub!\n", iface, handler, token );
+    return E_NOTIMPL;
+}

-static HRESULT STDMETHODCALLTYPE iterable_kvpair_HSTRING_IInspectable_First( IIterable_IKeyValuePair_HSTRING_IInspectable *iface,
-                                                                             IIterator_IKeyValuePair_HSTRING_IInspectable **iter )
+static HRESULT STDMETHODCALLTYPE propertyset_IObservableMap_remove_MapChanged( IObservableMap_HSTRING_IInspectable *iface, EventRegistrationToken token )
 {
-    FIXME( "(%p, %p) stub!\n", iface, iter );
+    FIXME( "(%p, %I64d) stub!\n", iface, token.value );
     return E_NOTIMPL;
 }

-const static IIterable_IKeyValuePair_HSTRING_IInspectableVtbl iterable_kvpair_HSTRING_IInspectable_vtbl =
+const static IObservableMap_HSTRING_IInspectableVtbl propertyset_IObservableMap_vtbl =
 {
     /* IUnknown */
-    iterable_kvpair_HSTRING_IInspectable_QueryInterface,
-    iterable_kvpair_HSTRING_IInspectable_AddRef,
-    iterable_kvpair_HSTRING_IInspectable_Release,
+    propertyset_IObservableMap_QueryInterface,
+    propertyset_IObservableMap_AddRef,
+    propertyset_IObservableMap_Release,
     /* IInspectable */
-    iterable_kvpair_HSTRING_IInspectable_GetIids,
-    iterable_kvpair_HSTRING_IInspectable_GetRuntimeClassName,
-    iterable_kvpair_HSTRING_IInspectable_GetTrustLevel,
-    /* IIterable<IKeyValuePair<HSTRING, IInspectable*>> */
-    iterable_kvpair_HSTRING_IInspectable_First
+    propertyset_IObservableMap_GetIids,
+    propertyset_IObservableMap_GetRuntimeClassName,
+    propertyset_IObservableMap_GetTrustLevel,
+    /* IObservableMap<HSTRING, IInspectable*> */
+    propertyset_IObservableMap_add_MapChanged,
+    propertyset_IObservableMap_remove_MapChanged,
 };

struct propertyset_factory
@@ -314,7 +743,18 @@ static HRESULT STDMETHODCALLTYPE factory_GetTrustLevel( IActivationFactory *ifac

static HRESULT STDMETHODCALLTYPE factory_ActivateInstance( IActivationFactory *iface, IInspectable **instance )
 {
+    static const struct map_iids iids =
+    {
+        .map = &IID_IMap_HSTRING_IInspectable,
+        .view = &IID_IMapView_HSTRING_IInspectable,
+        .iterable = &IID_IIterable_IKeyValuePair_HSTRING_IInspectable,
+        .iterator = &IID_IIterator_IKeyValuePair_HSTRING_IInspectable,
+        .pair = &IID_IKeyValuePair_HSTRING_IInspectable,
+    };
+
     struct propertyset *impl;
+    IInspectable *map;
+    HRESULT hr;

TRACE( "(%p, %p)\n", iface, instance );

@@ -325,8 +765,28 @@ static HRESULT STDMETHODCALLTYPE factory_ActivateInstance( IActivationFactory *i
     impl->IPropertySet_iface.lpVtbl = &propertyset_vtbl;
     impl->IObservableMap_HSTRING_IInspectable_iface.lpVtbl = &propertyset_IObservableMap_vtbl;
     impl->IMap_HSTRING_IInspectable_iface.lpVtbl = &propertyset_IMap_vtbl;
-    impl->IIterable_IKeyValuePair_HSTRING_IInspectable_iface.lpVtbl = &iterable_kvpair_HSTRING_IInspectable_vtbl;
+    impl->IIterable_IKeyValuePair_HSTRING_IInspectable_iface.lpVtbl = &propertyset_IIterable_vtbl;
     impl->ref = 1;
+    InitializeSRWLock( &impl->lock );
+
+    if (FAILED(hr = map_create( &iids, NULL, (void **)&map )))
+    {
+        free( impl );
+        return hr;
+    }
+    hr = IInspectable_QueryInterface( map, &IID_IMap_HSTRING_IInspectable, (void **)&impl->map );
+    IInspectable_Release( map );
+    if (FAILED( hr ))
+    {
+        free( impl );
+        return hr;
+    }
+    if (FAILED(hr = IMap_HSTRING_IInspectable_QueryInterface( impl->map, &IID_IIterable_IKeyValuePair_HSTRING_IInspectable, (void **)&impl->iterable )))
+    {
+        IMap_HSTRING_IInspectable_Release( impl->map );
+        free( impl );
+        return hr;
+    }
     *instance = (IInspectable *)&impl->IPropertySet_iface;
     return S_OK;
 }
diff --git a/dlls/wintypes/tests/wintypes.c b/dlls/wintypes/tests/wintypes.c
index 81e7d65a494..8a54a6b2d17 100644
--- a/dlls/wintypes/tests/wintypes.c
+++ b/dlls/wintypes/tests/wintypes.c
@@ -1443,32 +1443,20 @@ static void test_IPropertySet(void)
                                                    (void **)&iterable );
     ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
     hr = IIterable_IKeyValuePair_HSTRING_IInspectable_First( iterable, &iterator );
-    todo_wine
     ok( hr == S_OK, "got %#lx\n", hr );
-    if (SUCCEEDED( hr ))
-        IIterator_IKeyValuePair_HSTRING_IInspectable_Release( iterator );
+    IIterator_IKeyValuePair_HSTRING_IInspectable_Release( iterator );
     IIterable_IKeyValuePair_HSTRING_IInspectable_Release( iterable );

hr = IMap_HSTRING_IInspectable_GetView( map, &map_view );
-    todo_wine
     ok( hr == S_OK, "GetView failed, got %#lx\n", hr );
-    if (SUCCEEDED( hr ))
-    {
-        hr = IMapView_HSTRING_IInspectable_QueryInterface( map_view, &IID_IIterable_IKeyValuePair_HSTRING_IInspectable,
-                                                           (void **)&iterable );
-        todo_wine
-        ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
-        if (SUCCEEDED( hr ))
-        {
-            hr = IIterable_IKeyValuePair_HSTRING_IInspectable_First( iterable, &iterator );
-            todo_wine
-            ok( hr == S_OK, "got %#lx\n", hr );
-            if (SUCCEEDED( hr ))
-                IIterator_IKeyValuePair_HSTRING_IInspectable_Release( iterator );
-            IIterable_IKeyValuePair_HSTRING_IInspectable_Release( iterable );
-        }
-        IMapView_HSTRING_IInspectable_Release( map_view );
-    }
+    hr = IMapView_HSTRING_IInspectable_QueryInterface( map_view, &IID_IIterable_IKeyValuePair_HSTRING_IInspectable,
+                                                       (void **)&iterable );
+    ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
+    hr = IIterable_IKeyValuePair_HSTRING_IInspectable_First( iterable, &iterator );
+    ok( hr == S_OK, "got %#lx\n", hr );
+    IIterator_IKeyValuePair_HSTRING_IInspectable_Release( iterator );
+    IIterable_IKeyValuePair_HSTRING_IInspectable_Release( iterable );
+    IMapView_HSTRING_IInspectable_Release( map_view );
     IMap_HSTRING_IInspectable_Release( map );
     IPropertyValueStatics_Release( propval_statics );
 done:
diff --git a/dlls/wintypes/wintypes_private.idl b/dlls/wintypes/wintypes_private.idl
index b0d7b7d2241..33cfbed210b 100644
--- a/dlls/wintypes/wintypes_private.idl
+++ b/dlls/wintypes/wintypes_private.idl
@@ -27,42 +27,3 @@ import "windows.foundation.idl";
 declare {
     interface Windows.Foundation.IReference<HSTRING>;
 }
-
-cpp_quote("#define DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from, iface_mem, expr )             \")
-cpp_quote("    static inline impl_type *impl_from( iface_type *iface )                                        \")
-cpp_quote("    {                                                                                              \")
-cpp_quote("        return CONTAINING_RECORD( iface, impl_type, iface_mem );                                   \")
-cpp_quote("    }                                                                                              \")
-cpp_quote("    static HRESULT WINAPI pfx##_QueryInterface( iface_type *iface, REFIID iid, void **out )        \")
-cpp_quote("    {                                                                                              \")
-cpp_quote("        impl_type *impl = impl_from( iface );                                                      \")
-cpp_quote("        return IInspectable_QueryInterface( (IInspectable *)(expr), iid, out );                    \")
-cpp_quote("    }                                                                                              \")
-cpp_quote("    static ULONG WINAPI pfx##_AddRef( iface_type *iface )                                          \")
-cpp_quote("    {                                                                                              \")
-cpp_quote("        impl_type *impl = impl_from( iface );                                                      \")
-cpp_quote("        return IInspectable_AddRef( (IInspectable *)(expr) );                                      \")
-cpp_quote("    }                                                                                              \")
-cpp_quote("    static ULONG WINAPI pfx##_Release( iface_type *iface )                                         \")
-cpp_quote("    {                                                                                              \")
-cpp_quote("        impl_type *impl = impl_from( iface );                                                      \")
-cpp_quote("        return IInspectable_Release( (IInspectable *)(expr) );                                     \")
-cpp_quote("    }                                                                                              \")
-cpp_quote("    static HRESULT WINAPI pfx##_GetIids( iface_type *iface, ULONG *iid_count, IID **iids )         \")
-cpp_quote("    {                                                                                              \")
-cpp_quote("        impl_type *impl = impl_from( iface );                                                      \")
-cpp_quote("        return IInspectable_GetIids( (IInspectable *)(expr), iid_count, iids );                    \")
-cpp_quote("    }                                                                                              \")
-cpp_quote("    static HRESULT WINAPI pfx##_GetRuntimeClassName( iface_type *iface, HSTRING *class_name )      \")
-cpp_quote("    {                                                                                              \")
-cpp_quote("        impl_type *impl = impl_from( iface );                                                      \")
-cpp_quote("        return IInspectable_GetRuntimeClassName( (IInspectable *)(expr), class_name );             \")
-cpp_quote("    }                                                                                              \")
-cpp_quote("    static HRESULT WINAPI pfx##_GetTrustLevel( iface_type *iface, TrustLevel *trust_level )        \")
-cpp_quote("    {                                                                                              \")
-cpp_quote("        impl_type *impl = impl_from( iface );                                                      \")
-cpp_quote("        return IInspectable_GetTrustLevel( (IInspectable *)(expr), trust_level );                  \")
-cpp_quote("    }")
-
-cpp_quote("#define DEFINE_IINSPECTABLE( pfx, iface_type, impl_type, base_iface )                              \")
-cpp_quote("    DEFINE_IINSPECTABLE_( pfx, iface_type, impl_type, impl_from_##iface_type, iface_type##_iface, &impl->base_iface )")

[PATCH v3 3/4] wintypes/tests: Add tests for IMapView.

[Vibhav Pant]

From: Vibhav Pant

---
 dlls/wintypes/tests/wintypes.c | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/dlls/wintypes/tests/wintypes.c b/dlls/wintypes/tests/wintypes.c
index 8a54a6b2d17..c6df20d8248 100644
--- a/dlls/wintypes/tests/wintypes.c
+++ b/dlls/wintypes/tests/wintypes.c
@@ -1437,7 +1437,6 @@ static void test_IPropertySet(void)
         ok( hr == S_OK, "GetUInt32, got %#lx\n", hr );
         ok( uint64 == 0xdeadbeefdeadbeef, "Got uint64 %I64u\n", uint64 );
     }
-    WindowsDeleteString( key2 );

hr = IMap_HSTRING_IInspectable_QueryInterface( map, &IID_IIterable_IKeyValuePair_HSTRING_IInspectable,
                                                    (void **)&iterable );
@@ -1447,6 +1446,28 @@ static void test_IPropertySet(void)
     IIterator_IKeyValuePair_HSTRING_IInspectable_Release( iterator );
     IIterable_IKeyValuePair_HSTRING_IInspectable_Release( iterable );

+    hr = IMap_HSTRING_IInspectable_GetView( map, &map_view );
+    ok( hr == S_OK, "GetView failed, got %#lx\n", hr );
+    hr = IMapView_HSTRING_IInspectable_QueryInterface( map_view, &IID_IIterable_IKeyValuePair_HSTRING_IInspectable,
+                                                       (void **)&iterable );
+    ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
+    hr = IMapView_HSTRING_IInspectable_Lookup( map_view, key2, &val );
+    todo_wine
+    ok( hr == S_OK, "Lookup failed, got %#lx\n", hr );
+    if (SUCCEEDED(hr)) IInspectable_Release( val );
+    hr = IMap_HSTRING_IInspectable_Remove( map, key2 );
+    todo_wine
+    ok( hr == S_OK, "Remove failed, got %#lx\n", hr );
+    hr = IMapView_HSTRING_IInspectable_Lookup( map_view, key2, &val );
+    todo_wine
+    ok( hr == E_CHANGED_STATE, "Got hr %#lx\n", hr );
+    WindowsDeleteString( key2 );
+    hr = IIterable_IKeyValuePair_HSTRING_IInspectable_First( iterable, &iterator );
+    todo_wine
+    ok( hr == E_CHANGED_STATE, "got %#lx\n", hr );
+    IIterable_IKeyValuePair_HSTRING_IInspectable_Release( iterable );
+    IMapView_HSTRING_IInspectable_Release( map_view );
+
     hr = IMap_HSTRING_IInspectable_GetView( map, &map_view );
     ok( hr == S_OK, "GetView failed, got %#lx\n", hr );
     hr = IMapView_HSTRING_IInspectable_QueryInterface( map_view, &IID_IIterable_IKeyValuePair_HSTRING_IInspectable,

[PATCH v3 4/4] wintypes: Implement a generic IMap<HSTRING, IInspectable>.

[Rémi Bernon]

From: Rémi Bernon

---
 dlls/wintypes/map.c            | 304 +++++++++++++++++++++++++++------
 dlls/wintypes/tests/wintypes.c |  71 ++------
 2 files changed, 268 insertions(+), 107 deletions(-)

diff --git a/dlls/wintypes/map.c b/dlls/wintypes/map.c
index e49e933274a..b2dd866a590 100644
--- a/dlls/wintypes/map.c
+++ b/dlls/wintypes/map.c
@@ -24,11 +24,61 @@

WINE_DEFAULT_DEBUG_CHANNEL(combase);

+struct map_entry
+{
+    HSTRING key;
+    IInspectable *value;
+};
+
+static HRESULT map_entry_init( HSTRING key, IInspectable *value, struct map_entry *entry )
+{
+    HRESULT hr;
+    if (FAILED(hr = WindowsDuplicateString( key, &entry->key ))) return hr;
+    IInspectable_AddRef( (entry->value = value) );
+    return S_OK;
+}
+
+static void map_entry_copy( struct map_entry *dst, const struct map_entry *src )
+{
+    /* key has been duplicated already and further duplication cannot fail */
+    WindowsDuplicateString( src->key, &dst->key );
+    IInspectable_AddRef( (dst->value = src->value) );
+}
+
+static void map_entry_clear( struct map_entry *entry )
+{
+    WindowsDeleteString( entry->key );
+    entry->key = NULL;
+    IInspectable_AddRef( entry->value );
+    entry->value = NULL;
+}
+
+/* returns the first entry which is not less than addr, or entries + size if there's none. */
+static struct map_entry *map_entries_lower_bound( struct map_entry *entries, UINT32 size, HSTRING key, int *ret )
+{
+    struct map_entry *begin = entries, *end = begin + size, *mid;
+    int order = -1;
+
+    while (begin < end)
+    {
+        mid = begin + (end - begin) / 2;
+        WindowsCompareStringOrdinal( mid->key, key, &order );
+        if (order < 0) begin = mid + 1;
+        else if (order > 0) end = mid;
+        else begin = end = mid;
+    }
+
+    *ret = order;
+    return begin;
+}
+
 struct pair
 {
     IKeyValuePair_HSTRING_IInspectable IKeyValuePair_HSTRING_IInspectable_iface;
     const GUID *iid;
     LONG ref;
+
+    struct map_entry entry;
 };

static struct pair *impl_from_IKeyValuePair_HSTRING_IInspectable( IKeyValuePair_HSTRING_IInspectable *iface )
@@ -73,6 +123,7 @@ static ULONG WINAPI pair_Release( IKeyValuePair_HSTRING_IInspectable *iface )

if (!ref)
     {
+        map_entry_clear( &impl->entry );
         free( impl );
     }

@@ -99,14 +150,17 @@ static HRESULT WINAPI pair_GetTrustLevel( IKeyValuePair_HSTRING_IInspectable *if

static HRESULT WINAPI pair_get_Key( IKeyValuePair_HSTRING_IInspectable *iface, HSTRING *value )
 {
-    FIXME( "iface %p, value %p stub!\n", iface, value );
-    return E_NOTIMPL;
+    struct pair *impl = impl_from_IKeyValuePair_HSTRING_IInspectable( iface );
+    TRACE( "iface %p, value %p\n", iface, value );
+    return WindowsDuplicateString( impl->entry.key, value );
 }

static HRESULT WINAPI pair_get_Value( IKeyValuePair_HSTRING_IInspectable *iface, IInspectable **value )
 {
-    TRACE( "iface %p, value %p stub!\n", iface, value );
-    return E_NOTIMPL;
+    struct pair *impl = impl_from_IKeyValuePair_HSTRING_IInspectable( iface );
+    TRACE( "iface %p, value %p\n", iface, value );
+    IInspectable_AddRef( (*value = impl->entry.value) );
+    return S_OK;
 }

static const IKeyValuePair_HSTRING_IInspectableVtbl pair_vtbl =
@@ -123,7 +177,7 @@ static const IKeyValuePair_HSTRING_IInspectableVtbl pair_vtbl =
     pair_get_Value,
 };

-static HRESULT pair_create( const GUID *iid, IKeyValuePair_HSTRING_IInspectable **out )
+static HRESULT pair_create( const GUID *iid, struct map_entry *entry, IKeyValuePair_HSTRING_IInspectable **out )
 {
     struct pair *pair;

@@ -131,15 +185,38 @@ static HRESULT pair_create( const GUID *iid, IKeyValuePair_HSTRING_IInspectable
     pair->IKeyValuePair_HSTRING_IInspectable_iface.lpVtbl = &pair_vtbl;
     pair->iid = iid;
     pair->ref = 1;
+    map_entry_copy( &pair->entry, entry );

return S_OK;
 }

+struct map
+{
+    IInspectable IInspectable_iface;
+    IMap_HSTRING_IInspectable IMap_HSTRING_IInspectable_iface;
+    IIterable_IKeyValuePair_HSTRING_IInspectable IIterable_IKeyValuePair_HSTRING_IInspectable_iface;
+    IInspectable *IInspectable_outer;
+    struct map_iids iids;
+    LONG ref;
+
+    SIZE_T serial; /* Used to detect MapView/Iterator invalidation. */
+    UINT32 size;
+    UINT32 capacity;
+    struct map_entry *entries;
+};
+
+static struct map *impl_from_IInspectable( IInspectable *iface )
+{
+    return CONTAINING_RECORD( iface, struct map, IInspectable_iface );
+}
+
 struct map_view
 {
     IMapView_HSTRING_IInspectable IMapView_HSTRING_IInspectable_iface;
     IIterable_IKeyValuePair_HSTRING_IInspectable IIterable_IKeyValuePair_HSTRING_IInspectable_iface;
     struct map_iids iids;
+    SIZE_T serial;
+    struct map *map;
     LONG ref;
 };

@@ -154,6 +231,7 @@ struct iterator
     const GUID *iid;
     LONG ref;

+    UINT32 index;
     IMapView_HSTRING_IInspectable *view;
 };

@@ -228,27 +306,66 @@ static HRESULT WINAPI iterator_get_Current( IIterator_IKeyValuePair_HSTRING_IIns
 {
     struct iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
     struct map_view *view = impl_from_IMapView_HSTRING_IInspectable( impl->view );
-    FIXME( "iface %p, value %p stub!\n", iface, value );
-    return pair_create( view->iids.pair, value );
+
+    TRACE( "iface %p, value %p\n", iface, value );
+
+    if (view->serial != view->map->serial) return E_CHANGED_STATE;
+    return (impl->index < view->map->size) ? pair_create( view->iids.pair, view->map->entries + impl->index, value ) : E_BOUNDS;
 }

static HRESULT WINAPI iterator_get_HasCurrent( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, boolean *value )
 {
-    TRACE( "iface %p, value %p stub!\n", iface, value );
-    return E_NOTIMPL;
+    struct iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    struct map_view *view = impl_from_IMapView_HSTRING_IInspectable( impl->view );
+
+    TRACE( "iface %p, value %p\n", iface, value );
+
+    *value = FALSE;
+    if (view->serial != view->map->serial) return E_CHANGED_STATE;
+    *value = impl->index < view->map->size;
+    return S_OK;
 }

static HRESULT WINAPI iterator_MoveNext( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, boolean *value )
 {
-    FIXME( "iface %p, value %p stub!\n", iface, value );
-    return E_NOTIMPL;
+    struct iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    struct map_view *view = impl_from_IMapView_HSTRING_IInspectable( impl->view );
+
+    TRACE( "iface %p, value %p\n", iface, value );
+
+    *value = FALSE;
+    if (view->serial != view->map->serial) return E_CHANGED_STATE;
+    if (impl->index < view->map->size) impl->index++;
+    *value = impl->index < view->map->size;
+    return S_OK;
 }

static HRESULT WINAPI iterator_GetMany( IIterator_IKeyValuePair_HSTRING_IInspectable *iface, UINT32 items_size,
                                         IKeyValuePair_HSTRING_IInspectable **items, UINT *count )
 {
-    FIXME( "iface %p, items_size %u, items %p, count %p stub!\n", iface, items_size, items, count );
-    return E_NOTIMPL;
+    struct iterator *impl = impl_from_IIterator_IKeyValuePair_HSTRING_IInspectable( iface );
+    struct map_view *view = impl_from_IMapView_HSTRING_IInspectable( impl->view );
+    HRESULT hr = S_OK;
+    int len = 0;
+
+    TRACE( "iface %p, items_size %u, items %p, count %p\n", iface, items_size, items, count );
+
+    if (view->serial != view->map->serial)
+        return E_CHANGED_STATE;
+    if ((len = view->map->size - impl->index) < 0)
+        return E_BOUNDS;
+    *count = 0;
+    for (UINT32 i = 0; i < len; ++i)
+    {
+        if (i >= items_size) break;
+        if (FAILED(hr = pair_create( view->iids.pair, view->map->entries + impl->index + i, items + i )))
+        {
+            while (i) IKeyValuePair_HSTRING_IInspectable_Release( items[--i] );
+            break;
+        }
+    }
+    if (SUCCEEDED( hr )) *count = len;
+    return hr;
 }

static const IIterator_IKeyValuePair_HSTRING_IInspectableVtbl iterator_vtbl =
@@ -308,7 +425,11 @@ static ULONG WINAPI map_view_Release( IMapView_HSTRING_IInspectable *iface )

TRACE( "iface %p decreasing refcount to %lu.\n", iface, ref );

-    if (!ref) free( impl );
+    if (!ref)
+    {
+        IInspectable_Release( &impl->map->IInspectable_iface );
+        free( impl );
+    }
     return ref;
 }

@@ -332,27 +453,46 @@ static HRESULT WINAPI map_view_GetTrustLevel( IMapView_HSTRING_IInspectable *ifa

static HRESULT WINAPI map_view_Lookup( IMapView_HSTRING_IInspectable *iface, HSTRING key, IInspectable **value )
 {
-    FIXME( "iface %p, key %s, value %p stub!\n", iface, debugstr_hstring( key ), value );
-    return E_NOTIMPL;
+    struct map_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+
+    TRACE( "iface %p, key %s, value %p\n", iface, debugstr_hstring( key ), value );
+
+    if (impl->serial != impl->map->serial) return E_CHANGED_STATE;
+    return IMap_HSTRING_IInspectable_Lookup( &impl->map->IMap_HSTRING_IInspectable_iface, key, value );
 }

static HRESULT WINAPI map_view_get_Size( IMapView_HSTRING_IInspectable *iface, UINT32 *value )
 {
-    FIXME( "iface %p, value %p stub!\n", iface, value );
-    return E_NOTIMPL;
+    struct map_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+
+    TRACE( "iface %p, value %p\n", iface, value );
+
+    if (impl->map->serial != impl->serial) return E_CHANGED_STATE;
+    *value = impl->map->size;
+    return S_OK;
 }

static HRESULT WINAPI map_view_HasKey( IMapView_HSTRING_IInspectable *iface, HSTRING key, boolean *found )
 {
-    FIXME( "iface %p, key %s, found %p stub!\n", iface, debugstr_hstring( key ), found );
-    return E_NOTIMPL;
+    struct map_view *impl = impl_from_IMapView_HSTRING_IInspectable( iface );
+    int order;
+
+    TRACE( "iface %p, key %s, found %p\n", iface, debugstr_hstring( key ), found );
+
+    *found = FALSE;
+    if (impl->map->serial != impl->serial) return E_CHANGED_STATE;
+    map_entries_lower_bound( impl->map->entries, impl->map->size, key, &order );
+    *found = !order;
+    return S_OK;
 }

static HRESULT WINAPI map_view_Split( IMapView_HSTRING_IInspectable *iface, IMapView_HSTRING_IInspectable **first,
                                       IMapView_HSTRING_IInspectable **second )
 {
-    FIXME( "iface %p, first %p, second %p stub!\n", iface, first, second );
-    return E_NOTIMPL;
+    TRACE( "iface %p, first %p, second %p\n", iface, first, second );
+
+    *first = *second = NULL;
+    return S_OK;
 }

static const struct IMapView_HSTRING_IInspectableVtbl map_view_vtbl =
@@ -381,6 +521,8 @@ static HRESULT WINAPI iterable_view_First( IIterable_IKeyValuePair_HSTRING_IInsp

TRACE( "iface %p, value %p.\n", iface, value );

+    *value = NULL;
+    if (impl->serial != impl->map->serial) return E_CHANGED_STATE;
     if (!(iter = calloc( 1, sizeof(struct iterator) ))) return E_OUTOFMEMORY;
     iter->IIterator_IKeyValuePair_HSTRING_IInspectable_iface.lpVtbl = &iterator_vtbl;
     iter->iid = impl->iids.iterator;
@@ -404,35 +546,22 @@ static const struct IIterable_IKeyValuePair_HSTRING_IInspectableVtbl iterable_vi
     iterable_view_First,
 };

-static HRESULT map_view_create( const struct map_iids *iids, IMapView_HSTRING_IInspectable **out )
+static HRESULT map_view_create( const struct map_iids *iids, struct map *map, IMapView_HSTRING_IInspectable **out )
 {
     struct map_view *view;

if (!(view = calloc( 1, sizeof(*view) ))) return E_OUTOFMEMORY;
+    IInspectable_AddRef( &map->IInspectable_iface );
+    view->map = map;
     view->IMapView_HSTRING_IInspectable_iface.lpVtbl = &map_view_vtbl;
     view->IIterable_IKeyValuePair_HSTRING_IInspectable_iface.lpVtbl = &iterable_view_vtbl;
     view->iids = *iids;
     view->ref = 1;
-
+    view->serial = map->serial;
     *out = &view->IMapView_HSTRING_IInspectable_iface;
     return S_OK;
 }

-struct map
-{
-    IInspectable IInspectable_iface;
-    IMap_HSTRING_IInspectable IMap_HSTRING_IInspectable_iface;
-    IIterable_IKeyValuePair_HSTRING_IInspectable IIterable_IKeyValuePair_HSTRING_IInspectable_iface;
-    IInspectable *IInspectable_outer;
-    struct map_iids iids;
-    LONG ref;
-};
-
-static struct map *impl_from_IInspectable( IInspectable *iface )
-{
-    return CONTAINING_RECORD( iface, struct map, IInspectable_iface );
-}
-
 static HRESULT WINAPI map_inner_QueryInterface( IInspectable *iface, REFIID iid, void **out )
 {
     struct map *impl = impl_from_IInspectable( iface );
@@ -522,45 +651,115 @@ DEFINE_IINSPECTABLE_OUTER( map, IMap_HSTRING_IInspectable, struct map, IInspecta

static HRESULT WINAPI map_Lookup( IMap_HSTRING_IInspectable *iface, HSTRING key, IInspectable **value )
 {
-    FIXME( "iface %p, key %s, value %p stub!\n", iface, debugstr_hstring( key ), value );
-    return E_NOTIMPL;
+    struct map *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    struct map_entry *entry;
+    int order;
+
+    TRACE( "iface %p, key %s, value %p\n", iface, debugstr_hstring( key ), value );
+
+    if (!(entry = map_entries_lower_bound( impl->entries, impl->size, key, &order )) || order) return E_BOUNDS;
+    IInspectable_AddRef( (*value = entry->value ));
+    return S_OK;
 }

static HRESULT WINAPI map_get_Size( IMap_HSTRING_IInspectable *iface, UINT32 *size )
 {
-    FIXME( "iface %p, size %p stub!\n", iface, size );
-    return E_NOTIMPL;
+    struct map *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+
+    TRACE( "iface %p, size %p\n", iface, size );
+
+    *size = impl->size;
+    return S_OK;
 }

static HRESULT WINAPI map_HasKey( IMap_HSTRING_IInspectable *iface, HSTRING key, boolean *exists )
 {
-    FIXME( "iface %p, key %s, exists %p stub!\n", iface, debugstr_hstring( key ), exists );
-    return E_NOTIMPL;
+    struct map *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    int order;
+
+    TRACE( "iface %p, key %s, exists %p\n", iface, debugstr_hstring( key ), exists );
+
+    map_entries_lower_bound( impl->entries, impl->size, key, &order );
+    *exists = !order;
+    return S_OK;
 }

static HRESULT WINAPI map_GetView( IMap_HSTRING_IInspectable *iface, IMapView_HSTRING_IInspectable **value )
 {
     struct map *impl = impl_from_IMap_HSTRING_IInspectable( iface );
     TRACE( "iface %p, value %p.\n", iface, value );
-    return map_view_create( &impl->iids, value );
+    return map_view_create( &impl->iids, impl, value );
 }

static HRESULT WINAPI map_Insert( IMap_HSTRING_IInspectable *iface, HSTRING key, IInspectable *value, boolean *replaced )
 {
-    FIXME( "iface %p, key %p, value %p, replaced %p stub!\n", iface, key, value, replaced );
-    return E_NOTIMPL;
+    struct map *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    struct map_entry *tmp, *entry, copy;
+    HRESULT hr;
+    int order;
+
+    TRACE( "iface %p, key %p, value %p, replaced %p\n", iface, key, value, replaced );
+
+    tmp = impl->entries;
+    if (impl->size == impl->capacity)
+    {
+        impl->capacity = max( 32, impl->capacity * 3 / 2 );
+        if (!(impl->entries = realloc( impl->entries, impl->capacity * sizeof(*impl->entries) )))
+        {
+            impl->entries = tmp;
+            return E_OUTOFMEMORY;
+        }
+    }
+
+    if (!(entry = map_entries_lower_bound( impl->entries, impl->size, key, &order ))) return E_OUTOFMEMORY;
+    if (FAILED(hr = map_entry_init( key, value, &copy ))) return hr;
+    if ((*replaced = !order)) map_entry_clear( entry );
+    else memmove( entry + 1, entry, (impl->entries + impl->size++ - entry) * sizeof(*impl->entries) );
+    *entry = copy;
+    impl->serial++;
+    return S_OK;
 }

static HRESULT WINAPI map_Remove( IMap_HSTRING_IInspectable *iface, HSTRING key )
 {
-    FIXME( "iface %p, key %s stub!\n", iface, debugstr_hstring( key ) );
-    return E_NOTIMPL;
+    struct map *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    struct map_entry *entry;
+    HRESULT hr = S_OK;
+    int order;
+
+    TRACE( "iface %p, key %s\n", iface, debugstr_hstring( key ) );
+
+    entry = map_entries_lower_bound( impl->entries, impl->size, key, &order );
+    if (!entry || order)
+        hr =  E_BOUNDS;
+    else
+    {
+        map_entry_clear( entry );
+        memmove( entry, entry + 1, (impl->entries + --impl->size - entry) * sizeof(*impl->entries) );
+        impl->serial++;
+    }
+    return hr;
 }

static HRESULT WINAPI map_Clear( IMap_HSTRING_IInspectable *iface )
 {
-    FIXME( "iface %p stub!\n", iface );
-    return E_NOTIMPL;
+    struct map *impl = impl_from_IMap_HSTRING_IInspectable( iface );
+    struct map_entry *entries;
+    UINT32 size;
+
+    TRACE( "iface %p\n", iface );
+
+    entries = impl->entries;
+    size = impl->size;
+
+    impl->entries = NULL;
+    impl->capacity = 0;
+    impl->size = 0;
+
+    while (size) map_entry_clear( entries + --size );
+    free( entries );
+    impl->serial++;
+    return S_OK;
 }

const static IMap_HSTRING_IInspectableVtbl map_vtbl =
@@ -631,7 +830,6 @@ HRESULT map_create( const struct map_iids *iids, IInspectable *outer, void **out
     impl->IInspectable_outer = outer ? outer : (IInspectable *)&impl->IInspectable_iface;
     impl->iids = *iids;
     impl->ref = 1;
-
     *out = &impl->IInspectable_iface;
     TRACE( "created %p\n", *out );
     return S_OK;
diff --git a/dlls/wintypes/tests/wintypes.c b/dlls/wintypes/tests/wintypes.c
index c6df20d8248..9e913c7391b 100644
--- a/dlls/wintypes/tests/wintypes.c
+++ b/dlls/wintypes/tests/wintypes.c
@@ -1267,6 +1267,8 @@ static void test_IPropertySet(void)
     BOOLEAN boolean;
     HRESULT hr;
     HSTRING name, key1, key2;
+    IPropertyValue *propval;
+    UINT32 uint32 = 0;

hr = RoInitialize( RO_INIT_MULTITHREADED );
     ok( hr == S_OK, "got %#lx\n", hr );
@@ -1313,21 +1315,16 @@ static void test_IPropertySet(void)

boolean = TRUE;
     hr = IMap_HSTRING_IInspectable_HasKey( map, NULL, &boolean );
-    todo_wine
     ok( hr == S_OK, "HasKey failed, got %#lx\n", hr );
-    todo_wine
     ok( !boolean, "Got boolean %d.\n", boolean );
     hr = IMap_HSTRING_IInspectable_Lookup( map, NULL, &val );
-    todo_wine
     ok( hr == E_BOUNDS, "Got hr %#lx\n", hr );

hr = IPropertyValueStatics_CreateUInt32( propval_statics, 0xdeadbeef, &val1 );
     ok( hr == S_OK, "CreateUInt32 failed, got %#lx\n", hr );
     boolean = TRUE;
     hr = IMap_HSTRING_IInspectable_Insert( map, NULL, val1, &boolean );
-    todo_wine
     ok( hr == S_OK, "Insert failed, got %#lx\n", hr );
-    todo_wine
     ok( !boolean, "Got boolean %d.\n", boolean );

hr = IPropertyValueStatics_CreateUInt32( propval_statics, 0xc0decafe, &val2 );
@@ -1335,94 +1332,64 @@ static void test_IPropertySet(void)
     boolean = FALSE;
     hr = IMap_HSTRING_IInspectable_Insert( map, NULL, val2, &boolean );
     IInspectable_Release( val2 );
-    todo_wine
     ok( boolean, "Got boolean %d.\n", boolean );
-    todo_wine
     ok( hr == S_OK, "Insert failed, got %#lx\n", hr );
     boolean = FALSE;
     hr = IMap_HSTRING_IInspectable_HasKey( map, NULL, &boolean );
-    todo_wine
     ok( hr == S_OK, "HasKey failed, got %#lx\n", hr );
-    todo_wine
     ok( boolean, "Got boolean %d.\n", boolean );
     hr = IMap_HSTRING_IInspectable_Lookup( map, NULL, &val );
-    todo_wine
     ok( hr == S_OK, "Lookup failed, got %#lx\n", hr );
-    if (SUCCEEDED(hr))
-    {
-        IPropertyValue *propval;
-        UINT32 uint32 = 0;
-
-        hr = IInspectable_QueryInterface( val, &IID_IPropertyValue, (void **)&propval );
-        IInspectable_Release( val );
-        ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
-        hr = IPropertyValue_GetUInt32( propval, &uint32 );
-        IPropertyValue_Release( propval );
-        ok( hr == S_OK, "GetUInt32, got %#lx\n", hr );
-        ok( uint32 == 0xc0decafe, "Got uint32 %u\n", uint32 );
-    }
+    hr = IInspectable_QueryInterface( val, &IID_IPropertyValue, (void **)&propval );
+    IInspectable_Release( val );
+    ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
+    hr = IPropertyValue_GetUInt32( propval, &uint32 );
+    IPropertyValue_Release( propval );
+    ok( hr == S_OK, "GetUInt32, got %#lx\n", hr );
+    ok( uint32 == 0xc0decafe, "Got uint32 %u\n", uint32 );

hr = WindowsCreateString( L"foo", 3, &key1 );
     ok( hr == S_OK, "WindowsCreateString failed, got %#lx\n", hr );
     boolean = TRUE;
     hr = IMap_HSTRING_IInspectable_Lookup( map, key1, &val );
-    todo_wine
     ok( hr == E_BOUNDS, "Got hr %#lx\n", hr );
     hr = IMap_HSTRING_IInspectable_Insert( map, key1, val1, &boolean );
     IInspectable_Release( val1 );
-    todo_wine
     ok( hr == S_OK, "Insert failed, got %#lx\n", hr );
-    todo_wine
     ok( !boolean, "Got boolean %d.\n", boolean );
     boolean = FALSE;
     hr = IMap_HSTRING_IInspectable_HasKey( map, key1, &boolean );
-    todo_wine
     ok( hr == S_OK, "HasKey failed, got %#lx\n", hr );
-    todo_wine
     ok( boolean, "Got boolean %d.\n", boolean );
     hr = IMap_HSTRING_IInspectable_Lookup( map, key1, &val );
-    todo_wine
     ok( hr == S_OK, "Lookup failed, got %#lx\n", hr );
-    if (SUCCEEDED(hr))
-    {
-        IPropertyValue *propval;
-        UINT32 uint32 = 0;
-
-        hr = IInspectable_QueryInterface( val, &IID_IPropertyValue, (void **)&propval );
-        IInspectable_Release( val );
-        ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
-        hr = IPropertyValue_GetUInt32( propval, &uint32 );
-        IPropertyValue_Release( propval );
-        ok( hr == S_OK, "GetUInt32, got %#lx\n", hr );
-        ok( uint32 == 0xdeadbeef, "Got uint32 %u\n", uint32 );
-    }
+    hr = IInspectable_QueryInterface( val, &IID_IPropertyValue, (void **)&propval );
+    IInspectable_Release( val );
+    ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
+    hr = IPropertyValue_GetUInt32( propval, &uint32 );
+    IPropertyValue_Release( propval );
+    ok( hr == S_OK, "GetUInt32, got %#lx\n", hr );
+    ok( uint32 == 0xdeadbeef, "Got uint32 %u\n", uint32 );
     WindowsDeleteString( key1 );

hr = WindowsCreateString( L"bar", 3, &key2 );
     ok( hr == S_OK, "WindowsCreateString failed, got %#lx\n", hr );
     boolean = TRUE;
     hr = IMap_HSTRING_IInspectable_HasKey( map, key2, &boolean );
-    todo_wine
     ok( hr == S_OK, "HasKey failed, got %#lx\n", hr );
-    todo_wine
     ok( !boolean, "Got boolean %d.\n", boolean );
     hr = IPropertyValueStatics_CreateUInt64( propval_statics, 0xdeadbeefdeadbeef, &val3 );
     ok( hr == S_OK, "CreateUInt32 failed, got %#lx\n", hr );
     boolean = TRUE;
     hr = IMap_HSTRING_IInspectable_Insert( map, key2, val3, &boolean );
     IInspectable_Release( val3 );
-    todo_wine
     ok( hr == S_OK, "Insert failed, got %#lx\n", hr );
-    todo_wine
     ok( !boolean, "Got boolean %d.\n", boolean );
     boolean = FALSE;
     hr = IMap_HSTRING_IInspectable_HasKey( map, key2, &boolean );
-    todo_wine
     ok( hr == S_OK, "HasKey failed, got %#lx\n", hr );
-    todo_wine
     ok( boolean, "Got boolean %d.\n", boolean );
     hr = IMap_HSTRING_IInspectable_Lookup( map, key2, &val );
-    todo_wine
     ok( hr == S_OK, "Lookup failed, got %#lx\n", hr );
     if (SUCCEEDED(hr))
     {
@@ -1452,18 +1419,14 @@ static void test_IPropertySet(void)
                                                        (void **)&iterable );
     ok( hr == S_OK, "QueryInterface failed, got %#lx\n", hr );
     hr = IMapView_HSTRING_IInspectable_Lookup( map_view, key2, &val );
-    todo_wine
     ok( hr == S_OK, "Lookup failed, got %#lx\n", hr );
-    if (SUCCEEDED(hr)) IInspectable_Release( val );
+    IInspectable_Release( val );
     hr = IMap_HSTRING_IInspectable_Remove( map, key2 );
-    todo_wine
     ok( hr == S_OK, "Remove failed, got %#lx\n", hr );
     hr = IMapView_HSTRING_IInspectable_Lookup( map_view, key2, &val );
-    todo_wine
     ok( hr == E_CHANGED_STATE, "Got hr %#lx\n", hr );
     WindowsDeleteString( key2 );
     hr = IIterable_IKeyValuePair_HSTRING_IInspectable_First( iterable, &iterator );
-    todo_wine
     ok( hr == E_CHANGED_STATE, "got %#lx\n", hr );
     IIterable_IKeyValuePair_HSTRING_IInspectable_Release( iterable );
     IMapView_HSTRING_IInspectable_Release( map_view );

[Vibhav Pant (＠vibhavp)]

On Thu Sep  4 12:04:00 2025 +0000, Rémi Bernon wrote:
> Well, like before I don't really like the idea of putting a lock in the
> generic implementation, when it's only needed because of one of its
> user. I think it would be good to have a separate thread safe one
> wrapping the unsafe one. The serial can still be implemented in the
> unsafe code, if we really need to return E_CHANGED_STATE.

Makes sense, I made reverted the locking code in `map.c` in the latest revision. The `PropertySet` implementation now guards access to the underlying `IMap/IMapView/IIterable/IIterator` with a SRWLOCK instead (though we can't neatly aggregate `IPropertySet` now). Does this look better?

[PATCH v3 0/4] MR8895: wintypes: Implement a generic IMap<HSTRING, IInspectable> + IPropertySet.

[Vibhav Pant (＠vibhavp)]

v3:

* Move locking code from IMap implementation to `IPropertySet`.