Package.proj

<Project DefaultTargets="Package">
  <Import Project="Version.props" />

  <UsingTask TaskName="ParsePackageVersion" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
    <ParameterGroup>
      <Version ParameterType="System.String" Required="true" />
      <Major ParameterType="System.String" Output="true" />
      <Minor ParameterType="System.String" Output="true" />
      <Patch ParameterType="System.String" Output="true" />
      <Build ParameterType="System.String" Output="true" />
    </ParameterGroup>
    <Task>
      <Using Namespace="System.Text.RegularExpressions" />
      <Code Type="Fragment" Language="cs"><![CDATA[
        var match = Regex.Match(Version ?? "", @"^(\d+)\.(\d+)\.(\d+)$");
        if (!match.Success)
        {
            Log.LogError("Version must use numeric major.minor.patch format. Got: {0}", Version);
            return false;
        }

        Major = match.Groups[1].Value;
        Minor = match.Groups[2].Value;
        Patch = match.Groups[3].Value;
        Build = "0";
        return true;
      ]]></Code>
    </Task>
  </UsingTask>

  <UsingTask TaskName="ValidateNativeDllVersion" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
    <ParameterGroup>
      <DllPath ParameterType="System.String" Required="true" />
      <ExpectedVersion ParameterType="System.String" Required="true" />
    </ParameterGroup>
    <Task>
      <Using Namespace="System" />
      <Using Namespace="System.Diagnostics" />
      <Using Namespace="System.IO" />
      <Code Type="Fragment" Language="cs"><![CDATA[
        if (!File.Exists(DllPath))
        {
            Log.LogError("Plugin DLL not found: {0}", DllPath);
            return false;
        }

        var versionInfo = FileVersionInfo.GetVersionInfo(DllPath);
        if (!String.Equals(versionInfo.FileVersion, ExpectedVersion, StringComparison.Ordinal))
        {
            Log.LogError("DLL FileVersion mismatch. Expected {0}, got {1}", ExpectedVersion, versionInfo.FileVersion);
            return false;
        }

        if (!String.Equals(versionInfo.ProductVersion, ExpectedVersion, StringComparison.Ordinal))
        {
            Log.LogError("DLL ProductVersion mismatch. Expected {0}, got {1}", ExpectedVersion, versionInfo.ProductVersion);
            return false;
        }

        return true;
      ]]></Code>
    </Task>
  </UsingTask>

  <UsingTask TaskName="ValidateZipEntries" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
    <ParameterGroup>
      <ZipPath ParameterType="System.String" Required="true" />
      <Entries ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
    </ParameterGroup>
    <Task>
      <Reference Include="System.IO.Compression" />
      <Reference Include="System.IO.Compression.FileSystem" />
      <Using Namespace="System.Collections.Generic" />
      <Using Namespace="System.IO" />
      <Using Namespace="System.IO.Compression" />
      <Code Type="Fragment" Language="cs"><![CDATA[
        if (!File.Exists(ZipPath))
        {
            Log.LogError("ZIP package not found: {0}", ZipPath);
            return false;
        }

        var actualEntries = new HashSet<string>(System.StringComparer.Ordinal);
        using (var zip = ZipFile.OpenRead(ZipPath))
        {
            foreach (var entry in zip.Entries)
            {
                actualEntries.Add(entry.FullName.Replace('\\', '/'));
            }
        }

        var ok = true;
        foreach (var entry in Entries)
        {
            var required = entry.ItemSpec.Replace('\\', '/');
            if (!actualEntries.Contains(required))
            {
                Log.LogError("ZIP package is missing required entry '{0}': {1}", required, ZipPath);
                ok = false;
            }
        }

        return ok;
      ]]></Code>
    </Task>
  </UsingTask>

  <UsingTask TaskName="ResolveCoverageConsole" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
    <ParameterGroup>
      <CoverageConsole ParameterType="System.String" Output="true" />
    </ParameterGroup>
    <Task>
      <Using Namespace="System" />
      <Using Namespace="System.Collections.Generic" />
      <Using Namespace="System.Diagnostics" />
      <Using Namespace="System.IO" />
      <Using Namespace="System.Linq" />
      <Code Type="Fragment" Language="cs"><![CDATA[
        var installRoots = new List<string>();
        var vsInstallDir = Environment.GetEnvironmentVariable("VSINSTALLDIR");
        if (!String.IsNullOrWhiteSpace(vsInstallDir))
        {
            installRoots.Add(vsInstallDir.TrimEnd('\\', '/'));
        }

        var programFilesX86 = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86);
        var vswhere = Path.Combine(programFilesX86, "Microsoft Visual Studio", "Installer", "vswhere.exe");
        if (File.Exists(vswhere))
        {
            var info = new ProcessStartInfo(vswhere, "-latest -products * -requires Microsoft.Component.MSBuild -property installationPath")
            {
                UseShellExecute = false,
                RedirectStandardOutput = true,
                CreateNoWindow = true
            };
            using (var process = Process.Start(info))
            {
                var output = process.StandardOutput.ReadToEnd();
                process.WaitForExit();
                installRoots.AddRange(output.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries));
            }
        }

        installRoots.Add(Path.Combine(programFilesX86, "Microsoft Visual Studio", "2022", "BuildTools"));
        installRoots.Add(Path.Combine(programFilesX86, "Microsoft Visual Studio", "2022", "Enterprise"));
        installRoots.Add(Path.Combine(programFilesX86, "Microsoft Visual Studio", "2022", "Community"));
        installRoots.Add(Path.Combine(programFilesX86, "Microsoft Visual Studio", "2022", "Professional"));

        foreach (var root in installRoots.Where(p => !String.IsNullOrWhiteSpace(p)).Distinct(StringComparer.OrdinalIgnoreCase))
        {
            var candidate = Path.Combine(root.TrimEnd('\\', '/'), "Common7", "IDE", "Extensions", "Microsoft", "CodeCoverage.Console", "Microsoft.CodeCoverage.Console.exe");
            if (File.Exists(candidate))
            {
                CoverageConsole = candidate;
                Log.LogMessage(MessageImportance.High, "Using coverage console: {0}", CoverageConsole);
                return true;
            }
        }

        Log.LogError("Microsoft.CodeCoverage.Console.exe was not found in the current Visual Studio installation.");
        return false;
      ]]></Code>
    </Task>
  </UsingTask>

  <UsingTask TaskName="NormalizeCoberturaCoverage" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
    <ParameterGroup>
      <InputPath ParameterType="System.String" Required="true" />
      <OutputPath ParameterType="System.String" Required="true" />
      <ProjectRoot ParameterType="System.String" Required="true" />
      <SourceRoot ParameterType="System.String" Required="true" />
    </ParameterGroup>
    <Task>
      <Reference Include="System.Xml" />
      <Reference Include="System.Xml.Linq" />
      <Using Namespace="System" />
      <Using Namespace="System.Collections.Generic" />
      <Using Namespace="System.Globalization" />
      <Using Namespace="System.IO" />
      <Using Namespace="System.Linq" />
      <Using Namespace="System.Text" />
      <Using Namespace="System.Xml" />
      <Using Namespace="System.Xml.Linq" />
      <Code Type="Fragment" Language="cs"><![CDATA[
        var projectRoot = Path.GetFullPath(ProjectRoot).TrimEnd('\\', '/');
        var sourceRoot = Path.GetFullPath(SourceRoot).TrimEnd('\\', '/');
        Func<string, string> fullPath = path => Path.GetFullPath(path).TrimEnd('\\', '/');
        Func<string, bool> isUnderSourceRoot = path =>
        {
            var candidate = fullPath(path);
            return candidate.Equals(sourceRoot, StringComparison.OrdinalIgnoreCase) ||
                candidate.StartsWith(sourceRoot + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase);
        };
        Func<double, string> formatDecimal = value => value.ToString("0.###############", CultureInfo.InvariantCulture);
        Action<XElement, int, int> setLineRate = (node, covered, valid) =>
        {
            var rate = valid == 0 ? 1.0 : (double)covered / valid;
            node.SetAttributeValue("line-rate", formatDecimal(rate));
        };
        Func<string, string> relativePath = path =>
        {
            var rootUri = new Uri(projectRoot + Path.DirectorySeparatorChar);
            var pathUri = new Uri(Path.GetFullPath(path));
            return Uri.UnescapeDataString(rootUri.MakeRelativeUri(pathUri).ToString()).Replace('\\', '/');
        };
        Func<IEnumerable<XElement>, Dictionary<int, int>> collectLineHits = classes =>
        {
            var hitsByLine = new Dictionary<int, int>();
            foreach (var line in classes.Descendants("line"))
            {
                int number;
                int hits;
                if (!Int32.TryParse((string)line.Attribute("number"), out number))
                {
                    continue;
                }
                if (!Int32.TryParse((string)line.Attribute("hits"), out hits))
                {
                    hits = 0;
                }
                int existing;
                if (!hitsByLine.TryGetValue(number, out existing) || hits > existing)
                {
                    hitsByLine[number] = hits;
                }
            }
            return hitsByLine;
        };

        var document = XDocument.Load(InputPath);
        foreach (var classNode in document.Descendants("class").ToList())
        {
            var filename = (string)classNode.Attribute("filename");
            if (String.IsNullOrWhiteSpace(filename) || !isUnderSourceRoot(filename))
            {
                classNode.Remove();
            }
        }

        var classesByFile = document.Descendants("class")
            .GroupBy(node => Path.GetFullPath((string)node.Attribute("filename")), StringComparer.OrdinalIgnoreCase)
            .ToList();
        foreach (var fileGroup in classesByFile)
        {
            var lineHits = collectLineHits(fileGroup);
            var keptClass = fileGroup.First();
            foreach (var duplicate in fileGroup.Skip(1).ToList())
            {
                duplicate.Remove();
            }

            keptClass.Elements("methods").Remove();
            keptClass.Elements("lines").Remove();
            keptClass.Add(new XElement("lines",
                lineHits.OrderBy(pair => pair.Key).Select(pair =>
                    new XElement("line",
                        new XAttribute("number", pair.Key.ToString(CultureInfo.InvariantCulture)),
                        new XAttribute("hits", pair.Value.ToString(CultureInfo.InvariantCulture)),
                        new XAttribute("branch", "False")))));

            var covered = lineHits.Values.Count(value => value > 0);
            var valid = lineHits.Count;
            setLineRate(keptClass, covered, valid);
            keptClass.SetAttributeValue("filename", relativePath(fileGroup.Key));
            keptClass.SetAttributeValue("name", Path.GetFileNameWithoutExtension(fileGroup.Key));
        }

        foreach (var package in document.Descendants("package").ToList())
        {
            var packageClasses = package.Descendants("class").ToList();
            if (packageClasses.Count == 0)
            {
                package.Remove();
                continue;
            }

            var valid = packageClasses.Sum(node => node.Element("lines").Elements("line").Count());
            var covered = packageClasses.Sum(node => node.Element("lines").Elements("line").Count(line => ((int?)line.Attribute("hits") ?? 0) > 0));
            setLineRate(package, covered, valid);
        }

        var allClasses = document.Descendants("class").ToList();
        var linesValid = allClasses.Sum(node => node.Element("lines").Elements("line").Count());
        var linesCovered = allClasses.Sum(node => node.Element("lines").Elements("line").Count(line => ((int?)line.Attribute("hits") ?? 0) > 0));
        var coverage = document.Root;
        setLineRate(coverage, linesCovered, linesValid);
        coverage.SetAttributeValue("lines-covered", linesCovered.ToString(CultureInfo.InvariantCulture));
        coverage.SetAttributeValue("lines-valid", linesValid.ToString(CultureInfo.InvariantCulture));

        Directory.CreateDirectory(Path.GetDirectoryName(OutputPath));
        var settings = new XmlWriterSettings { Encoding = new UTF8Encoding(false), Indent = true };
        using (var writer = XmlWriter.Create(OutputPath, settings))
        {
            document.Save(writer);
        }

        Log.LogMessage(MessageImportance.High, "Normalized Cobertura line coverage: {0} / {1}", linesCovered, linesValid);
        Log.LogMessage(MessageImportance.High, "Cobertura report: {0}", OutputPath);
        return true;
      ]]></Code>
    </Task>
  </UsingTask>

  <UsingTask TaskName="VerifyCoberturaCoverage" TaskFactory="CodeTaskFactory" AssemblyFile="$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll">
    <ParameterGroup>
      <InputPath ParameterType="System.String" Required="true" />
      <MinimumLineRate ParameterType="System.String" Required="true" />
    </ParameterGroup>
    <Task>
      <Reference Include="System.Xml" />
      <Reference Include="System.Xml.Linq" />
      <Using Namespace="System" />
      <Using Namespace="System.Globalization" />
      <Using Namespace="System.Xml.Linq" />
      <Code Type="Fragment" Language="cs"><![CDATA[
        var document = XDocument.Load(InputPath);
        var coverage = document.Root;
        double actual;
        double minimum;
        if (coverage == null || !Double.TryParse((string)coverage.Attribute("line-rate"), NumberStyles.Float, CultureInfo.InvariantCulture, out actual))
        {
            Log.LogError("Coverage report does not contain a valid root line-rate: {0}", InputPath);
            return false;
        }
        if (!Double.TryParse(MinimumLineRate, NumberStyles.Float, CultureInfo.InvariantCulture, out minimum))
        {
            Log.LogError("MinimumLineRate is not a valid decimal value: {0}", MinimumLineRate);
            return false;
        }
        Log.LogMessage(MessageImportance.High, "C++ core line coverage: {0:P2}; required: {1:P2}", actual, minimum);
        if (actual < minimum)
        {
            Log.LogError("C++ core line coverage {0:P2} is below the required {1:P2}.", actual, minimum);
            return false;
        }
        return true;
      ]]></Code>
    </Task>
  </UsingTask>

  <PropertyGroup>
    <Configuration Condition="'$(Configuration)'==''">Release</Configuration>
    <Platform Condition="'$(Platform)'==''">x64</Platform>
    <ResolvedPackageVersion>$(MarkdownTableEditorVersion)</ResolvedPackageVersion>
    <ProjectRoot>$(MSBuildThisFileDirectory)</ProjectRoot>
    <PluginProject>$(ProjectRoot)vs.proj\MarkdownTableEditor.vcxproj</PluginProject>
    <TestProject>$(ProjectRoot)tests\CoreSmoke.vcxproj</TestProject>
    <TestExe>$(ProjectRoot)tests\CoreSmoke.exe</TestExe>
    <PerformanceProject>$(ProjectRoot)tests\CorePerformance.vcxproj</PerformanceProject>
    <PerformanceExe>$(ProjectRoot)tests\CorePerformance.exe</PerformanceExe>
    <PluginShortcutTestProject>$(ProjectRoot)tests\PluginShortcutSmoke.vcxproj</PluginShortcutTestProject>
    <PluginShortcutTestExe>$(ProjectRoot)tests\PluginShortcutSmoke.exe</PluginShortcutTestExe>
    <BuildDir>$(ProjectRoot)build</BuildDir>
    <CoverageWorkDir>$(BuildDir)\coverage</CoverageWorkDir>
    <CoverageReportsDir>$(BuildDir)\reports\coverage</CoverageReportsDir>
    <RawCoverageReport>$(CoverageWorkDir)\coverage.raw.cobertura.xml</RawCoverageReport>
    <CoverageReport>$(CoverageReportsDir)\coverage.cobertura.xml</CoverageReport>
    <MinimumCoreLineCoverage Condition="'$(MinimumCoreLineCoverage)'==''">0.70</MinimumCoreLineCoverage>
    <PackageRoot>$(BuildDir)\dist</PackageRoot>
    <PackageDir>$(PackageRoot)\MarkdownTableEditor</PackageDir>
    <PluginAdminPackageDir>$(BuildDir)\pluginadmin</PluginAdminPackageDir>
  </PropertyGroup>

  <PropertyGroup>
    <BuildPlatform Condition="'$(Platform)'=='x86'">Win32</BuildPlatform>
    <BuildPlatform Condition="'$(Platform)'=='arm' Or '$(Platform)'=='arm64'">ARM64</BuildPlatform>
    <BuildPlatform Condition="'$(BuildPlatform)'==''">$(Platform)</BuildPlatform>
    <PackagePlatform Condition="'$(BuildPlatform)'=='Win32'">x86</PackagePlatform>
    <PackagePlatform Condition="'$(BuildPlatform)'=='ARM64'">arm64</PackagePlatform>
    <PackagePlatform Condition="'$(PackagePlatform)'==''">$(BuildPlatform)</PackagePlatform>
    <OutputDir Condition="'$(BuildPlatform)'=='Win32'">$(ProjectRoot)bin</OutputDir>
    <OutputDir Condition="'$(BuildPlatform)'=='x64'">$(ProjectRoot)bin64</OutputDir>
    <OutputDir Condition="'$(BuildPlatform)'=='ARM64'">$(ProjectRoot)arm64</OutputDir>
    <DllPath>$(OutputDir)\MarkdownTableEditor.dll</DllPath>
    <ZipPath>$(BuildDir)\MarkdownTableEditor-$(ResolvedPackageVersion)-$(PackagePlatform).zip</ZipPath>
    <PluginAdminZipPath>$(BuildDir)\MarkdownTableEditor-$(ResolvedPackageVersion)-$(PackagePlatform)-pluginadmin.zip</PluginAdminZipPath>
  </PropertyGroup>

  <Target Name="VerifyCanonicalVersion">
    <XmlPeek XmlInputPath="$(ProjectRoot)Version.props" Query="/Project/PropertyGroup/MarkdownTableEditorVersionMajor/text()">
      <Output TaskParameter="Result" PropertyName="CanonicalVersionMajor" />
    </XmlPeek>
    <XmlPeek XmlInputPath="$(ProjectRoot)Version.props" Query="/Project/PropertyGroup/MarkdownTableEditorVersionMinor/text()">
      <Output TaskParameter="Result" PropertyName="CanonicalVersionMinor" />
    </XmlPeek>
    <XmlPeek XmlInputPath="$(ProjectRoot)Version.props" Query="/Project/PropertyGroup/MarkdownTableEditorVersionPatch/text()">
      <Output TaskParameter="Result" PropertyName="CanonicalVersionPatch" />
    </XmlPeek>
    <XmlPeek XmlInputPath="$(ProjectRoot)Version.props" Query="/Project/PropertyGroup/MarkdownTableEditorVersionBuild/text()">
      <Output TaskParameter="Result" PropertyName="CanonicalVersionBuild" />
    </XmlPeek>
    <PropertyGroup>
      <VersionPropsCanonicalVersion>$(CanonicalVersionMajor).$(CanonicalVersionMinor).$(CanonicalVersionPatch)</VersionPropsCanonicalVersion>
    </PropertyGroup>
    <Error Condition="'$(CanonicalVersionMajor)'=='' Or '$(CanonicalVersionMinor)'=='' Or '$(CanonicalVersionPatch)'=='' Or '$(CanonicalVersionBuild)'==''" Text="Version.props must define MarkdownTableEditorVersionMajor, MarkdownTableEditorVersionMinor, MarkdownTableEditorVersionPatch, and MarkdownTableEditorVersionBuild." />
    <Error Condition="'$(ResolvedPackageVersion)'!='$(VersionPropsCanonicalVersion)'" Text="Package version must come from Version.props. Expected $(VersionPropsCanonicalVersion), got $(ResolvedPackageVersion)." />
    <Error Condition="'$(MarkdownTableEditorVersionBuild)'!='$(CanonicalVersionBuild)'" Text="Package version build component must come from Version.props. Expected build $(CanonicalVersionBuild), got $(MarkdownTableEditorVersionBuild)." />
    <Error Condition="'$(Version)'!='' And '$(Version)'!='$(VersionPropsCanonicalVersion)'" Text="/p:Version is not a source of truth. Update Version.props to $(Version), or build with the current Version.props value $(VersionPropsCanonicalVersion)." />
    <Message Importance="high" Text="Resolved MarkdownTableEditor version from Version.props: $(VersionPropsCanonicalVersion)" />
  </Target>

  <Target Name="ResolvePackageInputs" DependsOnTargets="VerifyCanonicalVersion">
    <Error Condition="'$(BuildPlatform)'!='Win32' And '$(BuildPlatform)'!='x64' And '$(BuildPlatform)'!='ARM64'" Text="Platform must be x86, Win32, x64, arm64, or ARM64. Got: $(Platform)" />
    <ParsePackageVersion Version="$(ResolvedPackageVersion)">
      <Output TaskParameter="Major" PropertyName="PackageVersionMajor" />
      <Output TaskParameter="Minor" PropertyName="PackageVersionMinor" />
      <Output TaskParameter="Patch" PropertyName="PackageVersionPatch" />
      <Output TaskParameter="Build" PropertyName="PackageVersionBuild" />
    </ParsePackageVersion>
  </Target>

  <Target Name="CleanPackage">
    <RemoveDir Directories="$(PackageRoot);$(PluginAdminPackageDir)" Condition="Exists('$(PackageRoot)') Or Exists('$(PluginAdminPackageDir)')" />
    <MakeDir Directories="$(PackageDir);$(PluginAdminPackageDir)" />
  </Target>

  <Target Name="BuildPlugin" DependsOnTargets="ResolvePackageInputs">
    <Message Importance="high" Text="Building MarkdownTableEditor $(ResolvedPackageVersion) $(Configuration)|$(BuildPlatform)" />
    <MSBuild Projects="$(PluginProject)"
             Targets="Rebuild"
             Properties="Configuration=$(Configuration);Platform=$(BuildPlatform);SkipCoreScenarioTests=true;MarkdownTableEditorVersionMajor=$(PackageVersionMajor);MarkdownTableEditorVersionMinor=$(PackageVersionMinor);MarkdownTableEditorVersionPatch=$(PackageVersionPatch);MarkdownTableEditorVersionBuild=$(PackageVersionBuild)" />
  </Target>

  <Target Name="BuildNppCompatibilitySmokePlugins">
    <MSBuild Projects="$(MSBuildThisFileFullPath)"
             Targets="BuildPlugin"
             Properties="Configuration=Release;Platform=Win32" />
    <MSBuild Projects="$(MSBuildThisFileFullPath)"
             Targets="BuildPlugin"
             Properties="Configuration=Release;Platform=x64" />
  </Target>

  <Target Name="NppCompatibilitySmoke" DependsOnTargets="BuildNppCompatibilitySmokePlugins">
    <Exec Command="powershell -NoProfile -ExecutionPolicy Bypass -File &quot;$(ProjectRoot)scripts\Invoke-NppCompatibilitySmoke.ps1&quot; -Win32PluginPath &quot;$(ProjectRoot)bin\MarkdownTableEditor.dll&quot; -X64PluginPath &quot;$(ProjectRoot)bin64\MarkdownTableEditor.dll&quot;" />
  </Target>

  <Target Name="BuildReleaseAllPlatforms">
    <ItemGroup>
      <ReleaseBuildPlatform Include="Win32" />
      <ReleaseBuildPlatform Include="x64" />
      <ReleaseBuildPlatform Include="ARM64" />
    </ItemGroup>
    <Message Importance="high" Text="Building MarkdownTableEditor Release|%(ReleaseBuildPlatform.Identity)" />
    <MSBuild Projects="$(PluginProject)"
             Targets="Build"
             Properties="Configuration=Release;Platform=%(ReleaseBuildPlatform.Identity)" />
  </Target>

  <Target Name="BuildCoreSmokeTests">
    <MSBuild Projects="$(TestProject)" Targets="Rebuild" Properties="Configuration=Debug;Platform=x64" />
  </Target>

  <Target Name="RunCoreSmokeTests" DependsOnTargets="BuildCoreSmokeTests">
    <Exec Command="&quot;$(TestExe)&quot;" />
  </Target>

  <Target Name="BuildCorePerformanceBenchmarks">
    <MSBuild Projects="$(PerformanceProject)" Targets="Rebuild" Properties="Configuration=Release;Platform=x64" />
  </Target>

  <Target Name="RunCorePerformanceBenchmarks" DependsOnTargets="BuildCorePerformanceBenchmarks">
    <Exec Command="&quot;$(PerformanceExe)&quot;" />
  </Target>

  <Target Name="CorePerformance" DependsOnTargets="RunCorePerformanceBenchmarks" />

  <Target Name="BuildPluginShortcutSmokeTests">
    <MSBuild Projects="$(PluginShortcutTestProject)" Targets="Rebuild" Properties="Configuration=Debug;Platform=x64" />
  </Target>

  <Target Name="RunPluginShortcutSmokeTests" DependsOnTargets="BuildPluginShortcutSmokeTests">
    <Exec Command="&quot;$(PluginShortcutTestExe)&quot;" />
  </Target>

  <Target Name="CleanCoverage">
    <RemoveDir Directories="$(CoverageWorkDir);$(CoverageReportsDir)" Condition="Exists('$(CoverageWorkDir)') Or Exists('$(CoverageReportsDir)')" />
    <MakeDir Directories="$(CoverageWorkDir);$(CoverageReportsDir)" />
  </Target>

  <Target Name="ResolveCoverageInputs">
    <ResolveCoverageConsole>
      <Output TaskParameter="CoverageConsole" PropertyName="CoverageConsole" />
    </ResolveCoverageConsole>
  </Target>

  <Target Name="Coverage" DependsOnTargets="CleanCoverage;BuildCoreSmokeTests;ResolveCoverageInputs">
    <Exec Command="&quot;$(CoverageConsole)&quot; collect --nologo --output &quot;$(RawCoverageReport)&quot; --output-format cobertura --include-files &quot;$(ProjectRoot)src\MarkdownTableCore.cpp&quot; &quot;$(TestExe)&quot;" />
    <NormalizeCoberturaCoverage InputPath="$(RawCoverageReport)"
                                OutputPath="$(CoverageReport)"
                                ProjectRoot="$(ProjectRoot)"
                                SourceRoot="$(ProjectRoot)src" />
    <VerifyCoberturaCoverage InputPath="$(CoverageReport)"
                             MinimumLineRate="$(MinimumCoreLineCoverage)" />
  </Target>

  <Target Name="ValidateDllVersion">
    <ValidateNativeDllVersion DllPath="$(DllPath)" ExpectedVersion="$(ResolvedPackageVersion)" />
  </Target>

  <Target Name="PreparePackage">
    <ItemGroup>
      <PackageRootFile Include="$(DllPath)" />
      <PackageRootFile Include="$(ProjectRoot)license.txt" />
      <PackageRootFile Include="$(ProjectRoot)readme.FIRST" />
      <PackageRootFile Include="$(ProjectRoot)NOTICE.md" />
      <PackageLicenseFile Include="$(ProjectRoot)LICENSES\**\*.*" />
    </ItemGroup>

    <Copy SourceFiles="@(PackageRootFile)" DestinationFolder="$(PackageDir)" />
    <Copy SourceFiles="@(PackageLicenseFile)" DestinationFiles="@(PackageLicenseFile->'$(PackageDir)\LICENSES\%(RecursiveDir)%(Filename)%(Extension)')" />
    <Copy SourceFiles="@(PackageRootFile)" DestinationFolder="$(PluginAdminPackageDir)" />
    <Copy SourceFiles="@(PackageLicenseFile)" DestinationFiles="@(PackageLicenseFile->'$(PluginAdminPackageDir)\LICENSES\%(RecursiveDir)%(Filename)%(Extension)')" />
  </Target>

  <Target Name="CreateArchives">
    <ZipDirectory SourceDirectory="$(PackageRoot)" DestinationFile="$(ZipPath)" Overwrite="true" />
    <ZipDirectory SourceDirectory="$(PluginAdminPackageDir)" DestinationFile="$(PluginAdminZipPath)" Overwrite="true" />
  </Target>

  <Target Name="ValidateArchives">
    <ItemGroup>
      <RequiredPluginAdminZipEntry Include="MarkdownTableEditor.dll" />
      <RequiredPluginAdminZipEntry Include="license.txt" />
      <RequiredPluginAdminZipEntry Include="readme.FIRST" />
      <RequiredPluginAdminZipEntry Include="NOTICE.md" />
      <RequiredPluginAdminZipEntry Include="LICENSES/GPL-3.0-or-later.txt" />
      <RequiredPluginAdminZipEntry Include="LICENSES/LGPL-3.0-or-later.txt" />
      <RequiredPluginAdminZipEntry Include="LICENSES/Scintilla.txt" />
    </ItemGroup>
    <ValidateZipEntries ZipPath="$(PluginAdminZipPath)" Entries="@(RequiredPluginAdminZipEntry)" />
    <Message Importance="high" Text="Built $(ZipPath)" />
    <Message Importance="high" Text="Built $(PluginAdminZipPath)" />
  </Target>

  <Target Name="Package" DependsOnTargets="CleanPackage;BuildPlugin;RunPluginShortcutSmokeTests;Coverage;ValidateDllVersion;PreparePackage;CreateArchives;ValidateArchives" />
</Project>