Assert-Equivalent

First of all, thank you for this wonderful module. We use the CmdLet Assert-Equivalent very often to compare objects which saves us a lot of time.
However, recently I stumbled upon something strange with regards to file/folder quota limits. Consider this code:
Describe 'Test quota' {
    It 'Should be ok and is ok' {
        $Actual = Get-FsrmQuota -Path $UserFolder

        Assert-Equivalent -Actual $Actual -Expected $Actual
    }
}

Then this code:
Describe 'Test quota' {
    It 'Should be ok and is not ok' {
        $Expected = Get-FsrmQuota -Path $UserFolder
        $Actual = Get-FsrmQuota -Path $UserFolder

        Assert-Equivalent -Actual $Actual -Expected $Expected
    }
}

I don't think there is something wrong with your function, but the error message is so long that it becomes unreadable. In short, it says they are not equal although a Get should not change anything but apparently Assert-Equivalent does see a difference somewhere. And I can 't seem to find what it is or how to work around it.
Error message:
 [-] Should be ok and is not ok 725ms
   AssertionException: Expected and actual are not equivalent!
   Expected:
   ciminstance{
       CimClass=Root/Microsoft/Windows/FSRM:MSFT_FSRMQuota;
       CimInstanceProperties=Microsoft.Management.Infrastructure.Internal.Data.CimPropertiesCollection;
       CimSystemProperties=Microsoft.Management.Infrastructure.CimSystemProperties;
       Description=;
       Disabled=False;
       MatchesTemplate=True;
       Path=C:\Users\bob\AppData\Local\Temp\27\0bbb92b5-df43-4e34-b199-4ce3e87fead5\HOME\user;
       PeakUsage=1024;
       PSComputerName=;
       Size=10737418240;
       SoftLimit=True;
       Template=TEST HOME Quota (10GB Soft);
       Threshold=;
       Usage=1024
   }
   Actual:
   ciminstance{
       CimClass=Root/Microsoft/Windows/FSRM:MSFT_FSRMQuota;
       CimInstanceProperties=Microsoft.Management.Infrastructure.Internal.Data.CimPropertiesCollection;
       CimSystemProperties=Microsoft.Management.Infrastructure.CimSystemProperties;
       Description=;
       Disabled=False;
       MatchesTemplate=True;
       Path=C:\Users\bob\AppData\Local\Temp\27\0bbb92b5-df43-4e34-b199-4ce3e87fead5\HOME\user;
       PeakUsage=1024;
       PSComputerName=;
       Size=10737418240;
       SoftLimit=True;
       Template=TEST HOME Quota (10GB Soft);
       Threshold=;
       Usage=1024
   }
   Summary:

After Summary there are two pages of red text. But all of the above seems equal to me. When checking Compare-Object $Actual $Expected -IncludeEqual they are equal too. So maybe Assert-Equivalent picks something up on a far deeper level?

When we test the same code with Assert-Equal -Actual $Actual -Expected $Expected we get an error too. I've tried to clean it up for readability purposes:
    AssertionException: Expected ciminstance '
    ciminstance{CimClass=Root/Microsoft/Windows/FSRM:MSFT_FSRMQuota;
    CimInstanceProperties=Microsoft.Management.Infrastructure.Internal.Data.CimPropertiesCollection;
    CimSystemProperties=Microsoft.Management.Infrastructure.CimSystemProperties;
    Description=;
    Disabled=False;
    MatchesTemplate=True;
    Path=C:\Users\bob\AppData\Local\Temp\27\34eb448c-1418-4a35-bae4-89ea468c6319\HOME\user;
    PeakUsage=1024;
    PSComputerName=;
    Size=10737418240;
    SoftLimit=True;
    Template=TEST HOME Quota (10GB Soft);
    Threshold=;
    Usage=1024}'

, but got ciminstance '
    ciminstance{CimClass=Root/Microsoft/Windows/FSRM:MSFT_FSRMQuota;
    CimInstanceProperties=Microsoft.Management.Infrastructure.Internal.Data.CimPropertiesCollection;
    CimSystemProperties=Microsoft.Management.Infrastructure.CimSystemProperties;
    Description=;
    Disabled=False;
    MatchesTemplate=True;
    Path=C:\Users\bob\AppData\Local\Temp\27\34eb448c-1418-4a35-bae4-89ea468c6319\HOME\user;
    PeakUsage=1024;
    PSComputerName=;
    Size=10737418240;
    SoftLimit=True;
    Template=TEST HOME Quota (10GB Soft);
    Threshold=;
    Usage=1024}'.
          at Assert-Equal, C:\Program Files\WindowsPowerShell\Modules\Assert\0.9.1\src\General\Assert-Equal.ps1: line 15

          at <ScriptBlock>, S:\test\Brecht\Home drives quota\Set-Quota.Tests.ps1: line 106

My first thought was that the order of the object properties was not the same for both objects. But the error appears to put them in the same order and saying there not the same. So it must be something else that I'm missing...

@DarkLite1 Not sure what the problem is, maybe there is a timestamp somewhere? You could compare the properties one by one to see where the difference is.
Something like (most likely wrong :D):
$properties = $Expected.PsObject.Properties
foreach ($p in $properties) {
    try {
        Assert-Equivalent -Actual $Actual.$p -Expected $Expected.$p
    } catch {
         $p
         $_ | fl * -force | out-string
    }
}

Thank you for the tip. I've tried your suggestion below and it does not throw. All is fine when I use this.
$properties = $Expected.PsObject.Properties
foreach ($p in $properties) {
    Assert-Equivalent -Actual $Actual.$p -Expected $Expected.$p
}

When trying the original code Assert-Equivalent -Actual $Actual -Expected $Expected it's still not ok. So I've been thinking that the differences might be on a deeper level within the object. So when I tried excluding some objects it worked:
$Expected= Get-FsrmQuota -Path $UserFolder | Select-Object * -ExcludeProperty CimClass, CimInstanceProperties, CimSystemProperties
$Actual = Get-FsrmQuota -Path $UserFolder | Select-Object * -ExcludeProperty CimClass, CimInstanceProperties, CimSystemProperties
Assert-Equivalent -Actual $Actual -Expected $Expected

So it seems like Assert-Equivalent has an issue with the properties starting with cim.

It's maybe not best practice or very clever, but I ended up hard coding the test like this:
$Properties = @('Size' , 'Description', 'SoftLimit', 'Template')
foreach ($P in $Properties) {
    $Actual.$P | Should -BeExactly $Expected.$P -Because "the '$P' is not the same"
}

$ThresholdProperties = @('Percentage')
foreach ($P in $ThresholdProperties) {
    $Actual.Threshold.$P | Should -BeExactly $Expected.Threshold.$P -Because "the 'Threshold.$P' is not the same"
}

foreach ($E in $Expected.Threshold) {
    $A = $Actual.Threshold | where {$E.Percentage -eq $_.Percentage}

    $ThresholdActionProperties = @('Body', 'MailTo', 'MailCC', 'MailBCC', 'Subject',
    'ShouldLogError', 'Type', 'RunLimitInterval')

    foreach ($P in $ThresholdActionProperties) {
        $A.Action.$P | Should -BeExactly $E.Action.$P -Because "the 'Threshold.Action.$P' for percentage '$($E.Percentage)' is not the same"
    }
}

This seems to tell me exactly where the problem is and it spots the differences where I need it.

I am seeing this as well. Comparing $Actual and $Expected fails, but testing each property succeeds.
# Fails
Assert-Equivalent -Actual $Results -Expected $Expected

# Pass
Assert-Equivalent -Actual $Results.Prop1 -Expected $Expected.Prop1

Assert-Equivalent -Actual $Results.Prop2 -Expected $Expected.Prop2

Assert-Equivalent -Actual $Results.Prop3 -Expected $Expected.Prop3

Assert-Equivalent -Actual $Results.Prop4 -Expected $Expected.Prop4

Assert-Equivalent -Actual $Results.Prop5 -Expected $Expected.Prop5

Assert equivalent definitely needs a debug/tracing output that says what exactly is happening, otherwise debugging this remains a nightmare.

@DarkLite1 there is verbose-equivalence branch could you try using it to debug the issue? I don't have the cmdlet. To see the output simply provide -Verbose to Assert-Equivalent.

Thank you @nohwnd , I've installed the other branch you suggested and ran the code again in -Verbose mode. Here is the output:
Describing Test quota
VERBOSE: $Expected has type ciminstance, $Actual has type ciminstance, they are both non-null.
VERBOSE: $Expected is an object of type ciminstance, we will be comparing $Actual to objects.
VERBOSE: Comparing all (14) properties of $Expected to $Actual.
VERBOSE: Property 'Description was found on $Actual, comparing them for equivalence.
VERBOSE: (.Description) - $Expected has type string, $Actual has type string, they are both non-null.
VERBOSE: (.Description) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.Description) - Comparing values as string because $Expected has that type.
VERBOSE: (.Description) EQUIVALENCE - $Actual is equivalent to  because it is , and  coalesced to string is .
VERBOSE: EQUIVALENCE - Property 'Description is equivalent.
VERBOSE: Property 'Disabled was found on $Actual, comparing them for equivalence.
VERBOSE: (.Disabled) - $Expected has type bool, $Actual has type bool, they are both non-null.
VERBOSE: (.Disabled) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.Disabled) - Comparing values as bool because $Expected has that type.
VERBOSE: (.Disabled) EQUIVALENCE - $Actual is equivalent to $false because it is $false, and $false coalesced to bool is $false.
VERBOSE: EQUIVALENCE - Property 'Disabled is equivalent.
VERBOSE: Property 'MatchesTemplate was found on $Actual, comparing them for equivalence.
VERBOSE: (.MatchesTemplate) - $Expected has type bool, $Actual has type bool, they are both non-null.
VERBOSE: (.MatchesTemplate) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.MatchesTemplate) - Comparing values as bool because $Expected has that type.
VERBOSE: (.MatchesTemplate) EQUIVALENCE - $Actual is equivalent to $false because it is $false, and $false coalesced to bool is $false.
VERBOSE: EQUIVALENCE - Property 'MatchesTemplate is equivalent.
VERBOSE: Property 'Path was found on $Actual, comparing them for equivalence.
VERBOSE: (.Path) - $Expected has type string, $Actual has type string, they are both non-null.
VERBOSE: (.Path) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.Path) - Comparing values as string because $Expected has that type.
VERBOSE: (.Path) EQUIVALENCE - $Actual is equivalent to S:\Test\Brecht\HOME\user because it is S:\Test\Brecht\HOME\user, and S:\Test\Brecht\HOME\user coalesced to string is S:\Test\Brecht\HOME\user.
VERBOSE: EQUIVALENCE - Property 'Path is equivalent.
VERBOSE: Property 'PeakUsage was found on $Actual, comparing them for equivalence.
VERBOSE: (.PeakUsage) - $Expected has type uint64, $Actual has type uint64, they are both non-null.
VERBOSE: (.PeakUsage) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.PeakUsage) - Comparing values as uint64 because $Expected has that type.
VERBOSE: (.PeakUsage) EQUIVALENCE - $Actual is equivalent to 1024 because it is 1024, and 1024 coalesced to uint64 is 1024.
VERBOSE: EQUIVALENCE - Property 'PeakUsage is equivalent.
VERBOSE: Property 'Size was found on $Actual, comparing them for equivalence.
VERBOSE: (.Size) - $Expected has type uint64, $Actual has type uint64, they are both non-null.
VERBOSE: (.Size) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.Size) - Comparing values as uint64 because $Expected has that type.
VERBOSE: (.Size) EQUIVALENCE - $Actual is equivalent to<PHONE_NUMBER> because it is<PHONE_NUMBER>, and<PHONE_NUMBER> coalesced to uint64 is<PHONE_NUMBER>.
VERBOSE: EQUIVALENCE - Property 'Size is equivalent.
VERBOSE: Property 'SoftLimit was found on $Actual, comparing them for equivalence.
VERBOSE: (.SoftLimit) - $Expected has type bool, $Actual has type bool, they are both non-null.
VERBOSE: (.SoftLimit) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.SoftLimit) - Comparing values as bool because $Expected has that type.
VERBOSE: (.SoftLimit) EQUIVALENCE - $Actual is equivalent to $false because it is $false, and $false coalesced to bool is $false.
VERBOSE: EQUIVALENCE - Property 'SoftLimit is equivalent.
VERBOSE: Property 'Template was found on $Actual, comparing them for equivalence.
VERBOSE: (.Template) - $Expected has type string, $Actual has type string, they are both non-null.
VERBOSE: (.Template) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.Template) - Comparing values as string because $Expected has that type.
VERBOSE: (.Template) EQUIVALENCE - $Actual is equivalent to TEST HOME Quota (10GB Soft) because it is TEST HOME Quota (10GB Soft), and TEST HOME Quota (10GB Soft) coalesced to string is TEST HOME Quota (10GB Soft).
VERBOSE: EQUIVALENCE - Property 'Template is equivalent.
VERBOSE: Property 'Threshold was found on $Actual, comparing them for equivalence.
VERBOSE: (.Threshold) - $Expected is $null, so we are expecting $null.
VERBOSE: (.Threshold) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: EQUIVALENCE - Property 'Threshold is equivalent.
VERBOSE: Property 'Usage was found on $Actual, comparing them for equivalence.
VERBOSE: (.Usage) - $Expected has type uint64, $Actual has type uint64, they are both non-null.
VERBOSE: (.Usage) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.Usage) - Comparing values as uint64 because $Expected has that type.
VERBOSE: (.Usage) EQUIVALENCE - $Actual is equivalent to 1024 because it is 1024, and 1024 coalesced to uint64 is 1024.
VERBOSE: EQUIVALENCE - Property 'Usage is equivalent.
VERBOSE: Property 'PSComputerName was found on $Actual, comparing them for equivalence.
VERBOSE: (.PSComputerName) - $Expected is $null, so we are expecting $null.
VERBOSE: (.PSComputerName) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: EQUIVALENCE - Property 'PSComputerName is equivalent.
VERBOSE: Property 'CimClass was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass) - $Expected has type cimclass, $Actual has type cimclass, they are both non-null.
VERBOSE: (.CimClass) - $Expected is an object of type cimclass, we will be comparing $Actual to objects.
VERBOSE: (.CimClass) - Comparing all (7) properties of $Expected to $Actual.
VERBOSE: (.CimClass) - Property 'CimClassName was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass.CimClassName) - $Expected has type string, $Actual has type string, they are both non-null.
VERBOSE: (.CimClass.CimClassName) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.CimClass.CimClassName) - Comparing values as string because $Expected has that type.
VERBOSE: (.CimClass.CimClassName) EQUIVALENCE - $Actual is equivalent to MSFT_FSRMQuota because it is MSFT_FSRMQuota, and MSFT_FSRMQuota coalesced to string is MSFT_FSRMQuota.
VERBOSE: (.CimClass) EQUIVALENCE - Property 'CimClassName is equivalent.
VERBOSE: (.CimClass) - Property 'CimSuperClassName was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass.CimSuperClassName) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimSuperClassName) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass) EQUIVALENCE - Property 'CimSuperClassName is equivalent.
VERBOSE: (.CimClass) - Property 'CimSuperClass was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass.CimSuperClass) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimSuperClass) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass) EQUIVALENCE - Property 'CimSuperClass is equivalent.
VERBOSE: (.CimClass) - Property 'CimClassProperties was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass.CimClassProperties) - $Expected has type Microsoft.Management.Infrastructure.Internal.Data.CimClassPropertiesCollection, Microsoft.Management.Infrastructure, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=31bf3856ad364e35, $Actual has type Microsoft.Management.Infrastructure.Internal.Data.CimClassPropertiesCollection, Microsoft.Management.Infrastructure, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=31bf3856ad364e35, they are both non-null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is a collection, we will be comparing $Actual to collections.
VERBOSE: (.CimClass.CimClassProperties) - Comparing items in collection, $Expected has lenght 10, $Actual has length 10.
VERBOSE: (.CimClass.CimClassProperties) -
Searching for $Expected[0]:
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassProperties) -
Searching for $Expected[1]:
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) DIFFERENCE - $Actual does not contain $Expected[1].
VERBOSE: (.CimClass.CimClassProperties) -
Searching for $Expected[2]:
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) DIFFERENCE - $Actual does not contain $Expected[2].
VERBOSE: (.CimClass.CimClassProperties) -
Searching for $Expected[3]:
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) DIFFERENCE - $Actual does not contain $Expected[3].
VERBOSE: (.CimClass.CimClassProperties) -
Searching for $Expected[4]:
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) DIFFERENCE - $Actual does not contain $Expected[4].
VERBOSE: (.CimClass.CimClassProperties) -
Searching for $Expected[5]:
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) DIFFERENCE - $Actual does not contain $Expected[5].
VERBOSE: (.CimClass.CimClassProperties) -
Searching for $Expected[6]:
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) DIFFERENCE - $Actual does not contain $Expected[6].
VERBOSE: (.CimClass.CimClassProperties) -
Searching for $Expected[7]:
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) DIFFERENCE - $Actual does not contain $Expected[7].
VERBOSE: (.CimClass.CimClassProperties) -
Searching for $Expected[8]:
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) DIFFERENCE - $Actual does not contain $Expected[8].
VERBOSE: (.CimClass.CimClassProperties) -
Searching for $Expected[9]:
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassProperties) DIFFERENCE - $Actual does not contain $Expected[9].
VERBOSE: (.CimClass.CimClassProperties) DIFFERENCE - $Actual and $Expected arrays are not equivalent.
VERBOSE: (.CimClass) DIFFERENCE - Property 'CimClassProperties is not equivalent.
VERBOSE: (.CimClass) - Property 'CimClassQualifiers was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass.CimClassQualifiers) - $Expected has type Microsoft.Management.Infrastructure.Internal.Data.CimClassQualifierCollection, Microsoft.Management.Infrastructure, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=31bf3856ad364e35, $Actual has type Microsoft.Management.Infrastructure.Internal.Data.CimClassQualifierCollection, Microsoft.Management.Infrastructure, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=31bf3856ad364e35, they are both non-null.
VERBOSE: (.CimClass.CimClassQualifiers) - $Expected is a collection, we will be comparing $Actual to collections.
VERBOSE: (.CimClass.CimClassQualifiers) - Comparing items in collection, $Expected has lenght 2, $Actual has length 2.
VERBOSE: (.CimClass.CimClassQualifiers) -
Searching for $Expected[0]:
VERBOSE: (.CimClass.CimClassQualifiers) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassQualifiers) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassQualifiers) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassQualifiers) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassQualifiers) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassQualifiers) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassQualifiers) -
Searching for $Expected[1]:
VERBOSE: (.CimClass.CimClassQualifiers) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassQualifiers) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassQualifiers) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassQualifiers) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassQualifiers) DIFFERENCE - $Actual does not contain $Expected[1].
VERBOSE: (.CimClass.CimClassQualifiers) EQUIVALENCE - $Actual and $Expected arrays are equivalent.
VERBOSE: (.CimClass) EQUIVALENCE - Property 'CimClassQualifiers is equivalent.
VERBOSE: (.CimClass) - Property 'CimClassMethods was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass.CimClassMethods) - $Expected has type Microsoft.Management.Infrastructure.Internal.Data.CimMethodDeclarationCollection, Microsoft.Management.Infrastructure, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=31bf3856ad364e35, $Actual has type Microsoft.Management.Infrastructure.Internal.Data.CimMethodDeclarationCollection, Microsoft.Management.Infrastructure, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=31bf3856ad364e35, they are both non-null.
VERBOSE: (.CimClass.CimClassMethods) - $Expected is a collection, we will be comparing $Actual to collections.
VERBOSE: (.CimClass.CimClassMethods) - Comparing items in collection, $Expected has lenght 2, $Actual has length 2.
VERBOSE: (.CimClass.CimClassMethods) -
Searching for $Expected[0]:
VERBOSE: (.CimClass.CimClassMethods) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassMethods) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassMethods) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassMethods) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassMethods) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassMethods) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimClass.CimClassMethods) -
Searching for $Expected[1]:
VERBOSE: (.CimClass.CimClassMethods) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassMethods) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassMethods) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimClassMethods) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimClassMethods) DIFFERENCE - $Actual does not contain $Expected[1].
VERBOSE: (.CimClass.CimClassMethods) EQUIVALENCE - $Actual and $Expected arrays are equivalent.
VERBOSE: (.CimClass) EQUIVALENCE - Property 'CimClassMethods is equivalent.
VERBOSE: (.CimClass) - Property 'CimSystemProperties was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass.CimSystemProperties) - $Expected has type Microsoft.Management.Infrastructure.CimSystemProperties, $Actual has type Microsoft.Management.Infrastructure.CimSystemProperties, they are both non-null.
VERBOSE: (.CimClass.CimSystemProperties) - $Expected is an object of type Microsoft.Management.Infrastructure.CimSystemProperties, we will be comparing $Actual to objects.
VERBOSE: (.CimClass.CimSystemProperties) - Comparing all (4) properties of $Expected to $Actual.
VERBOSE: (.CimClass.CimSystemProperties) - Property 'Namespace was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass.CimSystemProperties.Namespace) - $Expected has type string, $Actual has type string, they are both non-null.
VERBOSE: (.CimClass.CimSystemProperties.Namespace) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.CimClass.CimSystemProperties.Namespace) - Comparing values as string because $Expected has that type.
VERBOSE: (.CimClass.CimSystemProperties.Namespace) EQUIVALENCE - $Actual is equivalent to Root/Microsoft/Windows/FSRM because it is Root/Microsoft/Windows/FSRM, and Root/Microsoft/Windows/FSRM coalesced to string is Root/Microsoft/Windows/FSRM.
VERBOSE: (.CimClass.CimSystemProperties) EQUIVALENCE - Property 'Namespace is equivalent.
VERBOSE: (.CimClass.CimSystemProperties) - Property 'ServerName was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass.CimSystemProperties.ServerName) - $Expected has type string, $Actual has type string, they are both non-null.
VERBOSE: (.CimClass.CimSystemProperties.ServerName) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.CimClass.CimSystemProperties.ServerName) - Comparing values as string because $Expected has that type.
VERBOSE: (.CimClass.CimSystemProperties.ServerName) EQUIVALENCE - $Actual is equivalent to DEUSGFRANIT03 because it is DEUSGFRANIT03, and DEUSGFRANIT03 coalesced to string is DEUSGFRANIT03.
VERBOSE: (.CimClass.CimSystemProperties) EQUIVALENCE - Property 'ServerName is equivalent.
VERBOSE: (.CimClass.CimSystemProperties) - Property 'ClassName was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass.CimSystemProperties.ClassName) - $Expected has type string, $Actual has type string, they are both non-null.
VERBOSE: (.CimClass.CimSystemProperties.ClassName) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.CimClass.CimSystemProperties.ClassName) - Comparing values as string because $Expected has that type.
VERBOSE: (.CimClass.CimSystemProperties.ClassName) EQUIVALENCE - $Actual is equivalent to MSFT_FSRMQuota because it is MSFT_FSRMQuota, and MSFT_FSRMQuota coalesced to string is MSFT_FSRMQuota.
VERBOSE: (.CimClass.CimSystemProperties) EQUIVALENCE - Property 'ClassName is equivalent.
VERBOSE: (.CimClass.CimSystemProperties) - Property 'Path was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimClass.CimSystemProperties.Path) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimClass.CimSystemProperties.Path) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimClass.CimSystemProperties) EQUIVALENCE - Property 'Path is equivalent.
VERBOSE: (.CimClass.CimSystemProperties) EQUIVALENCE - $Actual has no extra properties that $Expected does not have.
VERBOSE: (.CimClass) EQUIVALENCE - Property 'CimSystemProperties is equivalent.
VERBOSE: (.CimClass) EQUIVALENCE - $Actual has no extra properties that $Expected does not have.
VERBOSE: DIFFERENCE - Property 'CimClass is not equivalent.
VERBOSE: Property 'CimInstanceProperties was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimInstanceProperties) - $Expected has type Microsoft.Management.Infrastructure.Internal.Data.CimPropertiesCollection, Microsoft.Management.Infrastructure, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=31bf3856ad364e35, $Actual has type Microsoft.Management.Infrastructure.Internal.Data.CimPropertiesCollection, Microsoft.Management.Infrastructure, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=31bf3856ad364e35, they are both non-null.
VERBOSE: (.CimInstanceProperties) - $Expected is a collection, we will be comparing $Actual to collections.
VERBOSE: (.CimInstanceProperties) - Comparing items in collection, $Expected has lenght 10, $Actual has length 10.
VERBOSE: (.CimInstanceProperties) -
Searching for $Expected[0]:
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimInstanceProperties) -
Searching for $Expected[1]:
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) DIFFERENCE - $Actual does not contain $Expected[1].
VERBOSE: (.CimInstanceProperties) -
Searching for $Expected[2]:
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) DIFFERENCE - $Actual does not contain $Expected[2].
VERBOSE: (.CimInstanceProperties) -
Searching for $Expected[3]:
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) DIFFERENCE - $Actual does not contain $Expected[3].
VERBOSE: (.CimInstanceProperties) -
Searching for $Expected[4]:
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) DIFFERENCE - $Actual does not contain $Expected[4].
VERBOSE: (.CimInstanceProperties) -
Searching for $Expected[5]:
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) DIFFERENCE - $Actual does not contain $Expected[5].
VERBOSE: (.CimInstanceProperties) -
Searching for $Expected[6]:
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) DIFFERENCE - $Actual does not contain $Expected[6].
VERBOSE: (.CimInstanceProperties) -
Searching for $Expected[7]:
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) DIFFERENCE - $Actual does not contain $Expected[7].
VERBOSE: (.CimInstanceProperties) -
Searching for $Expected[8]:
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) DIFFERENCE - $Actual does not contain $Expected[8].
VERBOSE: (.CimInstanceProperties) -
Searching for $Expected[9]:
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimInstanceProperties) DIFFERENCE - $Actual does not contain $Expected[9].
VERBOSE: (.CimInstanceProperties) DIFFERENCE - $Actual and $Expected arrays are not equivalent.
VERBOSE: DIFFERENCE - Property 'CimInstanceProperties is not equivalent.
VERBOSE: Property 'CimSystemProperties was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimSystemProperties) - $Expected has type Microsoft.Management.Infrastructure.CimSystemProperties, $Actual has type Microsoft.Management.Infrastructure.CimSystemProperties, they are both non-null.
VERBOSE: (.CimSystemProperties) - $Expected is an object of type Microsoft.Management.Infrastructure.CimSystemProperties, we will be comparing $Actual to objects.
VERBOSE: (.CimSystemProperties) - Comparing all (4) properties of $Expected to $Actual.
VERBOSE: (.CimSystemProperties) - Property 'Namespace was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimSystemProperties.Namespace) - $Expected has type string, $Actual has type string, they are both non-null.
VERBOSE: (.CimSystemProperties.Namespace) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.CimSystemProperties.Namespace) - Comparing values as string because $Expected has that type.
VERBOSE: (.CimSystemProperties.Namespace) EQUIVALENCE - $Actual is equivalent to Root/Microsoft/Windows/FSRM because it is Root/Microsoft/Windows/FSRM, and Root/Microsoft/Windows/FSRM coalesced to string is Root/Microsoft/Windows/FSRM.
VERBOSE: (.CimSystemProperties) EQUIVALENCE - Property 'Namespace is equivalent.
VERBOSE: (.CimSystemProperties) - Property 'ServerName was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimSystemProperties.ServerName) - $Expected has type string, $Actual has type string, they are both non-null.
VERBOSE: (.CimSystemProperties.ServerName) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.CimSystemProperties.ServerName) - Comparing values as string because $Expected has that type.
VERBOSE: (.CimSystemProperties.ServerName) EQUIVALENCE - $Actual is equivalent to DEUSGFRANIT03 because it is DEUSGFRANIT03, and DEUSGFRANIT03 coalesced to string is DEUSGFRANIT03.
VERBOSE: (.CimSystemProperties) EQUIVALENCE - Property 'ServerName is equivalent.
VERBOSE: (.CimSystemProperties) - Property 'ClassName was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimSystemProperties.ClassName) - $Expected has type string, $Actual has type string, they are both non-null.
VERBOSE: (.CimSystemProperties.ClassName) - $Expected is a value (value type, string, single value array, or a scriptblock), we will be comparing $Actual to value types.
VERBOSE: (.CimSystemProperties.ClassName) - Comparing values as string because $Expected has that type.
VERBOSE: (.CimSystemProperties.ClassName) EQUIVALENCE - $Actual is equivalent to MSFT_FSRMQuota because it is MSFT_FSRMQuota, and MSFT_FSRMQuota coalesced to string is MSFT_FSRMQuota.
VERBOSE: (.CimSystemProperties) EQUIVALENCE - Property 'ClassName is equivalent.
VERBOSE: (.CimSystemProperties) - Property 'Path was found on $Actual, comparing them for equivalence.
VERBOSE: (.CimSystemProperties.Path) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimSystemProperties.Path) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
VERBOSE: (.CimSystemProperties) EQUIVALENCE - Property 'Path is equivalent.
VERBOSE: (.CimSystemProperties) EQUIVALENCE - $Actual has no extra properties that $Expected does not have.
VERBOSE: EQUIVALENCE - Property 'CimSystemProperties is equivalent.
VERBOSE: EQUIVALENCE - $Actual has no extra properties that $Expected does not have.
  [-] Should be ok and is not ok 1.84s
    AssertionException: Expected and actual are not equivalent!

     Maybe you have a better eye for this.

@DarkLite1 VERBOSE: (.CimClass.CimClassQualifiers) DIFFERENCE - $Actual does not contain $Expected[1]. that message is a bit misleading. We are searching in a collection and the thing at the start in () is the path inside of the object. So it actually means $Actual.CimClass.CimClassQualifiers collection does not contain the item $Expected.CimClass.CimClassQualifiers[1]. To me it looks like the collection searching code is broken in some way. Looking at this code:
VERBOSE: (.CimInstanceProperties) - $Expected has type Microsoft.Management.Infrastructure.Internal.Data.CimPropertiesCollection, Microsoft.Management.Infrastructure, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=31bf3856ad364e35, $Actual has type Microsoft.Management.Infrastructure.Internal.Data.CimPropertiesCollection, Microsoft.Management.Infrastructure, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=31bf3856ad364e35, they are both non-null.

VERBOSE: (.CimInstanceProperties) - $Expected is a collection, we will be comparing $Actual to collections.
VERBOSE: (.CimInstanceProperties) - Comparing items in collection, $Expected has lenght 10, $Actual has length 10.

# both collections have 10 items, so we take each item from the collection on the expected
# object and try to find it in the collection on actual
VERBOSE: (.CimInstanceProperties) -
Searching for $Expected[0]:
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.
# the object is found and this repeats 10 times in the output
# result of the search is equivalence - this is correct because we found an equivalent object in the actual collection
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - Found $Expected[0].
VERBOSE: (.CimInstanceProperties) -

Searching for $Expected[1]:
# we search the collection again for item on index 1 in the expected collection,
VERBOSE: (.CimInstanceProperties) - $Expected is $null, so we are expecting $null.
VERBOSE: (.CimInstanceProperties) EQUIVALENCE - $Actual is equivalent to $null, because it is $null.

# the lines above do not indicate any difference, yet the result is not equivalence
VERBOSE: (.CimInstanceProperties) DIFFERENCE - $Actual does not contain $Expected[1].
VERBOSE: (.CimInstanceProperties) -

Looking at the output I'd say there is error in the way collections are compared. All the items in the collection evaluate to $null, (might be fine if the collection is actually a collection of 10 $null objects), but we don't stop after finding the first item (that seems like the first error), and I think internally I am keeping note of what I already found, so maybe there are no items left for subsequent matches. Or something like that. Need to find a simpler repro for this problem.

# works
Assert-Equivalent -Actual @($null,$null) -Expected @($null,$null) -Verbose
# throws 🙀
Assert-Equivalent -Actual @($null,$null,$null) -Expected @($null,$null,$null) -Verbose

Indeed, the FSRM module is a bit annoying to test with if you don't have it. It took me a while to set it up again too.
@gerane do you have an example of code where it went wrong for you? It might be easier to test with than the FSRM module.

@DarkLite1 see above. :)

@DarkLite1 @gerane Okay two bugs were there

When comparing collections we go through each item in Expected and compare it for equivalence with every item in Actual. When the item is found, we take note of the index in actual so we dont compare them further. This way we are able to compare a: (1,1,2) to e:(1,1,2) as equivalent, but a: (1,1,2), e:(1,2,2) as not equivalent. Without taking the already matched items out of consideration we would be linking one item from expected to multiple items in actual, or vice versa. - but in the loop where this was happening it did not return right after a match was found, so every item in the collection was marked as taken, and none were left for the next iteration. Making the assertion report non-equivalence even though the collections are equivalent. To solve this I simply break out of the loop as soon as I find an item.

Now you might ask why ($null, $null) did not fail then? There was another bug. When deciding whether or not the collections are equivalent I we look at the collection of items that were not found, but in case we did not find a single null, we cast @($null) to bool which is false, so it seems that all items were found (0 items were not found), which is not true. so instead of depending on the rules of coalescing to bool I am taking note that there is some difference when the branch of logic is reached, which results in ($null, $null) failng "correctly" when the above bug is present.

@DarkLite1 The error was not limited to your instance of cim class, I could simulate the same problem with Assert-Equivalent @(Get-CimClass Win32_ComputerSystem) @(Get-CimClass Win32_ComputerSystem) -Verbose which reported error before, but now correctly considers the objects equivalent.


Continuous a11y integration

As a site engineer, in order to ensure the quality and accessibility of our code, I would like an automated accessibility tool to test all our of code.
Acceptance criteria:

[ ] axe-core-rspec is implemented for Challenge_platform repo and runs with the other CI tests

@TCKapGrp I moved this back to doing based on @kkrug's feedback about Axe being acceptable for use in GSA.


Not clear if Go 1.6.2 or Go 1.7 is required

Since https://github.com/influxdata/influxdb/commit/3774d5e7340517b4feb7c379df2f457e49c562a7 (update latest dependencies with Godeps) Go 1.7 is now required to build, which does not match the recommendations in https://github.com/influxdata/influxdb/blob/master/CONTRIBUTING.md.
If Go 1.6.2 is supported please partially revert the above commit.

Use the following Godeps: collectd.org 3f276a01c9ef9dba3e8013d3252a6243a7240473. This is not the previously used commit but the latest released commit supporting Go 1.6.
Do not import context in services/collectd/test_client/client.go.

Otherwise please update CONTRIBUTING.md.

Should be 1.7.3.  Looks like the docs are out of date after merging #7522


Ct unstable

:tada: This PR is included in version 1.13.4 :tada:
The release is available on npm package (@latest dist-tag)
Your semantic-release bot :package::rocket:


Backport 2.7: Reject properly authenticated but improperly padded records in CBC with EtM

This is the backport to Mbed TLS 2.7 of #2111.

retest


Add option to set Git tag and repository URL to all (or some) External_*.cmake

Currently  only External_Gadgetron.cmake, External_NIFTYREG.cmake (in PR https://github.com/CCPPETMR/SIRF-SuperBuild/pull/335), External_SIRF.cmake and External_STIR.cmake have this option.
Should we add SetGitTagAndRepo("${proj}") to the rest? Not sure if it makes sense for Armadillo or boost, but perhaps NIFTYPET or SPM or CCPi_* could use this variable?

Let's do this on a need basis. It would in any case make more sense to use one more macro that call the 3 other macros etc. Even less lines to write.


[BEAM-7389] Add code snippet for Distinct

Adding the code snippets for Distinct.
R: @aaltay

Thank you for your contribution! Follow this checklist to help us incorporate your contribution quickly and easily:

[x] Choose reviewer(s) and mention them in a comment (R: @username).
[x] Format the pull request title like [BEAM-XXX] Fixes bug in ApproximateQuantiles, where you replace BEAM-XXX with the appropriate JIRA issue, if applicable. This will automatically link the pull request to the issue.
[x] If this contribution is large, please file an Apache Individual Contributor License Agreement.

See the Contributor Guide for more tips on how to make review process smoother.

SUCCESS
--none--

Run Python2_PVR_Flink PreCommit

Run Python PreCommit

Run Python PreCommit


Clarify Route Nesting example in the guide

In https://github.com/QubitProducts/cherrytree/blob/master/docs/intro.md#route-nesting describes that the routes inbox and mail does not have URL matches for it. But since there's no abstract option passed to then, technically they should be navigated to with e.g. /inbox and /inbox/m/:mailId
Also, i could not find the explanation of usage of  route name with a dot (mail.raw).

Good catch!
I've now fixed the table in the guide and added explanation about the dotted route names here https://github.com/QubitProducts/cherrytree/blob/master/docs/api.md#default-path.
TBH, the dotted route names are too obscure and I might remove those in the next major version.


vue style not found

Describe the bug
vite build Production environment package style file missing

Reproduction
https://github.com/leafront/my-vue-app

System Info
Output of npx envinfo --system --npmPackages vite,@vitejs/plugin-vue --binaries --browsers:
  System:
    OS: windows 10
    CPU: (12) x64 Intel(R) Core(TM) i7-10700 CPU @ 2.90GHz
    Memory: 12 GB / 32.00 GB
    Shell: 5.8 - /bin/zsh
  Binaries:
    Node: 14.16.1 - D:\Program Files\nodejs\
    npm: 6.14.12 - ~D:\Program Files\nodejs\npm
  Browsers:
    Chrome: 89.0.4389.114

Used package manager:
Logs

╰─➤  sudo npm run build                                                     1 ↵
Password:

><EMAIL_ADDRESS>build /Users/leaf/my-vue-app
> vite build

vite v2.2.1 building for production...
✓ 17 modules transformed.
dist/index.html                       0.71kb
dist/assets/Footer.9ea5d8f6.js        0.14kb / brotli: 0.11kb
dist/assets/HelloWorld.5224c65b.js    0.28kb / brotli: 0.18kb
dist/assets/HelloWorld.7ca16950.css   0.02kb / brotli: 0.02kb
dist/assets/Test.cda07b1d.js          0.27kb / brotli: 0.17kb
dist/assets/Footer.9751d05f.css       0.04kb / brotli: 0.03kb
dist/assets/index.974cc591.js         1.85kb / brotli: 0.82kb
dist/assets/vendor.7f384ad1.js        64.02kb / brotli: 22.47kb

Before submitting the issue, please make sure you do the following

[ ] Read the Contributing Guidelines.
[ ] Read the docs.
[ ] Check that there isn't already an issue that reports the same bug to avoid creating a duplicate.
[ ] Provide a description in this issue that describes the bug.
[ ] Make sure this is a Vite issue and not a framework-specific issue. For example, if it's a Vue SFC related bug, it should likely be reported to https://github.com/vuejs/vue-next instead.
[ ] Check that this is a concrete bug. For Q&A open a GitHub Discussion or join our Discord Chat Server.

component: () =><EMAIL_ADDRESS>  Change
import  Hello from<EMAIL_ADDRESS>componets: Hello

@leafront would you create a minimal reproduction of this issue in github to share here?

Code: https://gitlab.haoyishu.org/hysfront/hys-h5-home/tree/vite
Account: yeliang
Password: yl940110
At 2021-04-23 17:55:30, "github-actions[bot]" @.***> wrote:
Hello @leafront. Please provide a online reproduction by codesandbox or a minimal GitHub repository. Issues labeled by need reproduction will be closed if no activities in 3 days.
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub, or unsubscribe.

https://github.com/leafront/my-vue-app

I think this is the same problem I'm having, the css dependency is included in the first dynamic import() that depends on that component, but not in others

Do you have a solution?

You can lock the vite version to 2.1.5 to solve this problem, I tested my local environment and found that this error occurs when the vite version >= 2.2.0

What I'm talking about is that there's a problem with the packaged code

What I'm talking about is that there's a problem with the packaged code

我知道你遇到的打包的问题，我给出的目前可行之策是将你的vite版本降到2.1.5再打包，我本地用2.2.0+以上的版本打包后，css样式并没有被js脚本所引用。

Resolved by #3144

@daiwanxing @leafront @LepkoQQ the fix was released in Vite v2.2.3, you should be able to update to it in your projects

@daiwanxing @leafront @LepkoQQ the fix was released in Vite v2.2.3, you should be able to update to it in your projects

Thanks!


Additional Maintainers

After a year pipx has grown into a pretty successful open source project -- over 100k downloads, mentioned on episode 118 of Talk Python, active contributors, issue creations, almost 1000 github stars, a page on packaging.python.org, and no signs of slowing down! All thanks to @sahensley starting a conversation in the pipsi issue tracker with the same title as this issue :smile:, and to the many contributors besides me who have shaped pipx into what it is today.
I have started a few open source projects, but never given up the reigns and granted commit rights to anyone else. I would like to do that now for pipx. It has wide adoption and fairly robust CI tests, so there is a good starting place for everyone to work from.
Maintainers would

triage issues (add labels to them, or fix urgent things immediately)
review pull requests
merge code into master
decide which features go into pipx and how to implement them
be listed on the pipx readme as maintainers

I will still be the sole publisher to PyPI for now, with the plan to let maintainers publish eventually.
@itsayellow, @clbarnes, @jayvdb, @joshuarli, @sahensley, @aiguofer would you be interested in becoming maintainers?

I don't have a lot of spare time at all right now to donate, but would be interested in the future if things clear up. Thanks for asking though!

@joshuarli no problem, don't spread yourself too thin

some pip packages can do really crazy stuff.

indeed :sweat_smile:

I'm honored to be asked and would love to help!

It is amazing what you (and all the contributors) accomplished in a year!
While I don't have a huge amount of time, I could certainly commit a few hours a week.  I'd mainly focus on verifying, labeling and researching issues.

I'd love to be involved - pipx solves a serious problem in the large ecosystem of system tools written in python, and it's a great codebase. However, I'm about to start a new job while still working on a PhD thesis so I can't really predict my time allowance right now.

Hey! I'd love to help since I do use this every day (and my dotfile config depends heavily on it), although I'm not sure how much time I can commit to it. I guess with a few other maintainers we should hopefully be able to keep up with issues and PRs though :)

I'm maintaining both virtualenv and tox, I probably would not be available for development, but more than happy to champion with maintenance (release, reviews, ci), integration with the python packaging ecosystem. This is a truly awesome project.

It is amazing what you (and all the contributors) accomplished in a year!
While I don't have a huge amount of time, I could certainly commit a few hours a week. I'd mainly focus on verifying, labeling and researching issues.

For sure this project would not be where it is if it weren't for contributors. Everyone has been super helpful and friendly, and it's been a very positive experience for me and hopefully everyone else involved.
If you are up to it, help on issue organization would be great. I think the time of a few people combined will add up and be effective in managing the project. But if you don't have the time don't feel obligated.

I'd love to be involved - pipx solves a serious problem in the large ecosystem of system tools written in python, and it's a great codebase. However, I'm about to start a new job while still working on a PhD thesis so I can't really predict my time allowance right now.

Sounds good! Congrats btw.

I'm maintaining both virtualenv and tox, I probably would not be available for development, but more than happy to champion with maintenance (release, reviews, ci), integration with the python packaging ecosystem. This is a truly awesome project.

Wow, thanks so much! I think I'll take you up on that. And thanks for all your work on virtualenv and tox!

I think we've added the new maintainers, so can probably close this Issue. 😄


Faster Biot Savart

This PR makes two main changes:

Compile with -march=native when compiled locally. Compile with -march=ivybridge  when compiled on the CI for our wheels. Ivy Bridge supports avx but is old enough that we can probably rely on this wheel working everywhere.

If compiled with AVX512F instructions available, then we use a Fast Inverse Square root trick to speed up the computation of 1/||diff||, since both inverses and square roots are pretty slow on current AVX512 hardware.

Here are some benchmarks on a modern Xeon Platinum CPU. Depending on problem size and number of derivatives, we get a 2x-3x speedup.
# march=x86-64 (old default)

Number of derivatives: 0
         N Time (in ms) Gigainteractions/s
     10000      0.03184            0.31407
   1000000        3.131            0.31939
 100000000        313.5            0.31898
Number of derivatives: 1
         N Time (in ms) Gigainteractions/s
     10000      0.12139           0.082379
   1000000       11.921           0.083886
 100000000         1192           0.083893
Number of derivatives: 2
         N Time (in ms) Gigainteractions/s
     10000      0.24222           0.041285
   1000000        23.71           0.042176
 100000000       2355.3           0.042457

# march=ivybridge (new default on CI)

Number of derivatives: 0
         N Time (in ms) Gigainteractions/s
     10000      0.02043            0.48948
   1000000        2.012            0.49702
 100000000        200.8            0.49801
Number of derivatives: 1
         N Time (in ms) Gigainteractions/s
     10000      0.07475            0.13378
   1000000        7.193            0.13902
 100000000        720.3            0.13883
Number of derivatives: 2
         N Time (in ms) Gigainteractions/s
     10000       0.1397           0.071582
   1000000       13.532           0.073899
 100000000       1345.7           0.074311

# march=native (new default for local installation)
 Number of derivatives: 0
         N Time (in ms) Gigainteractions/s
     10000      0.02685            0.37244
   1000000        1.943            0.51467
 100000000        191.5            0.52219
Number of derivatives: 1
         N Time (in ms) Gigainteractions/s
     10000      0.06174            0.16197
   1000000        3.645            0.27435
 100000000        362.9            0.27556
Number of derivatives: 2
         N Time (in ms) Gigainteractions/s
     10000      0.22623           0.044203
   1000000       10.436           0.095822
 100000000         1029           0.097182

# march=native + fast inverse square root avx512
 Number of derivatives: 0
         N Time (in ms) Gigainteractions/s
     10000      0.02157            0.46361
   1000000         1.38            0.72464
 100000000        138.7            0.72098
Number of derivatives: 1
         N Time (in ms) Gigainteractions/s
     10000      0.05904            0.16938
   1000000        3.424            0.29206
 100000000        340.3            0.29386
Number of derivatives: 2
         N Time (in ms) Gigainteractions/s
     10000      0.21749           0.045979
   1000000        9.531            0.10492
 100000000        972.7            0.10281

I also took this opportunity to clean up the biot savart code a bit to separate the version that uses xtensor-python from the one that just relies on xtensor.

Number of derivatives: 0
         N Time (in ms) Gigainteractions/s
     10000       0.0107            0.93458
   1000000         0.99             1.0101
 100000000           98             1.0204
Number of derivatives: 1
         N Time (in ms) Gigainteractions/s
     10000       0.0305            0.32787
   1000000         2.78            0.35971
 100000000          280            0.35714
Number of derivatives: 2
         N Time (in ms) Gigainteractions/s
     10000       0.0949            0.10537
   1000000         8.65            0.11561
 100000000          852            0.11737

I think this is now ready to merged.

@florianwechsung Thanks for working on this PR. I agree with your changes to build system that goes for march=native optimization for local builds.
Regarding march flag for CI, I am also bringing Matt (@landreman) into this discussion.
The reason I choose march=x86-64 is to have a base optimization that works on all processors. However, this flag is very baseline in the sense it supports all the processors from early 2000's when AMD introduced 64 bit extensions for x86 architecture. Since we don't have to support such old processors, I thought we could do better, but was not able to figure out if choosing a specific platform such as march=ivybridge would also support the latest AMD processors.  The gcc docs are not clear on that. This point would have been moot and we could have used march=ivybridge if AMD didn't have competitive processors. But now AMD is leading and the new PPPL cluster is using AMD processors.  So it didn't make sense to choose any manufacturer specific flag. I also checked some other codes that supply pre-built binaries and the selected default is x86-64.
After googling about this a little bit, I found this phoronix page. The author is a well known guy in the  hardware and software optimization space (owner of the website). According to the info on the page, newer versions of gcc (v11+) and clang (v12+) now support different versions of x86-64 optimization flags which work for a broad set of processors from both intel and amd. So we could specify march=x86-64 or x86-64-{v2, v3, v4}. x86-64-v4 features are supported only by intel processors as of now, but all AMD Zen+ processors support x86-64-v3.
So my recommendation would be to use the gcc/clang compilers to v11+/v12+ in conjuction with march=x86-64-v3.

I believe march=ivybridge (which has AVX but not AVX2) lies somewhere between x86-64-v2 (no AVX) and x86-64-v3 (AVX, AVX2, and FMA).
Having AVX, AVX2 and FMA makes the code significantly faster, so I would be happy to assume x86-64-v3 as default.


[Feature Request] Set a default PGP key, other than the most recent

Just a quick request - is there any chance we could gain the ability to set a default PGP key, other than 'the most recent'?
At the moment to get this behaviour I have to:
keybase pgp export -s -q $KEYID | gpg --import
keybase pgp drop $KEYID
gpg --export-secret-key -a "$KEY_NAME" | keybase pgp import --push-secret
gpg --delete-secret-keys -a "$KEY_NAME"

Which amongst other things signs a statement that a key shouldn't be associated with my account and then re-associates it. Which is /hopefully/ acceptable, given Keybase's model, but is still somewhat sketchy. 👀

You mean, as far as the website is concerned at key.asc?

Well for example in the output of `keybase pgp sign -h:
-k, --key            Specify a key to use for signing (otherwise most recent PGP key is used).
Similarly for all the other keybase pgp commands.

Oh, that's what you meant.  I see...

This is a nice idea, I'll make a story for it in our internal tracker.

IMO, this is quite needed for users of hardware keys, such as the YubiKey. So this gets an overwhelming :+1: from me.

Hah, lo and behold it's my recent push to make better use of my Yubikeys that led me to this issue. Unless some action has been taken on this, though, I don't think I can countenance the added workflow burden inherent with having to regularly tell keybase to use my older key for signatures and encryption.
@maxtaco, I'm sorry to ping you when I know you're already so busy, but can you speak to where this sits on your internal tracker/roadmap, if indeed it was added and remains there?


Chronicler's Gambit is called Chronicler's Prfn. in the book, and its description overflows slightly at the bottom

The actual Chronicler's Purification title also overflows a bit. Maybe the wrong one got changed?
And just as a related side note, Chronicler's Gambit's arguments seem to break convention, no? Compare to the casting item patterns and Akasha's Gambit, where the target entity/location is first in the list. Actually the arguments are just the wrong way around in the book.
Version: 0.10.0

"get 0.10.0 out quick" i said "it will be fun" i said "move fast and break things" i said


Switch from svdtools to XSLT

Switch the SVD modifications from being made through svdtools' svd patch to using XSLT. Since SVD files are already XML files, XSLT is
well-suited to modifying them.
This change also includes fixes for the ATSAMD11C14A device which are
not currently possible with svdtools.
See #195.

(This is the only time I've ever been happy to see xsltproc in use :-p)

(This is the only time I've ever been happy to see xsltproc in use :-p)

I definitely had a bit of trepidation as I wrote this change. I know some people are outright allergic to xsltproc. 😛

I will admit I am somewhat hesitant to diverge too far from svdtools because it's what the rest of the ecosystem is using, but if it's the only way we can get this to work and consensus is fine with it, I won't stop this PR from going through.

I will admit I am somewhat hesitant to diverge too far from svdtools because it's what the rest of the ecosystem is using, but if it's the only way we can get this to work and consensus is fine with it, I won't stop this PR from going through.

To be fair, it's not the only way to make this work. It's not even the only way to make this work without svdtools, you could just use patch to add corrections to the SVDs. However, making this work with svdtools is a losing game, in my opinion. Each new SVD I see is a new way that a vendor has managed to generate a weird broken SVD. svdtools (and svd-parser) are both designed to handle more-or-less well-formed SVDs. Using XSLT has the advantage that the only thing an SVD author needed to get right was that the SVD has to parse as XML. Everything else we can fix with XSLT. Other changes will inevitably require changes to svdtools to be able to reach into specific nodes, or even bigger changes if it needs to modify things like registers inside clusters inside devices (like ATSAMD11C14A).
The cons are, as you say, that there has been ecosystem adoption for svdtools. However, I do think the flexibility of having a tool now that can do every SVD modification we could need is a very strong pro.

Makes sense. I'd like to get a bit more feedback from community members before merging. Particularly @jessebraham


Examples Added

I've added some examples as actual C++-Code. It is easier for me to look at compiling examples when exploring an existing library. Two examples are taken out of the README.md, the third (Fibonacci) is taken from an Elixir-Book.
I've added a flag to the CMakeLists for conditional compiling of the examples as you did with the tests.
Thank you for the lib
Tom

Hello, sorry I must've missed the notification for this PR.
There are already "actual C++ code" in the test directory currently.
If you feel that an examples directory with self-contained examples,
I'd be okay with that but this PR in specific currently includes a bunch
of config files, cmake output and such. Please re-open and update
the patch if you're still interested in working on this.
Sorry for the late response!


Drop 2to3

This PR moves more-itertools to a single codebase for Python 2 and Python 3. I've used six judiciously (with Erik's endorsement).
The commits show me slowly taking out the 2to3 scaffolding and then removing it. I'll leave a few comments on less-than-obvious changes.

For safety, let's do either of those and <2.0.

Lgtm so far!

Ah, right. Everything got lazier. Carry on!

OK, I think this is where we want it.
After this I'd like to get a version of #47 in, and then a release?

Whoops, I meant #54 (sliding window) and not #47. Then a release.

If you're waiting for me to okay this PR, consider it okayed! You've been doing great work!