[PowerRename] Introduce advanced counter functionality (#27895)

src/modules/powerrename/unittests/CommonRegExTests.h

@@ -0,0 +1,472 @@
+//#undef TESTS_PARTIAL // Uncomment temporarily to make intellisense work in this file.
+#ifndef TESTS_PARTIAL
+#include "CppUnitTestInclude.h"
+#include "powerrename/lib/Settings.h"
+#include <PowerRenameInterfaces.h>
+#include <PowerRenameRegEx.h>
+
+using namespace Microsoft::VisualStudio::CppUnitTestFramework;
+namespace PowerRenameRegExTests
+{
+TEST_CLASS (SimpleTests)
+{
+public:
+#endif
+
+struct SearchReplaceExpected
+{
+    PCWSTR search;
+    PCWSTR replace;
+    PCWSTR test;
+    PCWSTR expected;
+};
+
+TEST_METHOD (GeneralReplaceTest)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"big") == S_OK);
+    unsigned long index = {};
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"bigbar", result);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (ReplaceNoMatch)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"notfound") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"big") == S_OK);
+    unsigned long index = {};
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"foobar", result);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (ReplaceNoSearchOrReplaceTerm)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    PWSTR result = nullptr;
+    unsigned long index = {};
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::IsTrue(result == nullptr);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (ReplaceNoReplaceTerm)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
+    unsigned long index = {};
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"bar", result);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (ReplaceEmptyStringReplaceTerm)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"") == S_OK);
+    unsigned long index = {};
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"bar", result);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (VerifyDefaultFlags)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = 0;
+    Assert::IsTrue(renameRegEx->GetFlags(&flags) == S_OK);
+    Assert::IsTrue(flags == 0);
+}
+
+TEST_METHOD (VerifyCaseSensitiveSearch)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = CaseSensitive;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+
+    SearchReplaceExpected sreTable[] = {
+        { L"Foo", L"Foo", L"FooBar", L"FooBar" },
+        { L"Foo", L"boo", L"FooBar", L"booBar" },
+        { L"Foo", L"boo", L"foobar", L"foobar" },
+        { L"123", L"654", L"123456", L"654456" },
+    };
+
+    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
+    {
+        PWSTR result = nullptr;
+        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
+        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
+        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
+        CoTaskMemFree(result);
+    }
+}
+
+TEST_METHOD (VerifyReplaceFirstOnly)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = 0;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+
+    SearchReplaceExpected sreTable[] = {
+        { L"B", L"BB", L"ABA", L"ABBA" },
+        { L"B", L"A", L"ABBBA", L"AABBA" },
+        { L"B", L"BBB", L"ABABAB", L"ABBBABAB" },
+    };
+
+    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
+    {
+        PWSTR result = nullptr;
+        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
+        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
+        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
+        CoTaskMemFree(result);
+    }
+}
+
+TEST_METHOD (VerifyReplaceAll)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = MatchAllOccurrences;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+
+    SearchReplaceExpected sreTable[] = {
+        { L"B", L"BB", L"ABA", L"ABBA" },
+        { L"B", L"A", L"ABBBA", L"AAAAA" },
+        { L"B", L"BBB", L"ABABAB", L"ABBBABBBABBB" },
+    };
+
+    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
+    {
+        PWSTR result = nullptr;
+        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
+        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
+        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
+        CoTaskMemFree(result);
+    }
+}
+
+TEST_METHOD (VerifyReplaceAllCaseInsensitive)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = MatchAllOccurrences | CaseSensitive;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+
+    SearchReplaceExpected sreTable[] = {
+        { L"B", L"BB", L"ABA", L"ABBA" },
+        { L"B", L"A", L"ABBBA", L"AAAAA" },
+        { L"B", L"BBB", L"ABABAB", L"ABBBABBBABBB" },
+        { L"b", L"BBB", L"AbABAb", L"ABBBABABBB" },
+    };
+
+    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
+    {
+        PWSTR result = nullptr;
+        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
+        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
+        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
+        CoTaskMemFree(result);
+    }
+}
+
+TEST_METHOD (VerifyReplaceFirstOnlyUseRegEx)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = UseRegularExpressions;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+
+    SearchReplaceExpected sreTable[] = {
+        { L"B", L"BB", L"ABA", L"ABBA" },
+        { L"B", L"A", L"ABBBA", L"AABBA" },
+        { L"B", L"BBB", L"ABABAB", L"ABBBABAB" },
+    };
+
+    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
+    {
+        PWSTR result = nullptr;
+        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
+        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
+        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
+        CoTaskMemFree(result);
+    }
+}
+
+TEST_METHOD (VerifyReplaceAllUseRegEx)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = MatchAllOccurrences | UseRegularExpressions;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+
+    SearchReplaceExpected sreTable[] = {
+        { L"B", L"BB", L"ABA", L"ABBA" },
+        { L"B", L"A", L"ABBBA", L"AAAAA" },
+        { L"B", L"BBB", L"ABABAB", L"ABBBABBBABBB" },
+    };
+
+    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
+    {
+        PWSTR result = nullptr;
+        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
+        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
+        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
+        CoTaskMemFree(result);
+    }
+}
+
+TEST_METHOD (VerifyReplaceAllUseRegExCaseSensitive)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = MatchAllOccurrences | UseRegularExpressions | CaseSensitive;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+
+    SearchReplaceExpected sreTable[] = {
+        { L"B", L"BB", L"ABA", L"ABBA" },
+        { L"B", L"A", L"ABBBA", L"AAAAA" },
+        { L"b", L"BBB", L"AbABAb", L"ABBBABABBB" },
+    };
+
+    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
+    {
+        PWSTR result = nullptr;
+        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
+        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
+        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
+        CoTaskMemFree(result);
+    }
+}
+
+void VerifyReplaceFirstWildcard(SearchReplaceExpected sreTable[], int tableSize, DWORD flags)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+
+    for (int i = 0; i < tableSize; i++)
+    {
+        PWSTR result = nullptr;
+        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
+        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
+        Assert::AreEqual(sreTable[i].expected, result);
+        CoTaskMemFree(result);
+    }
+}
+
+TEST_METHOD (VerifyReplaceFirstWildCardUseRegex)
+{
+    SearchReplaceExpected sreTable[] = {
+        //search, replace, test, result
+        { L".*", L"Foo", L"AAAAAA", L"Foo" },
+    };
+    VerifyReplaceFirstWildcard(sreTable, ARRAYSIZE(sreTable), UseRegularExpressions);
+}
+
+TEST_METHOD (VerifyReplaceFirstWildCardMatchAllOccurrences)
+{
+    SearchReplaceExpected sreTable[] = {
+        //search, replace, test, result
+        { L".*", L"Foo", L"AAAAAA", L"AAAAAA" },
+        { L".*", L"Foo", L".*", L"Foo" },
+        { L".*", L"Foo", L".*Bar.*", L"FooBarFoo" },
+    };
+    VerifyReplaceFirstWildcard(sreTable, ARRAYSIZE(sreTable), MatchAllOccurrences);
+}
+
+TEST_METHOD (VerifyReplaceFirstWildNoFlags)
+{
+    SearchReplaceExpected sreTable[] = {
+        //search, replace, test, result
+        { L".*", L"Foo", L"AAAAAA", L"AAAAAA" },
+        { L".*", L"Foo", L".*", L"Foo" },
+    };
+    VerifyReplaceFirstWildcard(sreTable, ARRAYSIZE(sreTable), 0);
+}
+
+TEST_METHOD (VerifyEventsFire)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    CMockPowerRenameRegExEvents* mockEvents = new CMockPowerRenameRegExEvents();
+    CComPtr<IPowerRenameRegExEvents> regExEvents;
+    Assert::IsTrue(mockEvents->QueryInterface(IID_PPV_ARGS(&regExEvents)) == S_OK);
+    DWORD cookie = 0;
+    Assert::IsTrue(renameRegEx->Advise(regExEvents, &cookie) == S_OK);
+    DWORD flags = MatchAllOccurrences | UseRegularExpressions | CaseSensitive;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"FOO") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"BAR") == S_OK);
+    Assert::IsTrue(renameRegEx->PutFileTime(SYSTEMTIME{ 0 }) == S_OK);
+    Assert::IsTrue(renameRegEx->ResetFileTime() == S_OK);
+    Assert::IsTrue(lstrcmpi(L"FOO", mockEvents->m_searchTerm) == 0);
+    Assert::IsTrue(lstrcmpi(L"BAR", mockEvents->m_replaceTerm) == 0);
+    Assert::IsTrue(flags == mockEvents->m_flags);
+    Assert::IsTrue(renameRegEx->UnAdvise(cookie) == S_OK);
+    mockEvents->Release();
+}
+
+TEST_METHOD (VerifySimpleCounterNoRegex)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = EnumerateItems;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"bar") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"$1bar_${}") == S_OK);
+    unsigned long index = {};
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"foo$1bar_0", result);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (VerifySimpleCounterNoEnum)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = UseRegularExpressions;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"bar") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"$1bar_${}") == S_OK);
+    unsigned long index = {};
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"foobar_${}", result);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (VerifySimpleCounter)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = EnumerateItems | UseRegularExpressions;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"bar") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"bar_${}") == S_OK);
+    unsigned long index = {};
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"foobar_0", result);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (VerifyMultipleCounters)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = EnumerateItems | UseRegularExpressions;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"bar") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"_${}_bar_${}") == S_OK);
+    unsigned long index = {};
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"foo_0_bar_0", result);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (VerifyCounterIncrementCustomization)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = EnumerateItems | UseRegularExpressions;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"bar") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"bar_${increment=10}") == S_OK);
+    unsigned long index = 1;
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"foobar_10", result);
+    Assert::AreEqual<unsigned long>(index, 2);
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"foobar_20", result);
+    Assert::AreEqual<unsigned long>(index, 3);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (VerifyCounterStartCustomization)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = EnumerateItems | UseRegularExpressions;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"bar") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"bar_${start=1000}") == S_OK);
+    unsigned long index = 5;
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"foobar_1005", result);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (VerifyCounterPaddingCustomization)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = EnumerateItems | UseRegularExpressions;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"bar") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"bar_${padding=5}") == S_OK);
+    unsigned long index = 204;
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"foobar_00204", result);
+    CoTaskMemFree(result);
+}
+
+TEST_METHOD (VerifyCounterAllCustomizations)
+{
+    CComPtr<IPowerRenameRegEx> renameRegEx;
+    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
+    DWORD flags = EnumerateItems | UseRegularExpressions;
+    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
+    Assert::IsTrue(renameRegEx->PutSearchTerm(L"bar") == S_OK);
+    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"bar_${increment=7,start=993,padding=5}") == S_OK);
+    unsigned long index = 12;
+    PWSTR result = nullptr;
+    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result, index) == S_OK);
+    Assert::AreEqual(L"foobar_01077", result);
+    CoTaskMemFree(result);
+}
+
+#ifndef TESTS_PARTIAL
+};
+}
+#endif

src/modules/powerrename/unittests/CppUnitTestInclude.h

@@ -0,0 +1,8 @@
+#pragma once
+// Headers for CppUnitTest
+
+// Suppressing 26466 - Don't use static_cast downcasts - in CppUnitTest.h
+#pragma warning(push)
+#pragma warning(disable : 26466)
+#include "CppUnitTest.h"
+#pragma warning(pop)

src/modules/powerrename/unittests/PowerRenameLibUnitTests.vcxproj

@@ -38,6 +38,7 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClInclude Include="CppUnitTestInclude.h" />
     <ClInclude Include="MockPowerRenameItem.h" />
     <ClInclude Include="MockPowerRenameManagerEvents.h" />
     <ClInclude Include="MockPowerRenameRegExEvents.h" />
@@ -45,6 +46,7 @@
     <ClInclude Include="resource.h" />
     <ClInclude Include="targetver.h" />
     <ClInclude Include="TestFileHelper.h" />
+    <ClInclude Include="CommonRegExTests.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="MockPowerRenameItem.cpp" />

src/modules/powerrename/unittests/PowerRenameLibUnitTests.vcxproj.filters

@@ -17,9 +17,11 @@
     <ClInclude Include="pch.h" />
     <ClInclude Include="targetver.h" />
     <ClInclude Include="TestFileHelper.h" />
+    <ClInclude Include="CommonRegExTests.h" />
     <ClInclude Include="resource.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="CppUnitTestInclude.h" />
   </ItemGroup>
   <ItemGroup>
     <Filter Include="Resource Files">

src/modules/powerrename/unittests/PowerRenameRegExBoostTests.cpp

@@ -8,14 +8,6 @@ using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 namespace PowerRenameRegExBoostTests
 {
-    struct SearchReplaceExpected
-    {
-        PCWSTR search;
-        PCWSTR replace;
-        PCWSTR test;
-        PCWSTR expected;
-    };
-
     TEST_CLASS(SimpleTests)
     {
     public:
@@ -29,241 +21,8 @@ TEST_CLASS_CLEANUP(ClassCleanup)
     CSettingsInstance().SetUseBoostLib(false);
 }
 
-TEST_METHOD(GeneralReplaceTest)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    PWSTR result = nullptr;
-    Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
-    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"big") == S_OK);
-    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
-    Assert::IsTrue(wcscmp(result, L"bigbar") == 0);
-    CoTaskMemFree(result);
-}
-
-TEST_METHOD(ReplaceNoMatch)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    PWSTR result = nullptr;
-    Assert::IsTrue(renameRegEx->PutSearchTerm(L"notfound") == S_OK);
-    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"big") == S_OK);
-    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
-    Assert::IsTrue(wcscmp(result, L"foobar") == 0);
-    CoTaskMemFree(result);
-}
-
-TEST_METHOD(ReplaceNoSearchOrReplaceTerm)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    PWSTR result = nullptr;
-    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
-    Assert::IsTrue(result == nullptr);
-    CoTaskMemFree(result);
-}
-
-TEST_METHOD(ReplaceNoReplaceTerm)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    PWSTR result = nullptr;
-    Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
-    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
-    Assert::IsTrue(wcscmp(result, L"bar") == 0);
-    CoTaskMemFree(result);
-}
-
-TEST_METHOD(ReplaceEmptyStringReplaceTerm)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    PWSTR result = nullptr;
-    Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
-    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"") == S_OK);
-    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
-    Assert::IsTrue(wcscmp(result, L"bar") == 0);
-    CoTaskMemFree(result);
-}
-
-TEST_METHOD(VerifyDefaultFlags)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = 0;
-    Assert::IsTrue(renameRegEx->GetFlags(&flags) == S_OK);
-    Assert::IsTrue(flags == 0);
-}
-
-TEST_METHOD(VerifyCaseSensitiveSearch)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = CaseSensitive;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"Foo", L"Foo", L"FooBar", L"FooBar" },
-        { L"Foo", L"boo", L"FooBar", L"booBar" },
-        { L"Foo", L"boo", L"foobar", L"foobar" },
-        { L"123", L"654", L"123456", L"654456" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceFirstOnly)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = 0;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AABBA" },
-        { L"B", L"BBB", L"ABABAB", L"ABBBABAB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceAll)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = MatchAllOccurrences;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AAAAA" },
-        { L"B", L"BBB", L"ABABAB", L"ABBBABBBABBB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceAllCaseInsensitive)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = MatchAllOccurrences | CaseSensitive;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AAAAA" },
-        { L"B", L"BBB", L"ABABAB", L"ABBBABBBABBB" },
-        { L"b", L"BBB", L"AbABAb", L"ABBBABABBB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceFirstOnlyUseRegEx)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = UseRegularExpressions;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AABBA" },
-        { L"B", L"BBB", L"ABABAB", L"ABBBABAB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceAllUseRegEx)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = MatchAllOccurrences | UseRegularExpressions;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AAAAA" },
-        { L"B", L"BBB", L"ABABAB", L"ABBBABBBABBB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceAllUseRegExCaseSensitive)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = MatchAllOccurrences | UseRegularExpressions | CaseSensitive;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AAAAA" },
-        { L"b", L"BBB", L"AbABAb", L"ABBBABABBB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
+#define TESTS_PARTIAL
+#include "CommonRegExTests.h"
 
 TEST_METHOD(VerifyMatchAllWildcardUseRegEx)
 {
@@ -284,38 +43,13 @@ TEST_METHOD(VerifyMatchAllWildcardUseRegEx)
         PWSTR result = nullptr;
         Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
         Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
         Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
         CoTaskMemFree(result);
     }
 }
 
-void VerifyReplaceFirstWildcard(SearchReplaceExpected sreTable[], int tableSize, DWORD flags)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    for (int i = 0; i < tableSize; i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::AreEqual(sreTable[i].expected, result);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceFirstWildCardUseRegex)
-{
-    SearchReplaceExpected sreTable[] = {
-        //search, replace, test, result
-        { L".*", L"Foo", L"AAAAAA", L"Foo" },
-    };
-    VerifyReplaceFirstWildcard(sreTable, ARRAYSIZE(sreTable), UseRegularExpressions);
-}
-
 TEST_METHOD(VerifyReplaceFirstWildCardUseRegexMatchAllOccurrences)
 {
     // This differs from the Standard Library: .* has two matches (all and nothing).
@@ -327,27 +61,6 @@ TEST_METHOD(VerifyReplaceFirstWildCardUseRegexMatchAllOccurrences)
     VerifyReplaceFirstWildcard(sreTable, ARRAYSIZE(sreTable), UseRegularExpressions | MatchAllOccurrences);
 }
 
-TEST_METHOD(VerifyReplaceFirstWildCardMatchAllOccurrences)
-{
-    SearchReplaceExpected sreTable[] = {
-        //search, replace, test, result
-        { L".*", L"Foo", L"AAAAAA", L"AAAAAA" },
-        { L".*", L"Foo", L".*", L"Foo" },
-        { L".*", L"Foo", L".*Bar.*", L"FooBarFoo" },
-    };
-    VerifyReplaceFirstWildcard(sreTable, ARRAYSIZE(sreTable), MatchAllOccurrences);
-}
-
-TEST_METHOD(VerifyReplaceFirstWildNoFlags)
-{
-    SearchReplaceExpected sreTable[] = {
-        //search, replace, test, result
-        { L".*", L"Foo", L"AAAAAA", L"AAAAAA" },
-        { L".*", L"Foo", L".*", L"Foo" },
-    };
-    VerifyReplaceFirstWildcard(sreTable, ARRAYSIZE(sreTable), 0);
-}
-
 TEST_METHOD(VerifyHandleCapturingGroups)
 {
     // This differs from the Standard Library: Boost does not recognize $123 as $1 and "23".
@@ -380,7 +93,8 @@ TEST_METHOD(VerifyHandleCapturingGroups)
         PWSTR result = nullptr;
         Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
         Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
         Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
         CoTaskMemFree(result);
     }
@@ -407,32 +121,11 @@ TEST_METHOD(VerifyLookbehind)
         PWSTR result = nullptr;
         Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
         Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
         Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
         CoTaskMemFree(result);
     }
 }
-
-TEST_METHOD(VerifyEventsFire)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    CMockPowerRenameRegExEvents* mockEvents = new CMockPowerRenameRegExEvents();
-    CComPtr<IPowerRenameRegExEvents> regExEvents;
-    Assert::IsTrue(mockEvents->QueryInterface(IID_PPV_ARGS(&regExEvents)) == S_OK);
-    DWORD cookie = 0;
-    Assert::IsTrue(renameRegEx->Advise(regExEvents, &cookie) == S_OK);
-    DWORD flags = MatchAllOccurrences | UseRegularExpressions | CaseSensitive;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-    Assert::IsTrue(renameRegEx->PutSearchTerm(L"FOO") == S_OK);
-    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"BAR") == S_OK);
-    Assert::IsTrue(renameRegEx->PutFileTime(SYSTEMTIME{0}) == S_OK);
-    Assert::IsTrue(renameRegEx->ResetFileTime() == S_OK);
-    Assert::IsTrue(lstrcmpi(L"FOO", mockEvents->m_searchTerm) == 0);
-    Assert::IsTrue(lstrcmpi(L"BAR", mockEvents->m_replaceTerm) == 0);
-    Assert::IsTrue(flags == mockEvents->m_flags);
-    Assert::IsTrue(renameRegEx->UnAdvise(cookie) == S_OK);
-    mockEvents->Release();
-}
 };
 }

src/modules/powerrename/unittests/PowerRenameRegExTests.cpp

@@ -8,14 +8,6 @@ using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 namespace PowerRenameRegExTests
 {
-    struct SearchReplaceExpected
-    {
-        PCWSTR search;
-        PCWSTR replace;
-        PCWSTR test;
-        PCWSTR expected;
-    };
-
     TEST_CLASS(SimpleTests){
         public:
 TEST_CLASS_INITIALIZE(ClassInitialize)
@@ -23,241 +15,8 @@ TEST_CLASS_INITIALIZE(ClassInitialize)
     CSettingsInstance().SetUseBoostLib(false);
 }
 
-TEST_METHOD(GeneralReplaceTest)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    PWSTR result = nullptr;
-    Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
-    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"big") == S_OK);
-    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
-    Assert::IsTrue(wcscmp(result, L"bigbar") == 0);
-    CoTaskMemFree(result);
-}
-
-TEST_METHOD(ReplaceNoMatch)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    PWSTR result = nullptr;
-    Assert::IsTrue(renameRegEx->PutSearchTerm(L"notfound") == S_OK);
-    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"big") == S_OK);
-    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
-    Assert::IsTrue(wcscmp(result, L"foobar") == 0);
-    CoTaskMemFree(result);
-}
-
-TEST_METHOD(ReplaceNoSearchOrReplaceTerm)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    PWSTR result = nullptr;
-    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
-    Assert::IsTrue(result == nullptr);
-    CoTaskMemFree(result);
-}
-
-TEST_METHOD(ReplaceNoReplaceTerm)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    PWSTR result = nullptr;
-    Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
-    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
-    Assert::IsTrue(wcscmp(result, L"bar") == 0);
-    CoTaskMemFree(result);
-}
-
-TEST_METHOD(ReplaceEmptyStringReplaceTerm)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    PWSTR result = nullptr;
-    Assert::IsTrue(renameRegEx->PutSearchTerm(L"foo") == S_OK);
-    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"") == S_OK);
-    Assert::IsTrue(renameRegEx->Replace(L"foobar", &result) == S_OK);
-    Assert::IsTrue(wcscmp(result, L"bar") == 0);
-    CoTaskMemFree(result);
-}
-
-TEST_METHOD(VerifyDefaultFlags)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = 0;
-    Assert::IsTrue(renameRegEx->GetFlags(&flags) == S_OK);
-    Assert::IsTrue(flags == 0);
-}
-
-TEST_METHOD(VerifyCaseSensitiveSearch)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = CaseSensitive;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"Foo", L"Foo", L"FooBar", L"FooBar" },
-        { L"Foo", L"boo", L"FooBar", L"booBar" },
-        { L"Foo", L"boo", L"foobar", L"foobar" },
-        { L"123", L"654", L"123456", L"654456" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceFirstOnly)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = 0;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AABBA" },
-        { L"B", L"BBB", L"ABABAB", L"ABBBABAB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceAll)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = MatchAllOccurrences;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AAAAA" },
-        { L"B", L"BBB", L"ABABAB", L"ABBBABBBABBB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceAllCaseInsensitive)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = MatchAllOccurrences | CaseSensitive;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AAAAA" },
-        { L"B", L"BBB", L"ABABAB", L"ABBBABBBABBB" },
-        { L"b", L"BBB", L"AbABAb", L"ABBBABABBB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceFirstOnlyUseRegEx)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = UseRegularExpressions;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AABBA" },
-        { L"B", L"BBB", L"ABABAB", L"ABBBABAB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceAllUseRegEx)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = MatchAllOccurrences | UseRegularExpressions;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AAAAA" },
-        { L"B", L"BBB", L"ABABAB", L"ABBBABBBABBB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceAllUseRegExCaseSensitive)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    DWORD flags = MatchAllOccurrences | UseRegularExpressions | CaseSensitive;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    SearchReplaceExpected sreTable[] = {
-        { L"B", L"BB", L"ABA", L"ABBA" },
-        { L"B", L"A", L"ABBBA", L"AAAAA" },
-        { L"b", L"BBB", L"AbABAb", L"ABBBABABBB" },
-    };
-
-    for (int i = 0; i < ARRAYSIZE(sreTable); i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
-        CoTaskMemFree(result);
-    }
-}
+#define TESTS_PARTIAL
+#include "CommonRegExTests.h"
 
 TEST_METHOD(VerifyMatchAllWildcardUseRegEx)
 {
@@ -275,38 +34,13 @@ TEST_METHOD(VerifyMatchAllWildcardUseRegEx)
         PWSTR result = nullptr;
         Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
         Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
         Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
         CoTaskMemFree(result);
     }
 }
 
-void VerifyReplaceFirstWildcard(SearchReplaceExpected sreTable[], int tableSize, DWORD flags)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-
-    for (int i = 0; i < tableSize; i++)
-    {
-        PWSTR result = nullptr;
-        Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
-        Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
-        Assert::AreEqual(sreTable[i].expected, result);
-        CoTaskMemFree(result);
-    }
-}
-
-TEST_METHOD(VerifyReplaceFirstWildCardUseRegex)
-{
-    SearchReplaceExpected sreTable[] = {
-        //search, replace, test, result
-        { L".*", L"Foo", L"AAAAAA", L"Foo" },
-    };
-    VerifyReplaceFirstWildcard(sreTable, ARRAYSIZE(sreTable), UseRegularExpressions);
-}
-
 TEST_METHOD(VerifyReplaceFirstWildCardUseRegexMatchAllOccurrences)
 {
     SearchReplaceExpected sreTable[] = {
@@ -316,27 +50,6 @@ TEST_METHOD(VerifyReplaceFirstWildCardUseRegexMatchAllOccurrences)
     VerifyReplaceFirstWildcard(sreTable, ARRAYSIZE(sreTable), UseRegularExpressions | MatchAllOccurrences);
 }
 
-TEST_METHOD(VerifyReplaceFirstWildCardMatchAllOccurrences)
-{
-    SearchReplaceExpected sreTable[] = {
-        //search, replace, test, result
-        { L".*", L"Foo", L"AAAAAA", L"AAAAAA" },
-        { L".*", L"Foo", L".*", L"Foo" },
-        { L".*", L"Foo", L".*Bar.*", L"FooBarFoo" },
-    };
-    VerifyReplaceFirstWildcard(sreTable, ARRAYSIZE(sreTable), MatchAllOccurrences);
-}
-
-TEST_METHOD(VerifyReplaceFirstWildNoFlags)
-{
-    SearchReplaceExpected sreTable[] = {
-        //search, replace, test, result
-        { L".*", L"Foo", L"AAAAAA", L"AAAAAA" },
-        { L".*", L"Foo", L".*", L"Foo" },
-    };
-    VerifyReplaceFirstWildcard(sreTable, ARRAYSIZE(sreTable), 0);
-}
-
 TEST_METHOD(VerifyHandleCapturingGroups)
 {
     CComPtr<IPowerRenameRegEx> renameRegEx;
@@ -362,7 +75,8 @@ TEST_METHOD(VerifyHandleCapturingGroups)
         PWSTR result = nullptr;
         Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
         Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
         Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
         CoTaskMemFree(result);
     }
@@ -387,7 +101,8 @@ TEST_METHOD (VerifyFileAttributesNoPadding)
         Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
         Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
         Assert::IsTrue(renameRegEx->PutFileTime(fileTime) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
         Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
         CoTaskMemFree(result);
     }
@@ -411,7 +126,8 @@ TEST_METHOD (VerifyFileAttributesPadding)
         Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
         Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
         Assert::IsTrue(renameRegEx->PutFileTime(fileTime) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
         Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
         CoTaskMemFree(result);
     }
@@ -459,7 +175,8 @@ TEST_METHOD (VerifyFileAttributesMonthandDayNames)
         Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
         Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
         Assert::IsTrue(renameRegEx->PutFileTime(fileTime) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == S_OK);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == S_OK);
         Assert::IsTrue(wcscmp(result, sreTable[i].expected) == 0);
         CoTaskMemFree(result);
     }
@@ -483,33 +200,12 @@ TEST_METHOD(VerifyLookbehindFails)
         PWSTR result = nullptr;
         Assert::IsTrue(renameRegEx->PutSearchTerm(sreTable[i].search) == S_OK);
         Assert::IsTrue(renameRegEx->PutReplaceTerm(sreTable[i].replace) == S_OK);
-        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result) == E_FAIL);
+        unsigned long index = {};
+        Assert::IsTrue(renameRegEx->Replace(sreTable[i].test, &result, index) == E_FAIL);
         Assert::AreEqual(sreTable[i].expected, result);
         CoTaskMemFree(result);
     }
 }
 
-TEST_METHOD(VerifyEventsFire)
-{
-    CComPtr<IPowerRenameRegEx> renameRegEx;
-    Assert::IsTrue(CPowerRenameRegEx::s_CreateInstance(&renameRegEx) == S_OK);
-    CMockPowerRenameRegExEvents* mockEvents = new CMockPowerRenameRegExEvents();
-    CComPtr<IPowerRenameRegExEvents> regExEvents;
-    Assert::IsTrue(mockEvents->QueryInterface(IID_PPV_ARGS(&regExEvents)) == S_OK);
-    DWORD cookie = 0;
-    Assert::IsTrue(renameRegEx->Advise(regExEvents, &cookie) == S_OK);
-    DWORD flags = MatchAllOccurrences | UseRegularExpressions | CaseSensitive;
-    Assert::IsTrue(renameRegEx->PutFlags(flags) == S_OK);
-    Assert::IsTrue(renameRegEx->PutSearchTerm(L"FOO") == S_OK);
-    Assert::IsTrue(renameRegEx->PutReplaceTerm(L"BAR") == S_OK);
-    Assert::IsTrue(renameRegEx->PutFileTime(SYSTEMTIME{ 0 }) == S_OK);
-    Assert::IsTrue(renameRegEx->ResetFileTime() == S_OK);
-    Assert::IsTrue(lstrcmpi(L"FOO", mockEvents->m_searchTerm) == 0);
-    Assert::IsTrue(lstrcmpi(L"BAR", mockEvents->m_replaceTerm) == 0);
-    Assert::IsTrue(flags == mockEvents->m_flags);
-    Assert::IsTrue(renameRegEx->UnAdvise(cookie) == S_OK);
-    mockEvents->Release();
-}
-}
-;
+};
 }

src/modules/powerrename/unittests/pch.h

@@ -3,11 +3,4 @@
 #include "targetver.h"
 
 #include <atlbase.h>
-
-// Headers for CppUnitTest
-
-// Suppressing 26466 - Don't use static_cast downcasts - in CppUnitTest.h
-#pragma warning(push)
-#pragma warning(disable : 26466)
-#include "CppUnitTest.h"
-#pragma warning(pop)
+#include "CppUnitTestInclude.h"