Skip to content

chore: resolve xunit warnings BED-8243 #303

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
lrfalslev wants to merge 2 commits into
base: v4
Choose a base branch
from
Open

chore: resolve xunit warnings BED-8243 #303

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
84bb2eb
resolve xunit warnings
lrfalslev May 8, 2026
9b276ee
materialize filter list to avoid multiple enumeration
lrfalslev May 8, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
150 changes: 75 additions & 75 deletions test/unit/ACLProcessorTest.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -256,10 +256,10 @@ public async Task ACLProcessor_ProcessACL_Yields_Owns_ACE() {

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalSID, expectedSID);
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(expectedSID, actual.PrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, EdgeNames.Owns);
Assert.Equal(EdgeNames.Owns, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -440,10 +440,10 @@ public async Task ACLProcessor_ProcessACL_GenericAll() {

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, EdgeNames.GenericAll);
Assert.Equal(EdgeNames.GenericAll, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -478,10 +478,10 @@ public async Task ACLProcessor_ProcessACL_GenericAll_WriteSPN() {

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, EdgeNames.WriteSPN);
Assert.Equal(EdgeNames.WriteSPN, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -516,10 +516,10 @@ public async Task ACLProcessor_ProcessACL_GenericAll_ForceChangePassword() {

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, EdgeNames.ForceChangePassword);
Assert.Equal(EdgeNames.ForceChangePassword, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -589,10 +589,10 @@ public async Task ACLProcessor_ProcessACL_WriteDacl() {

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName.ToString());
Assert.Equal(expectedRightName.ToString(), actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -662,10 +662,10 @@ public async Task ACLProcessor_ProcessACL_WriteOwner() {

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName.ToString());
Assert.Equal(expectedRightName.ToString(), actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -735,10 +735,10 @@ public async Task ACLProcessor_ProcessACL_Self() {

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -774,10 +774,10 @@ public async Task ACLProcessor_ProcessACL_Self_AllGuid() {

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -878,10 +878,10 @@ public async Task ACLProcessor_ProcessACL_ExtendedRight_Domain_DSReplicationGetC

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -916,10 +916,10 @@ public async Task ACLProcessor_ProcessACL_ExtendedRight_Domain_All() {

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -957,10 +957,10 @@ public async Task ACLProcessor_ProcessACL_ExtendedRight_Domain_DSReplicationGetC

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -1602,10 +1602,10 @@ public async Task ACLProcessor_ProcessACL_ExtendedRight_Domain_DSReplicationGetC

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -1641,10 +1641,10 @@ public async Task ACLProcessor_ProcessACL_GenericWrite_User_WriteSPN()

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -1680,10 +1680,10 @@ public async Task ACLProcessor_ProcessACL_GenericWrite_Computer_UserAccountRestr

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -1719,10 +1719,10 @@ public async Task ACLProcessor_ProcessACL_GenericWrite_Domain_WriteGPLink()

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -1758,10 +1758,10 @@ public async Task ACLProcessor_ProcessACL_GenericWrite_OU_WriteGPLink()

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -1797,10 +1797,10 @@ public async Task ACLProcessor_ProcessACL_GenericWrite_User_AddKeyPrincipal()

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -1836,10 +1836,10 @@ public async Task ACLProcessor_ProcessACL_GenericWrite_Computer_AddKeyPrincipal(

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -1875,10 +1875,10 @@ public async Task ACLProcessor_ProcessACL_GenericWrite_CertTemplate_PKIEnrollmen

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -1925,10 +1925,10 @@ public async Task ACLProcessor_ProcessACL_LAPS_CertTemplate_AllGuid()

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -1975,10 +1975,10 @@ public async Task ACLProcessor_ProcessACL_LAPS_CertTemplate_Enroll()

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -2014,10 +2014,10 @@ public async Task ACLProcessor_ProcessACL_GenericWrite_EnterpriseCA()

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -2053,10 +2053,10 @@ public async Task ACLProcessor_ProcessACL_EnterpriseCA_ManageCA()

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -2092,10 +2092,10 @@ public async Task ACLProcessor_ProcessACL_EnterpriseCA_ManageCertificates()

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}

[Fact]
Expand Down Expand Up @@ -2131,10 +2131,10 @@ public async Task ACLProcessor_ProcessACL_EnterpriseCA_Enroll()

Assert.Single(result);
var actual = result.First();
Assert.Equal(actual.PrincipalType, expectedPrincipalType);
Assert.Equal(actual.PrincipalSID, expectedPrincipalSID);
Assert.Equal(expectedPrincipalType, actual.PrincipalType);
Assert.Equal(expectedPrincipalSID, actual.PrincipalSID);
Assert.False(actual.IsInherited);
Assert.Equal(actual.RightName, expectedRightName);
Assert.Equal(expectedRightName, actual.RightName);
}
}
}
4 changes: 2 additions & 2 deletions test/unit/DefaultLabelValuesCacheTests.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -50,7 +50,7 @@ public void Empty_Intern_Returns_Empty_Array() {
}

[Fact]
public void LabelValuesCache_ReturnsSameReference_UnderConcurrency()
public async Task LabelValuesCache_ReturnsSameReference_UnderConcurrency()
{
// setup
var cache = new DefaultLabelValuesCache();
Expand All @@ -72,7 +72,7 @@ public void LabelValuesCache_ReturnsSameReference_UnderConcurrency()
}

// act
Task.WaitAll(tasks);
await Task.WhenAll(tasks);

// assert
// Take the first reference
Expand Down
8 changes: 4 additions & 4 deletions test/unit/LDAPFilterTest.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -86,7 +86,7 @@ public void LDAPFilter_GetFilterList_MergeFilter()
test.AddFilter(mandatoryFilter1, true);
test.AddFilter(mandatoryFilter2, true);

IEnumerable<string> filters = test.GetFilterList();
IReadOnlyList<string> filters = test.GetFilterList().ToList();

string computerFilter = "(samaccounttype=805306369)";
string userFilter = "(|(samaccounttype=805306368)(samaccounttype=805306370))";
Expand All @@ -100,10 +100,10 @@ public void LDAPFilter_GetFilterList_MergeFilter()
}

// Check that each of userFilter and computerFilter are accounted for
Assert.Single(filters.Where(f => f.Contains(userFilter)));
Assert.Single(filters.Where(f => f.Contains(computerFilter)));
Assert.Single(filters, f => f.Contains(userFilter));
Assert.Single(filters, f => f.Contains(computerFilter));

Assert.Equal(2, filters.Count());
Assert.Equal(2, filters.Count);
}

#endregion
Expand Down
Loading
Loading