<Rule Id="xUnit1019" Action="None" /> <!-- MemberData must reference a member providing a valid data type -->
<Rule Id="xUnit1024" Action="None" /> <!-- Test methods cannot have overloads -->
<Rule Id="xUnit1026" Action="None" /> <!-- Theory methods should use all of their parameters -->
- <Rule Id="xUnit2000" Action="None" /> <!-- Constants and literals should be the expected argument -->
<Rule Id="xUnit2005" Action="None" /> <!-- Do not use identity check on value type -->
<Rule Id="xUnit2006" Action="None" /> <!-- Do not use invalid string equality check -->
<Rule Id="xUnit2009" Action="None" /> <!-- Do not use boolean check to check for substrings -->
using (ec = ECDsaFactory.Create(curveDef.Curve))
{
param = ec.ExportParameters(true);
- Assert.NotEqual(param.D, null);
+ Assert.NotNull(param.D);
param.Validate();
ec.GenerateKey(param.Curve);
using (ec = ECDsaFactory.Create(256))
{
param = ec.ExportExplicitParameters(true);
- Assert.NotEqual(param.D, null);
+ Assert.NotNull(param.D);
ec.GenerateKey(param.Curve);
param2 = ec.ExportExplicitParameters(true);
Assert.Throws<FormatException>(() => string.Format(formatter, "{-1}", obj1, obj2));
Assert.Throws<FormatException>(() => string.Format(formatter, "{-1}", obj1, obj2, obj3));
Assert.Throws<FormatException>(() => string.Format(formatter, "{-1}", obj1, obj2, obj3, obj4));
-
+#pragma warning disable IDE0043 // Format string contains invalid placeholder - the purpose of this is to test the functions
// Format has out of range value
Assert.Throws<FormatException>(() => string.Format("{1}", obj1));
Assert.Throws<FormatException>(() => string.Format("{2}", obj1, obj2));
Assert.Throws<FormatException>(() => string.Format(formatter, "{2}", obj1, obj2));
Assert.Throws<FormatException>(() => string.Format(formatter, "{3}", obj1, obj2, obj3));
Assert.Throws<FormatException>(() => string.Format(formatter, "{4}", obj1, obj2, obj3, obj4));
+#pragma warning restore IDE0043 // Format string contains invalid placeholder
}
[Theory]
vsb.Append(Text1);
- Assert.Equal(vsb[3], 'b');
+ Assert.Equal('b', vsb[3]);
vsb[3] = 'c';
- Assert.Equal(vsb[3], 'c');
+ Assert.Equal('c', vsb[3]);
}
[Fact]
public void GetDirectories_Directory()
{
var DirectoryList = FileIO.FileSystem.GetDirectories(TestDirectory);
- Assert.Equal(DirectoryList.Count, 0);
+ Assert.Equal(0, DirectoryList.Count);
for (int i = 0; i < 6; i++)
{
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_DirectoryNewSubDirectory{i}"));
}
DirectoryList = FileIO.FileSystem.GetDirectories(TestDirectory);
- Assert.Equal(DirectoryList.Count, 6);
+ Assert.Equal(6, DirectoryList.Count);
for (int i = 0; i < 6; i++)
{
Assert.True(DirectoryList.Contains(System.IO.Path.Combine(TestDirectory, $"GetDirectories_DirectoryNewSubDirectory{i}")));
}
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_DirectoryNewSubDirectory0", $"NewSubSubDirectory"));
DirectoryList = FileIO.FileSystem.GetDirectories(TestDirectory);
- Assert.Equal(DirectoryList.Count, 6);
+ Assert.Equal(6, DirectoryList.Count);
}
[Fact]
public void GetDirectories_Directory_SearchOption()
{
var DirectoryList = FileIO.FileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly);
- Assert.Equal(DirectoryList.Count, 0);
+ Assert.Equal(0, DirectoryList.Count);
for (int i = 0; i < 6; i++)
{
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_Directory_SearchOptionNewSubDirectory{i}"));
}
DirectoryList = FileIO.FileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly);
- Assert.Equal(DirectoryList.Count, 6);
+ Assert.Equal(6, DirectoryList.Count);
for (int i = 0; i < 6; i++)
{
Assert.True(DirectoryList.Contains(System.IO.Path.Combine(TestDirectory, $"GetDirectories_Directory_SearchOptionNewSubDirectory{i}")));
}
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_Directory_SearchOptionNewSubDirectory0", $"NewSubSubDirectory"));
DirectoryList = FileIO.FileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly);
- Assert.Equal(DirectoryList.Count, 6);
+ Assert.Equal(6, DirectoryList.Count);
DirectoryList = FileIO.FileSystem.GetDirectories(TestDirectory, SearchOption.SearchAllSubDirectories);
- Assert.Equal(DirectoryList.Count, 7);
+ Assert.Equal(7, DirectoryList.Count);
}
[Fact]
public void GetDirectories_Directory_SearchOption_Wildcards()
{
var DirectoryList = FileIO.FileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly, "*");
- Assert.Equal(DirectoryList.Count, 0);
+ Assert.Equal(0, DirectoryList.Count);
var CreatedDirectories = new List<string>();
for (int i = 0; i < 6; i++)
{
CreatedDirectories.Add(System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"NewSubDirectory00{i}")).Name);
}
DirectoryList = FileIO.FileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly, "*000", "*001");
- Assert.Equal(DirectoryList.Count, 2);
+ Assert.Equal(2, DirectoryList.Count);
for (int i = 0; i < 2; i++)
{
var DirectoryName = System.IO.Path.Combine(TestDirectory, $"NewSubDirectory00{i}");
}
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"NewSubDirectory000", $"NewSubSubDirectory000"));
DirectoryList = FileIO.FileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly, "*000");
- Assert.Equal(DirectoryList.Count, 1);
+ Assert.Equal(1, DirectoryList.Count);
DirectoryList = FileIO.FileSystem.GetDirectories(TestDirectory, SearchOption.SearchAllSubDirectories, "*000");
- Assert.Equal(DirectoryList.Count, 2);
+ Assert.Equal(2, DirectoryList.Count);
}
[Fact]
public void GetFiles_Directory()
{
var FileList = FileIO.FileSystem.GetFiles(TestDirectory);
- Assert.Equal(FileList.Count, 0);
+ Assert.Equal(0, FileList.Count);
for (int i = 0; i < 6; i++)
{
CreateTestFile(SourceData, PathFromBase: null, TestFileName: $"NewFile{i}");
}
FileList = FileIO.FileSystem.GetFiles(TestDirectory);
- Assert.Equal(FileList.Count, 6);
+ Assert.Equal(6, FileList.Count);
for (int i = 0; i < 6; i++)
{
Assert.True(FileList.Contains(System.IO.Path.Combine(TestDirectory, $"NewFile{i}")));
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, "GetFiles_DirectoryNewSubDirectory"));
CreateTestFile(SourceData, PathFromBase: "GetFiles_DirectoryNewSubDirectory", TestFileName: "NewFile");
FileList = FileIO.FileSystem.GetFiles(TestDirectory);
- Assert.Equal(FileList.Count, 6);
+ Assert.Equal(6, FileList.Count);
}
[Fact]
System.IO.Directory.CreateDirectory(NewSubDirectoryPath);
CreateTestFile(SourceData, PathFromBase: "GetFiles_Directory_SearchOptionNewSubDirectory", TestFileName: "NewFile");
var FileList = FileIO.FileSystem.GetFiles(TestDirectory);
- Assert.Equal(FileList.Count, 0);
+ Assert.Equal(0, FileList.Count);
for (int i = 0; i < 6; i++)
{
CreateTestFile(SourceData, PathFromBase: null, TestFileName: $"NewFile{i}");
}
FileList = FileIO.FileSystem.GetFiles(TestDirectory, SearchOption.SearchTopLevelOnly);
CreateTestFile(SourceData, PathFromBase: null, TestFileName: "NewFile");
- Assert.Equal(FileList.Count, 6);
+ Assert.Equal(6, FileList.Count);
for (int i = 0; i < 6; i++)
{
Assert.True(FileList.Contains(System.IO.Path.Combine(TestDirectory, $"NewFile{i}")));
}
FileList = FileIO.FileSystem.GetFiles(TestDirectory, SearchOption.SearchAllSubDirectories);
- Assert.Equal(FileList.Count, 8);
+ Assert.Equal(8, FileList.Count);
for (int i = 0; i < 7; i++)
{
Assert.True(System.IO.File.Exists(FileList[i]));
public void GetFiles_Directory_SearchOption_Wildcards()
{
var FileList = FileIO.FileSystem.GetFiles(TestDirectory);
- Assert.Equal(FileList.Count, 0);
+ Assert.Equal(0, FileList.Count);
var TestFileList = new List<string>();
for (int i = 0; i < 6; i++)
{
TestFileList.Add(CreateTestFile(SourceData, PathFromBase: null, TestFileName: $"NewFile{i}{(i % 2 == 0 ? ".vb" : ".cs")}"));
}
FileList = FileIO.FileSystem.GetFiles(TestDirectory, SearchOption.SearchTopLevelOnly, "*.vb");
- Assert.Equal(FileList.Count, 3);
+ Assert.Equal(3, FileList.Count);
for (int i = 0; i < 3; i++)
{
Assert.True(TestFileList.Contains(FileList[i]));
TestFileList.Add(CreateTestFile(SourceData, PathFromBase: "GetFiles_Directory_SearchOption_WildcardsNewSubDirectory", TestFileName: "NewFile.cs"));
FileList = FileIO.FileSystem.GetFiles(TestDirectory, SearchOption.SearchAllSubDirectories, "*.cs");
Assert.True(FileList.Contains(TestFileList[TestFileList.Count - 1]), "File in Subdirectory not found");
- Assert.Equal(FileList.Count, 4);
+ Assert.Equal(4, FileList.Count);
}
[Fact]
{
var TempFile = FileIO.FileSystem.GetTempFileName();
Assert.True(System.IO.File.Exists(TempFile));
- Assert.Equal((new System.IO.FileInfo(TempFile)).Length, 0);
+ Assert.Equal(0, (new System.IO.FileInfo(TempFile)).Length);
System.IO.File.Delete(TempFile);
}
public void GetDirectories_Directory()
{
var DirectoryList = _fileSystem.GetDirectories(TestDirectory);
- Assert.Equal(DirectoryList.Count, 0);
+ Assert.Equal(0, DirectoryList.Count);
for (int i = 0; i < 6; i++)
{
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_DirectoryNewSubDirectory{i}"));
}
DirectoryList = _fileSystem.GetDirectories(TestDirectory);
- Assert.Equal(DirectoryList.Count, 6);
+ Assert.Equal(6, DirectoryList.Count);
for (int i = 0; i < 6; i++)
{
Assert.True(DirectoryList.Contains(System.IO.Path.Combine(TestDirectory, $"GetDirectories_DirectoryNewSubDirectory{i}")));
}
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_DirectoryNewSubDirectory0", $"NewSubSubDirectory"));
DirectoryList = _fileSystem.GetDirectories(TestDirectory);
- Assert.Equal(DirectoryList.Count, 6);
+ Assert.Equal(6, DirectoryList.Count);
}
[Fact]
public void GetDirectories_Directory_SearchOption()
{
var DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly);
- Assert.Equal(DirectoryList.Count, 0);
+ Assert.Equal(0, DirectoryList.Count);
for (int i = 0; i < 6; i++)
{
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_Directory_SearchOptionNewSubDirectory{i}"));
}
DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly);
- Assert.Equal(DirectoryList.Count, 6);
+ Assert.Equal(6, DirectoryList.Count);
for (int i = 0; i < 6; i++)
{
Assert.True(DirectoryList.Contains(System.IO.Path.Combine(TestDirectory, $"GetDirectories_Directory_SearchOptionNewSubDirectory{i}")));
}
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"GetDirectories_Directory_SearchOptionNewSubDirectory0", $"NewSubSubDirectory"));
DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly);
- Assert.Equal(DirectoryList.Count, 6);
+ Assert.Equal(6, DirectoryList.Count);
DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchAllSubDirectories);
- Assert.Equal(DirectoryList.Count, 7);
+ Assert.Equal(7, DirectoryList.Count);
}
[Fact]
public void GetDirectories_Directory_SearchOption_Wildcards()
{
var DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly, "*");
- Assert.Equal(DirectoryList.Count, 0);
+ Assert.Equal(0, DirectoryList.Count);
var CreatedDirectories = new List<string>();
for (int i = 0; i < 6; i++)
{
CreatedDirectories.Add(System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"NewSubDirectory00{i}")).Name);
}
DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly, "*000", "*001");
- Assert.Equal(DirectoryList.Count, 2);
+ Assert.Equal(2, DirectoryList.Count);
for (int i = 0; i < 2; i++)
{
var DirectoryName = System.IO.Path.Combine(TestDirectory, $"NewSubDirectory00{i}");
}
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, $"NewSubDirectory000", $"NewSubSubDirectory000"));
DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchTopLevelOnly, "*000");
- Assert.Equal(DirectoryList.Count, 1);
+ Assert.Equal(1, DirectoryList.Count);
DirectoryList = _fileSystem.GetDirectories(TestDirectory, SearchOption.SearchAllSubDirectories, "*000");
- Assert.Equal(DirectoryList.Count, 2);
+ Assert.Equal(2, DirectoryList.Count);
}
[Fact]
public void GetFiles_Directory()
{
var FileList = _fileSystem.GetFiles(TestDirectory);
- Assert.Equal(FileList.Count, 0);
+ Assert.Equal(0, FileList.Count);
for (int i = 0; i < 6; i++)
{
CreateTestFile(SourceData, PathFromBase: null, TestFileName: $"NewFile{i}");
}
FileList = _fileSystem.GetFiles(TestDirectory);
- Assert.Equal(FileList.Count, 6);
+ Assert.Equal(6, FileList.Count);
for (int i = 0; i < 6; i++)
{
Assert.True(FileList.Contains(System.IO.Path.Combine(TestDirectory, $"NewFile{i}")));
System.IO.Directory.CreateDirectory(System.IO.Path.Combine(TestDirectory, "GetFiles_DirectoryNewSubDirectory"));
CreateTestFile(SourceData, PathFromBase: "GetFiles_DirectoryNewSubDirectory", TestFileName: "NewFile");
FileList = _fileSystem.GetFiles(TestDirectory);
- Assert.Equal(FileList.Count, 6);
+ Assert.Equal(6, FileList.Count);
}
[Fact]
System.IO.Directory.CreateDirectory(NewSubDirectoryPath);
CreateTestFile(SourceData, PathFromBase: "GetFiles_Directory_SearchOptionNewSubDirectory", TestFileName: "NewFile");
var FileList = _fileSystem.GetFiles(TestDirectory);
- Assert.Equal(FileList.Count, 0);
+ Assert.Equal(0, FileList.Count);
for (int i = 0; i < 6; i++)
{
CreateTestFile(SourceData, PathFromBase: null, TestFileName: $"NewFile{i}");
}
FileList = _fileSystem.GetFiles(TestDirectory, SearchOption.SearchTopLevelOnly);
CreateTestFile(SourceData, PathFromBase: null, TestFileName: "NewFile");
- Assert.Equal(FileList.Count, 6);
+ Assert.Equal(6, FileList.Count);
for (int i = 0; i < 6; i++)
{
Assert.True(FileList.Contains(System.IO.Path.Combine(TestDirectory, $"NewFile{i}")));
}
FileList = _fileSystem.GetFiles(TestDirectory, SearchOption.SearchAllSubDirectories);
- Assert.Equal(FileList.Count, 8);
+ Assert.Equal(8, FileList.Count);
for (int i = 0; i < 7; i++)
{
Assert.True(System.IO.File.Exists(FileList[i]));
public void GetFiles_Directory_SearchOption_Wildcards()
{
var FileList = _fileSystem.GetFiles(TestDirectory);
- Assert.Equal(FileList.Count, 0);
+ Assert.Equal(0, FileList.Count);
var TestFileList = new List<string>();
for (int i = 0; i < 6; i++)
{
TestFileList.Add(CreateTestFile(SourceData, PathFromBase: null, TestFileName: $"NewFile{i}{(i % 2 == 0 ? ".vb" : ".cs")}"));
}
FileList = _fileSystem.GetFiles(TestDirectory, SearchOption.SearchTopLevelOnly, "*.vb");
- Assert.Equal(FileList.Count, 3);
+ Assert.Equal(3, FileList.Count);
for (int i = 0; i < 3; i++)
{
Assert.True(TestFileList.Contains(FileList[i]));
TestFileList.Add(CreateTestFile(SourceData, PathFromBase: "GetFiles_Directory_SearchOption_WildcardsNewSubDirectory", TestFileName: "NewFile.cs"));
FileList = _fileSystem.GetFiles(TestDirectory, SearchOption.SearchAllSubDirectories, "*.cs");
Assert.True(FileList.Contains(TestFileList[TestFileList.Count - 1]), "File in Subdirectory not found");
- Assert.Equal(FileList.Count, 4);
+ Assert.Equal(4, FileList.Count);
}
[Fact]
{
var TempFile = _fileSystem.GetTempFileName();
Assert.True(System.IO.File.Exists(TempFile));
- Assert.Equal((new System.IO.FileInfo(TempFile)).Length, 0);
+ Assert.Equal(0, (new System.IO.FileInfo(TempFile)).Length);
System.IO.File.Delete(TempFile);
}
ArrayPool<byte> pool = ArrayPool<byte>.Create(maxArraysPerBucket: 1, maxArrayLength: 32);
byte[] rented = pool.Rent(27);
Assert.NotNull(rented);
- Assert.Equal(rented.Length, 32);
+ Assert.Equal(32, rented.Length);
}
[Fact]
// Note - yes this is bad to hold on to the old instance but we need to validate the contract
pool.Return(buffer, clearArray: true);
- CheckFilledArray(buffer, (byte b1, byte b2) => Assert.Equal(b1, default(byte)));
+ CheckFilledArray(buffer, (byte b1, byte b2) => Assert.Equal(default(byte), b1));
}
[Fact]
array[0].InternalRef = "foo";
array[1].InternalRef = "bar";
pool.Return(array, clearArray: true);
- Assert.Equal(array[0], default(TestStruct));
- Assert.Equal(array[1], default(TestStruct));
+ Assert.Equal(default(TestStruct), array[0]);
+ Assert.Equal(default(TestStruct), array[1]);
}
[Fact]
expectedNext++;
}
Assert.False(enumerator2.MoveNext());
- Assert.Equal(expectedNext, 6);
+ Assert.Equal(6, expectedNext);
}
}
Task.WaitAll(workers);
- Assert.Equal(_hash2.Count, 0);
+ Assert.Equal(0, _hash2.Count);
}
private void AddElements(string strName)
var hash2 = new Hashtable();
Assert.NotSame(hash1.SyncRoot, hash2.SyncRoot);
- Assert.Equal(hash1.SyncRoot.GetType(), typeof(Hashtable));
+ Assert.Equal(typeof(Hashtable), hash1.SyncRoot.GetType());
// Cloned hashtables have different SyncRoots
hash1 = new Hashtable();
sortListMother.Add("Key_" + i, "Value_" + i);
}
- Assert.Equal(sortListMother.SyncRoot.GetType(), typeof(SortedList));
+ Assert.Equal(typeof(SortedList), sortListMother.SyncRoot.GetType());
SortedList sortListSon = SortedList.Synchronized(sortListMother);
_sortListGrandDaughter = SortedList.Synchronized(sortListSon);
public void ClearEmptyList()
{
List<T> list = new List<T>();
- Assert.Equal(list.Count, 0); //"Should be equal to 0"
+ Assert.Equal(0, list.Count); //"Should be equal to 0"
list.Clear();
- Assert.Equal(list.Count, 0); //"Should be equal to 0."
+ Assert.Equal(0, list.Count); //"Should be equal to 0."
}
public void ClearMultipleTimesEmptyList(int times)
{
List<T> list = new List<T>();
- Assert.Equal(list.Count, 0); //"Should be equal to 0."
+ Assert.Equal(0, list.Count); //"Should be equal to 0."
for (int i = 0; i < times; i++)
{
list.Clear();
- Assert.Equal(list.Count, 0); //"Should be equal to 0."
+ Assert.Equal(0, list.Count); //"Should be equal to 0."
}
}
public void ClearNonEmptyList(T[] items)
{
List<T> list = new List<T>(items);
list.Clear();
- Assert.Equal(list.Count, 0); //"Should be equal to 0."
+ Assert.Equal(0, list.Count); //"Should be equal to 0."
}
public void ClearMultipleTimesNonEmptyList(T[] items, int times)
for (int i = 0; i < times; i++)
{
list.Clear();
- Assert.Equal(list.Count, 0); //"Should be equal to 0."
+ Assert.Equal(0, list.Count); //"Should be equal to 0."
}
}
{
List<T> list = new List<T>();
IList _ilist = list;
- Assert.Equal(list.Count, 0); //"Should be equal to 0."
+ Assert.Equal(0, list.Count); //"Should be equal to 0."
_ilist.Clear();
- Assert.Equal(list.Count, 0); //"Should be equal to 0."
+ Assert.Equal(0, list.Count); //"Should be equal to 0."
}
public void NonGenericIListClearMultipleTimesEmptyList(int times)
{
List<T> list = new List<T>();
IList _ilist = list;
- Assert.Equal(list.Count, 0); //"Should be equal to 0."
+ Assert.Equal(0, list.Count); //"Should be equal to 0."
for (int i = 0; i < times; i++)
{
_ilist.Clear();
- Assert.Equal(list.Count, 0); //"Should be equal to 0."
+ Assert.Equal(0, list.Count); //"Should be equal to 0."
}
}
public void NonGenericIListClearNonEmptyList(T[] items)
List<T> list = new List<T>(items);
IList _ilist = list;
_ilist.Clear();
- Assert.Equal(list.Count, 0); //"Should be equal to 0."
+ Assert.Equal(0, list.Count); //"Should be equal to 0."
}
public void NonGenericIListClearMultipleTimesNonEmptyList(T[] items, int times)
for (int i = 0; i < times; i++)
{
_ilist.Clear();
- Assert.Equal(list.Count, 0); //"Should be equal to 0."
+ Assert.Equal(0, list.Count); //"Should be equal to 0."
}
}
var catalog = new TypeCatalog(new[] {
typeof(AmbiguousConstructors),
typeof(ConstructorArgs) }, ctx);
- Assert.Equal(catalog.Parts.Count(), 2);
+ Assert.Equal(2, catalog.Parts.Count());
var container = new CompositionContainer(catalog, CompositionOptions.DisableSilentRejection);
Assert.Throws<CompositionException>(() => container.GetExportedValue<AmbiguousConstructors>());
}
Assert.NotNull(export.Metadata);
Assert.NotNull(export.Metadata.Values);
- Assert.Equal(export.Metadata.Values.Count(), 3);
- Assert.Equal(export.Metadata.Values.First(), "One");
- Assert.Equal(export.Metadata.Values.Skip(1).First(), "two");
- Assert.Equal(export.Metadata.Values.Skip(2).First(), "3");
+ Assert.Equal(3, export.Metadata.Values.Count());
+ Assert.Equal("One", export.Metadata.Values.First());
+ Assert.Equal("two", export.Metadata.Values.Skip(1).First());
+ Assert.Equal("3", export.Metadata.Values.Skip(2).First());
}
[Fact]
batch.AddParts(new object());
container.Compose(batch);
- Assert.Equal(entrypoint.LowerCaseStrings.Count, 1);
- Assert.Equal(entrypoint.ImportCompletedCallCount, 1);
- Assert.Equal(entrypoint.UpperCaseStrings.Count, 1);
- Assert.Equal(entrypoint.LowerCaseStrings[0].Value.String, "abc");
- Assert.Equal(entrypoint.UpperCaseStrings[0], "ABC");
+ Assert.Equal(1, entrypoint.LowerCaseStrings.Count);
+ Assert.Equal(1, entrypoint.ImportCompletedCallCount);
+ Assert.Equal(1, entrypoint.UpperCaseStrings.Count);
+ Assert.Equal("abc", entrypoint.LowerCaseStrings[0].Value.String);
+ Assert.Equal("ABC", entrypoint.UpperCaseStrings[0]);
}
[Fact]
batch.AddParts(new LowerCaseString("abc"), entrypoint);
container.Compose(batch);
- Assert.Equal(entrypoint.LowerCaseStrings.Count, 1);
- Assert.Equal(entrypoint.ImportCompletedCallCount, 1);
- Assert.Equal(entrypoint.UpperCaseStrings.Count, 1);
- Assert.Equal(entrypoint.LowerCaseStrings[0].Value.String, "abc");
- Assert.Equal(entrypoint.UpperCaseStrings[0], "ABC");
+ Assert.Equal(1, entrypoint.LowerCaseStrings.Count);
+ Assert.Equal(1, entrypoint.ImportCompletedCallCount);
+ Assert.Equal(1, entrypoint.UpperCaseStrings.Count);
+ Assert.Equal("abc", entrypoint.LowerCaseStrings[0].Value.String);
+ Assert.Equal("ABC", entrypoint.UpperCaseStrings[0]);
// Add another component to verify recomposing
batch = new CompositionBatch();
batch.AddParts(new LowerCaseString("def"));
container.Compose(batch);
- Assert.Equal(entrypoint.LowerCaseStrings.Count, 2);
- Assert.Equal(entrypoint.ImportCompletedCallCount, 2);
- Assert.Equal(entrypoint.UpperCaseStrings.Count, 2);
- Assert.Equal(entrypoint.LowerCaseStrings[1].Value.String, "def");
- Assert.Equal(entrypoint.UpperCaseStrings[1], "DEF");
+ Assert.Equal(2, entrypoint.LowerCaseStrings.Count);
+ Assert.Equal(2, entrypoint.ImportCompletedCallCount);
+ Assert.Equal(2, entrypoint.UpperCaseStrings.Count);
+ Assert.Equal("def", entrypoint.LowerCaseStrings[1].Value.String);
+ Assert.Equal("DEF", entrypoint.UpperCaseStrings[1]);
// Verify that adding a random component doesn't cause
// the OnImportsSatisfied to be called again.
batch.AddParts(new object());
container.Compose(batch);
- Assert.Equal(entrypoint.LowerCaseStrings.Count, 2);
- Assert.Equal(entrypoint.ImportCompletedCallCount, 2);
- Assert.Equal(entrypoint.UpperCaseStrings.Count, 2);
+ Assert.Equal(2, entrypoint.LowerCaseStrings.Count);
+ Assert.Equal(2, entrypoint.ImportCompletedCallCount);
+ Assert.Equal(2, entrypoint.UpperCaseStrings.Count);
}
[Fact]
e2.Value.FooChild.FooValue = 20;
e3.Value.FooChild.FooValue = 30;
- Assert.Equal<int>(e1.Value.FooChild.FooValue, 30);
- Assert.Equal<int>(e2.Value.FooChild.FooValue, 30);
- Assert.Equal<int>(e3.Value.FooChild.FooValue, 30);
+ Assert.Equal<int>(30, e1.Value.FooChild.FooValue);
+ Assert.Equal<int>(30, e2.Value.FooChild.FooValue);
+ Assert.Equal<int>(30, e3.Value.FooChild.FooValue);
}
[Fact]
e2.Value.FooChild.FooValue = 20;
e3.Value.FooChild.FooValue = 30;
- Assert.Equal<int>(e1.Value.FooChild.FooValue, 10);
- Assert.Equal<int>(e2.Value.FooChild.FooValue, 20);
- Assert.Equal<int>(e3.Value.FooChild.FooValue, 30);
+ Assert.Equal<int>(10, e1.Value.FooChild.FooValue);
+ Assert.Equal<int>(20, e2.Value.FooChild.FooValue);
+ Assert.Equal<int>(30, e3.Value.FooChild.FooValue);
}
[Fact]
e2.Value.FooChild.FooValue = 20;
e3.Value.FooChild.FooValue = 30;
- Assert.Equal<int>(e1.Value.FooChild.FooValue, 10);
- Assert.Equal<int>(e2.Value.FooChild.FooValue, 20);
- Assert.Equal<int>(e3.Value.FooChild.FooValue, 30);
+ Assert.Equal<int>(10, e1.Value.FooChild.FooValue);
+ Assert.Equal<int>(20, e2.Value.FooChild.FooValue);
+ Assert.Equal<int>(30, e3.Value.FooChild.FooValue);
}
[Fact]
e2.Value.FooChild.FooValue = 20;
e3.Value.FooChild.FooValue = 30;
- Assert.Equal<int>(e1.Value.FooChild.FooValue, 30);
- Assert.Equal<int>(e2.Value.FooChild.FooValue, 30);
- Assert.Equal<int>(e3.Value.FooChild.FooValue, 30);
+ Assert.Equal<int>(30, e1.Value.FooChild.FooValue);
+ Assert.Equal<int>(30, e2.Value.FooChild.FooValue);
+ Assert.Equal<int>(30, e3.Value.FooChild.FooValue);
}
}
}
Assert.False(filter2Ing);
Assert.False(filter2Ed);
- Assert.Equal(edArgs.AddedDefinitions.Count(), 2);
- Assert.Equal(edArgs.RemovedDefinitions.Count(), 0);
+ Assert.Equal(2, edArgs.AddedDefinitions.Count());
+ Assert.Equal(0, edArgs.RemovedDefinitions.Count());
Assert.Equal(0, filter2.Parts.Count());
Assert.Equal(2, filter1.Parts.Count());
Assert.False(filter1Ing);
Assert.False(filter1Ed);
- Assert.Equal(edArgs.AddedDefinitions.Count(), 2);
- Assert.Equal(edArgs.RemovedDefinitions.Count(), 0);
+ Assert.Equal(2, edArgs.AddedDefinitions.Count());
+ Assert.Equal(0, edArgs.RemovedDefinitions.Count());
Assert.Equal(2, filter2.Parts.Count());
Assert.Equal(2, filter1.Parts.Count());
Assert.False(filter1Ing);
Assert.False(filter1Ed);
- Assert.Equal(edArgs.AddedDefinitions.Count(), 0);
- Assert.Equal(edArgs.RemovedDefinitions.Count(), 2);
+ Assert.Equal(0, edArgs.AddedDefinitions.Count());
+ Assert.Equal(2, edArgs.RemovedDefinitions.Count());
Assert.Equal(0, filter2.Parts.Count());
Assert.Equal(2, filter1.Parts.Count());
Assert.False(filter2Ing);
Assert.False(filter2Ed);
- Assert.Equal(edArgs.AddedDefinitions.Count(), 0);
- Assert.Equal(edArgs.RemovedDefinitions.Count(), 2);
+ Assert.Equal(0, edArgs.AddedDefinitions.Count());
+ Assert.Equal(2, edArgs.RemovedDefinitions.Count());
Assert.Equal(0, filter2.Parts.Count());
Assert.Equal(0, filter1.Parts.Count());
container.Compose(batch);
Assert.Equal(1, stableImporter.ImportSatisfiedCount);
- Assert.Equal(stableImporter.GetImport("stable"), 42);
+ Assert.Equal(42, stableImporter.GetImport("stable"));
Assert.Equal(1, dynamicImporter.ImportSatisfiedCount);
- Assert.Equal(dynamicImporter.GetImport("dynamic"), 1);
+ Assert.Equal(1, dynamicImporter.GetImport("dynamic"));
batch = new CompositionBatch();
stableImporter.ResetImportSatisfiedCount();
container.Compose(batch);
Assert.Equal(0, stableImporter.ImportSatisfiedCount);
- Assert.Equal(stableImporter.GetImport("stable"), 42);
+ Assert.Equal(42, stableImporter.GetImport("stable"));
Assert.Equal(1, dynamicImporter.ImportSatisfiedCount);
- Assert.Equal(dynamicImporter.GetImport("dynamic"), 2);
+ Assert.Equal(2, dynamicImporter.GetImport("dynamic"));
}
}
}
var view1 = MetadataViewProvider.GetMetadataView<IMetadataViewWithImplementation>(metadata);
Assert.Equal("One", view1.String1);
Assert.Equal("Two", view1.String2);
- Assert.Equal(view1.GetType(), typeof(MetadataViewWithImplementation));
+ Assert.Equal(typeof(MetadataViewWithImplementation), view1.GetType());
}
[Fact]
part.SetImport(importDef, CreateSimpleExports(21));
- Assert.NotEqual(import.Value, 21);
+ Assert.NotEqual(21, import.Value);
part.Activate();
- Assert.Equal(import.Value, 21);
+ Assert.Equal(21, import.Value);
part.SetImport(importDef, CreateSimpleExports(42));
- Assert.NotEqual(import.Value, 42);
+ Assert.NotEqual(42, import.Value);
part.Activate();
- Assert.Equal(import.Value, 42);
+ Assert.Equal(42, import.Value);
}
[Fact]
public void ImportDefinitions_ImportWithCustomAttributeImports()
{
var part = CreatePart(typeof(ImportWithCustomImport));
- Assert.Equal(part.ImportDefinitions.Count(), 1);
+ Assert.Equal(1, part.ImportDefinitions.Count());
ContractBasedImportDefinition import = part.ImportDefinitions.First() as ContractBasedImportDefinition;
Assert.NotNull(import);
public void ImportDefinitions_ImportWithCustomImportInvalidTarget_ShouldbeIgnored()
{
var part = CreatePart(typeof(ImportWithCustomImportInvalidTarget));
- Assert.Equal(part.ImportDefinitions.Count(), 0);
+ Assert.Equal(0, part.ImportDefinitions.Count());
}
[PartNotDiscoverable]
public void ImportDefinitions_ImportManyWithCustomAttributeImportManys()
{
var part = CreatePart(typeof(ImportManyWithCustomImportMany));
- Assert.Equal(part.ImportDefinitions.Count(), 1);
+ Assert.Equal(1, part.ImportDefinitions.Count());
ContractBasedImportDefinition import = part.ImportDefinitions.First() as ContractBasedImportDefinition;
Assert.NotNull(import);
public void ImportDefinitions_ImportManyWithCustomImportManyInvalidTarget_ShouldbeIgnored()
{
var part = CreatePart(typeof(ImportManyWithCustomImportManyInvalidTarget));
- Assert.Equal(part.ImportDefinitions.Count(), 0);
+ Assert.Equal(0, part.ImportDefinitions.Count());
}
[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = false)]
public void ImportDefinitions_ImportingConstructorWithCustomAttributeImportingConstructors()
{
var part = CreatePart(typeof(ImportingConstructorWithCustomImportingConstructor));
- Assert.Equal(part.ImportDefinitions.Count(), 1);
+ Assert.Equal(1, part.ImportDefinitions.Count());
ContractBasedImportDefinition import = part.ImportDefinitions.First() as ContractBasedImportDefinition;
Assert.NotNull(import);
{
var part = CreatePart(typeof(ImportingConstructorWithCustomImportingConstructorAllowMultiple));
- Assert.Equal(part.ImportDefinitions.Count(), 1);
+ Assert.Equal(1, part.ImportDefinitions.Count());
ContractBasedImportDefinition import = part.ImportDefinitions.First() as ContractBasedImportDefinition;
Assert.NotNull(import);
public void ImportDefinitions_ImportingConstructorWithCustomImportingConstructorInvalidTarget_ShouldbeIgnored()
{
var part = CreatePart(typeof(ImportingConstructorWithCustomImportingConstructorInvalidTarget));
- Assert.Equal(part.ImportDefinitions.Count(), 0);
+ Assert.Equal(0, part.ImportDefinitions.Count());
}
private Export[] CreateSimpleExports(object value)
[Export("ActionWith1Arg")]
public void MyAction1(int i1)
{
- Assert.Equal(i1, 1);
+ Assert.Equal(1, i1);
}
[Export("ActionWith2Args")]
public void MyAction2(int i1, int i2)
{
- Assert.Equal(i1, 1);
- Assert.Equal(i2, 2);
+ Assert.Equal(1, i1);
+ Assert.Equal(2, i2);
}
[Export("ActionWith3Args")]
public void MyAction3(int i1, int i2, int i3)
{
- Assert.Equal(i1, 1);
- Assert.Equal(i2, 2);
- Assert.Equal(i3, 3);
+ Assert.Equal(1, i1);
+ Assert.Equal(2, i2);
+ Assert.Equal(3, i3);
}
[Export("ActionWith4Args")]
public void MyAction4(int i1, int i2, int i3, int i4)
{
- Assert.Equal(i1, 1);
- Assert.Equal(i2, 2);
- Assert.Equal(i3, 3);
- Assert.Equal(i4, 4);
+ Assert.Equal(1, i1);
+ Assert.Equal(2, i2);
+ Assert.Equal(3, i3);
+ Assert.Equal(4, i4);
}
}
batch.AddPart(new Friend("Steve"));
batch.AddPart(new Friend("Joyce"));
container.Compose(batch);
- Assert.Equal(me.Name, "Blake");
- Assert.Equal(me.Job, null);
- Assert.Equal(me.Friends.Length, 3);
- Assert.Equal(me.Relatives.Length, 1);
- Assert.Equal(me.Children.Length, 0);
+ Assert.Equal("Blake", me.Name);
+ Assert.Null(me.Job);
+ Assert.Equal(3, me.Friends.Length);
+ Assert.Equal(1, me.Relatives.Length);
+ Assert.Equal(0, me.Children.Length);
// Can only have one name
Assert.Throws<ChangeRejectedException>(() =>
batch.AddPart(new MyName("Blayke"));
batch.RemovePart(namePart);
container.Compose(batch);
- Assert.Equal(me.Name, "Blayke");
+ Assert.Equal("Blayke", me.Name);
batch = new CompositionBatch();
var jobPart = batch.AddPart(new Job("Architect"));
container.Compose(batch);
- Assert.Equal(me.Job, "Architect");
+ Assert.Equal("Architect", me.Job);
batch = new CompositionBatch();
batch.AddPart(new Job("Chimney Sweep"));
batch = new CompositionBatch();
batch.RemovePart(jobPart);
container.Compose(batch);
- Assert.Equal(me.Job, "Chimney Sweep");
+ Assert.Equal("Chimney Sweep", me.Job);
batch = new CompositionBatch();
Assert.Throws<ChangeRejectedException>(() =>
container.ComposeParts(new Spouse("Cameron")));
- Assert.Equal(me.Relatives.Length, 1);
+ Assert.Equal(1, me.Relatives.Length);
batch = new CompositionBatch();
batch.AddPart(new Friend("Graham"));
container.Compose(batch);
- Assert.Equal(me.Friends.Length, 4);
- Assert.Equal(me.Relatives.Length, 1);
+ Assert.Equal(4, me.Friends.Length);
+ Assert.Equal(1, me.Relatives.Length);
}
public class FooWithOptionalImport
[Fact]
public static void Get_UnderlyingType()
{
- Assert.Equal(NullableConverterTests.s_intNullableConverter.UnderlyingType, typeof(int));
- Assert.Equal(NullableConverterTests.s_myNullableConverter.UnderlyingType, typeof(SomeValueType));
+ Assert.Equal(typeof(int), NullableConverterTests.s_intNullableConverter.UnderlyingType);
+ Assert.Equal(typeof(SomeValueType), NullableConverterTests.s_myNullableConverter.UnderlyingType);
}
[Fact]
public static void Get_NullableType()
{
- Assert.Equal(NullableConverterTests.s_intNullableConverter.NullableType, typeof(int?));
- Assert.Equal(NullableConverterTests.s_myNullableConverter.NullableType, typeof(SomeValueType?));
+ Assert.Equal(typeof(int?), NullableConverterTests.s_intNullableConverter.NullableType);
+ Assert.Equal(typeof(SomeValueType?), NullableConverterTests.s_myNullableConverter.NullableType);
}
[Fact]
Collections.Generic.IEnumerable<ExportAttribute> exports = builder.GetCustomAttributes(typeof(FooImpl), typeof(FooImpl).GetTypeInfo()).Where<Attribute>(e => e is ExportAttribute).Cast<ExportAttribute>();
Assert.Equal(1, exports.Count());
- Assert.Equal(exports.First().ContractType, typeof(IFoo));
+ Assert.Equal(typeof(IFoo), exports.First().ContractType);
}
[Fact]
Collections.Generic.IEnumerable<ExportAttribute> exports = builder.GetDeclaredAttributes(typeof(FooImpl), typeof(FooImpl).GetTypeInfo()).Where<Attribute>(e => e is ExportAttribute).Cast<ExportAttribute>();
Assert.Equal(1, exports.Count());
- Assert.Equal(exports.First().ContractType, typeof(IFoo));
+ Assert.Equal(typeof(IFoo), exports.First().ContractType);
}
IEnumerable<ExportAttribute> exports = builder.GetDeclaredAttributes(typeof(CFoo), typeof(CFoo).GetTypeInfo()).Where<Attribute>(e => e is ExportAttribute).Cast<ExportAttribute>();
Assert.Equal(1, exports.Count());
- Assert.Equal(exports.First().ContractType, typeof(IFoo));
+ Assert.Equal(typeof(IFoo), exports.First().ContractType);
}
[Fact]
IEnumerable<ExportAttribute> exports = builder.GetDeclaredAttributes(typeof(CFoo), typeof(CFoo).GetTypeInfo()).Where<Attribute>(e => e is ExportAttribute).Cast<ExportAttribute>();
Assert.Equal(1, exports.Count());
- Assert.Equal(exports.First().ContractType, typeof(IFoo));
+ Assert.Equal(typeof(IFoo), exports.First().ContractType);
}
[Fact]
var cc = CreateContainer(typeof(MetadataCircularityA), typeof(MetadataCircularityB));
var a = cc.GetExport<MetadataCircularityA>();
- Assert.Equal(a.B.Metadata.Name, "B");
- Assert.Equal(a.B.Value.A.Metadata.Name, "A");
+ Assert.Equal("B", a.B.Metadata.Name);
+ Assert.Equal("A", a.B.Value.A.Metadata.Name);
}
[Fact]
var b = test.GetExport<ClassWithDependecyAndSameBaseType>();
Assert.NotNull(b);
Assert.NotNull(b._dep);
- Assert.Equal(b._dep.GetType(), typeof(TestDependency));
+ Assert.Equal(typeof(TestDependency), b._dep.GetType());
}
}
}
var cc = CreateContainer(typeof(MetadataCircularityA), typeof(MetadataCircularityB));
var a = cc.GetExport<MetadataCircularityA>();
- Assert.Equal(a.B.Metadata.Name, "B");
- Assert.Equal(a.B.Value.A.Metadata.Name, "A");
+ Assert.Equal("B", a.B.Metadata.Name);
+ Assert.Equal("A", a.B.Value.A.Metadata.Name);
}
[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
var cInstance = cc.GetExport<CirA>();
cInstance.SharedState = 1;
var bInstance1 = cInstance.CreateInstance();
- Assert.Equal(bInstance1.DepC.DepA.SharedState, 1);
+ Assert.Equal(1, bInstance1.DepC.DepA.SharedState);
bInstance1.DepC.DepA.SharedState = 10;
cInstance.CreateInstance();
- Assert.Equal(bInstance1.DepC.DepA.SharedState, 10);
+ Assert.Equal(10, bInstance1.DepC.DepA.SharedState);
}
/// <summary>
attribute.MinValueString = "05:55:55";
string test = attribute.MinValueString;
- Assert.Equal(test, "05:55:55");
+ Assert.Equal("05:55:55", test);
attribute.MinValueString = "23:59:59";
test = attribute.MinValueString;
- Assert.Equal(test, "23:59:59");
+ Assert.Equal("23:59:59", test);
attribute.MinValueString = "00:00:00";
test = attribute.MinValueString;
- Assert.Equal(test, "00:00:00");
+ Assert.Equal("00:00:00", test);
attribute.MinValueString = "1:01:00:00";
test = attribute.MinValueString;
- Assert.Equal(test, "1.01:00:00");
+ Assert.Equal("1.01:00:00", test);
attribute.MinValueString = "2:22:50:45.2563";
test = attribute.MinValueString;
- Assert.Equal(test, "2.22:50:45.2563000");
+ Assert.Equal("2.22:50:45.2563000", test);
}
[Fact]
attribute.MaxValueString = "05:55:55";
string test = attribute.MaxValueString;
- Assert.Equal(test, "05:55:55");
+ Assert.Equal("05:55:55", test);
attribute.MaxValueString = "23:59:59";
test = attribute.MaxValueString;
- Assert.Equal(test, "23:59:59");
+ Assert.Equal("23:59:59", test);
attribute.MaxValueString = "00:00:00";
test = attribute.MaxValueString;
- Assert.Equal(test, "00:00:00");
+ Assert.Equal("00:00:00", test);
attribute.MaxValueString = "1:01:00:00";
test = attribute.MaxValueString;
- Assert.Equal(test, "1.01:00:00");
+ Assert.Equal("1.01:00:00", test);
attribute.MaxValueString = "2:22:50:45.2563";
test = attribute.MaxValueString;
- Assert.Equal(test, "2.22:50:45.2563000");
+ Assert.Equal("2.22:50:45.2563000", test);
}
[Fact]
DataTable providerTable = DbProviderFactories.GetFactoryClasses();
Assert.Equal(2, providerTable.Rows.Count);
List<string> invariantNames = DbProviderFactories.GetProviderInvariantNames().ToList();
- Assert.Equal(invariantNames.Count, 2);
+ Assert.Equal(2, invariantNames.Count);
Assert.True(invariantNames.Contains("System.Data.Common.TestProvider"));
Assert.True(invariantNames.Contains("System.Data.SqlClient"));
}
ds.Relations.Add(rel1);
ds.Relations.Add(rel2);
- Assert.Equal(ds.Relations.Count, 2);
+ Assert.Equal(2, ds.Relations.Count);
ds.Relations.CollectionChanged += new CollectionChangeEventHandler(Relations_CollectionChanged);
//Perform remove
{
DataTable dt = DataProvider.CreateParentDataTable();
int count = dt.Rows.Count;
- Assert.Equal(count != 0, true);
+ Assert.NotEqual(0, count);
dt.Rows.Clear();
Assert.Equal(0, dt.Rows.Count);
}
Assert.Equal(dr.RowError, string.Empty);
dr.RowError = "Err";
- Assert.Equal(dr.RowError, "Err");
+ Assert.Equal("Err", dr.RowError);
}
[Fact]
table.AcceptChanges();
row.SetModified();
- Assert.Equal(row.RowState, DataRowState.Modified);
+ Assert.Equal(DataRowState.Modified, row.RowState);
Assert.Equal(1, row[0, DataRowVersion.Current]);
Assert.Equal(1, row[0, DataRowVersion.Original]);
table.RejectChanges();
- Assert.Equal(row.RowState, DataRowState.Unchanged);
+ Assert.Equal(DataRowState.Unchanged, row.RowState);
}
[Fact]
public void DataRowExpressionDefaultValueTest()
child.Rows[0].Delete();
changes = ds.GetChanges();
- Assert.Equal(changes.Tables.Count, 2);
+ Assert.Equal(2, changes.Tables.Count);
Assert.Equal(1, changes.Tables["parent"].Rows.Count);
Assert.Equal(1, (int)changes.Tables["parent"].Rows[0][0]);
}
Assert.True(_rowDeleted);
Assert.Equal(_rowInAction_Deleting, dt.Rows[4]);
Assert.Equal(_rowInAction_Deleted, dt.Rows[4]);
- Assert.Equal(_rowAction_Deleting, DataRowAction.Delete);
- Assert.Equal(_rowAction_Deleted, DataRowAction.Delete);
+ Assert.Equal(DataRowAction.Delete, _rowAction_Deleting);
+ Assert.Equal(DataRowAction.Delete, _rowAction_Deleted);
dt.LoadDataRow(new object[] { 5, "mono 5" }, LoadOption.Upsert);
Assert.Equal(6, dt.Rows.Count);
Assert.Equal("mono 5", dt.Rows[5][1]);
Assert.True(_rowDeleted);
Assert.Equal(_rowInAction_Deleting, dt.Rows[4]);
Assert.Equal(_rowInAction_Deleted, dt.Rows[4]);
- Assert.Equal(_rowAction_Deleting, DataRowAction.Delete);
- Assert.Equal(_rowAction_Deleted, DataRowAction.Delete);
+ Assert.Equal(DataRowAction.Delete, _rowAction_Deleting);
+ Assert.Equal(DataRowAction.Delete, _rowAction_Deleted);
dt.LoadDataRow(new object[] { 5, "mono 51" }, LoadOption.OverwriteChanges);
Assert.Equal(5, dt.Rows.Count);
Assert.Equal("mono 51", dt.Rows[4][1]);
Assert.True(_rowDeleted);
Assert.Equal(_rowInAction_Deleting, dt.Rows[1]);
Assert.Equal(_rowInAction_Deleted, dt.Rows[1]);
- Assert.Equal(_rowAction_Deleting, DataRowAction.Delete);
- Assert.Equal(_rowAction_Deleted, DataRowAction.Delete);
+ Assert.Equal(DataRowAction.Delete, _rowAction_Deleting);
+ Assert.Equal(DataRowAction.Delete, _rowAction_Deleted);
dt.LoadDataRow(new object[] { 2, "mono deleted" }, LoadOption.PreserveChanges);
Assert.Equal(5, dt.Rows.Count);
Assert.Equal("mono deleted", dt.Rows[1][1, DataRowVersion.Original]);
Assert.Equal(dr["String1"], dt.Columns["String1"].DefaultValue);
// LoadDataRow(update1) - check column String2
- Assert.Equal(dr["String2"], "Changed");
+ Assert.Equal("Changed", dr["String2"]);
// LoadDataRow(update1) - check row state
Assert.Equal(DataRowState.Modified, dr.RowState);
another_new_row[0] = "9";
another_new_row[1] = "10";
- Assert.Equal(dv[2][0], "9");
+ Assert.Equal("9", dv[2][0]);
//This should not throw a System.Data.VersionNotFoundException: "There is no proposed data to access"
- Assert.Equal(dv[1][0], "7");
+ Assert.Equal("7", dv[1][0]);
}
[Fact]
SqlBytes bytes = new SqlBytes();
try
{
- Assert.Equal(bytes[0], 0);
+ Assert.Equal(0, bytes[0]);
Assert.False(true);
}
catch (Exception ex)
bytes = new SqlBytes(b);
try
{
- Assert.Equal(bytes[0], 0);
+ Assert.Equal(0, bytes[0]);
Assert.False(true);
}
catch (Exception ex)
}
b = new byte[10];
bytes = new SqlBytes(b);
- Assert.Equal(bytes[0], 0);
+ Assert.Equal(0, bytes[0]);
try
{
- Assert.Equal(bytes[-1], 0);
+ Assert.Equal(0, bytes[-1]);
Assert.False(true);
}
catch (Exception ex)
}
try
{
- Assert.Equal(bytes[10], 0);
+ Assert.Equal(0, bytes[10]);
Assert.False(true);
}
catch (Exception ex)
SqlBytes bytes = new SqlBytes();
try
{
- Assert.Equal(bytes.Length, 0);
+ Assert.Equal(0, bytes.Length);
Assert.False(true);
}
catch (Exception ex)
bytes = new SqlBytes(b);
try
{
- Assert.Equal(bytes.Length, 0);
+ Assert.Equal(0, bytes.Length);
Assert.False(true);
}
catch (Exception ex)
}
b = new byte[10];
bytes = new SqlBytes(b);
- Assert.Equal(bytes.Length, 10);
+ Assert.Equal(10, bytes.Length);
}
[Fact]
public void SqlBytesMaxLength()
Assert.Equal(bytes.MaxLength, -1);
b = new byte[10];
bytes = new SqlBytes(b);
- Assert.Equal(bytes.MaxLength, 10);
+ Assert.Equal(10, bytes.MaxLength);
}
[Fact]
public void SqlBytesNull()
{
byte[] b = null;
SqlBytes bytes = SqlBytes.Null;
- Assert.Equal(bytes.IsNull, true);
+ Assert.True(bytes.IsNull);
}
[Fact]
public void SqlBytesStorage()
SqlBytes bytes = new SqlBytes();
try
{
- Assert.Equal(bytes.Storage, StorageState.Buffer);
+ Assert.Equal(StorageState.Buffer, bytes.Storage);
Assert.False(true);
}
catch (Exception ex)
bytes = new SqlBytes(b);
try
{
- Assert.Equal(bytes.Storage, StorageState.Buffer);
+ Assert.Equal(StorageState.Buffer, bytes.Storage);
Assert.False(true);
}
catch (Exception ex)
}
b = new byte[10];
bytes = new SqlBytes(b);
- Assert.Equal(bytes.Storage, StorageState.Buffer);
+ Assert.Equal(StorageState.Buffer, bytes.Storage);
FileStream fs = null;
bytes = new SqlBytes(fs);
try
{
- Assert.Equal(bytes.Storage, StorageState.Buffer);
+ Assert.Equal(StorageState.Buffer, bytes.Storage);
Assert.False(true);
}
catch (Exception ex)
byte[] b2 = bytes.Value;
Assert.Equal(b1[0], b2[0]);
b2[0] = 10;
- Assert.Equal(b1[0], 0);
- Assert.Equal(b2[0], 10);
+ Assert.Equal(0, b1[0]);
+ Assert.Equal(10, b2[0]);
}
[Fact]
public void SqlBytesSetLength()
Assert.Equal(typeof(SqlTypeException), ex.GetType());
}
bytes = new SqlBytes(b1);
- Assert.Equal(bytes.Length, 10);
+ Assert.Equal(10, bytes.Length);
try
{
bytes.SetLength(-1);
Assert.Equal(typeof(ArgumentOutOfRangeException), ex.GetType());
}
bytes.SetLength(2);
- Assert.Equal(bytes.Length, 2);
+ Assert.Equal(2, bytes.Length);
}
[Fact]
public void SqlBytesSetNull()
{
byte[] b1 = new byte[10];
SqlBytes bytes = new SqlBytes(b1);
- Assert.Equal(bytes.Length, 10);
+ Assert.Equal(10, bytes.Length);
bytes.SetNull();
try
{
- Assert.Equal(bytes.Length, 10);
+ Assert.Equal(10, bytes.Length);
Assert.False(true);
}
catch (Exception ex)
SqlChars chars = new SqlChars();
try
{
- Assert.Equal(chars[0], 0);
+ Assert.Equal(0, chars[0]);
Assert.False(true);
}
catch (Exception ex)
chars = new SqlChars(b);
try
{
- Assert.Equal(chars[0], 0);
+ Assert.Equal(0, chars[0]);
Assert.False(true);
}
catch (Exception ex)
}
b = new char[10];
chars = new SqlChars(b);
- Assert.Equal(chars[0], 0);
+ Assert.Equal(0, chars[0]);
try
{
- Assert.Equal(chars[-1], 0);
+ Assert.Equal(0, chars[-1]);
Assert.False(true);
}
catch (Exception ex)
}
try
{
- Assert.Equal(chars[10], 0);
+ Assert.Equal(0, chars[10]);
Assert.False(true);
}
catch (Exception ex)
SqlChars chars = new SqlChars();
try
{
- Assert.Equal(chars.Length, 0);
+ Assert.Equal(0, chars.Length);
Assert.False(true);
}
catch (Exception ex)
chars = new SqlChars(b);
try
{
- Assert.Equal(chars.Length, 0);
+ Assert.Equal(0, chars.Length);
Assert.False(true);
}
catch (Exception ex)
}
b = new char[10];
chars = new SqlChars(b);
- Assert.Equal(chars.Length, 10);
+ Assert.Equal(10, chars.Length);
}
[Fact]
Assert.Equal(chars.MaxLength, -1);
b = new char[10];
chars = new SqlChars(b);
- Assert.Equal(chars.MaxLength, 10);
+ Assert.Equal(10, chars.MaxLength);
}
[Fact]
{
char[] b = null;
SqlChars chars = SqlChars.Null;
- Assert.Equal(chars.IsNull, true);
+ Assert.True(chars.IsNull);
}
[Fact]
SqlChars chars = new SqlChars();
try
{
- Assert.Equal(chars.Storage, StorageState.Buffer);
+ Assert.Equal(StorageState.Buffer, chars.Storage);
Assert.False(true);
}
catch (Exception ex)
chars = new SqlChars(b);
try
{
- Assert.Equal(chars.Storage, StorageState.Buffer);
+ Assert.Equal(StorageState.Buffer, chars.Storage);
Assert.False(true);
}
catch (Exception ex)
}
b = new char[10];
chars = new SqlChars(b);
- Assert.Equal(chars.Storage, StorageState.Buffer);
+ Assert.Equal(StorageState.Buffer, chars.Storage);
}
[Fact]
char[] b2 = chars.Value;
Assert.Equal(b1[0], b2[0]);
b2[0] = '1';
- Assert.Equal(b1[0], 0);
- Assert.Equal(b2[0], '1');
+ Assert.Equal(0, b1[0]);
+ Assert.Equal('1', b2[0]);
}
[Fact]
Assert.Equal(typeof(SqlTypeException), ex.GetType());
}
chars = new SqlChars(b1);
- Assert.Equal(chars.Length, 10);
+ Assert.Equal(10, chars.Length);
try
{
chars.SetLength(-1);
Assert.Equal(typeof(ArgumentOutOfRangeException), ex.GetType());
}
chars.SetLength(2);
- Assert.Equal(chars.Length, 2);
+ Assert.Equal(2, chars.Length);
}
[Fact]
{
char[] b1 = new char[10];
SqlChars chars = new SqlChars(b1);
- Assert.Equal(chars.Length, 10);
+ Assert.Equal(10, chars.Length);
chars.SetNull();
try
{
- Assert.Equal(chars.Length, 10);
+ Assert.Equal(10, chars.Length);
Assert.False(true);
}
catch (Exception ex)
public void Create()
{
SqlInt32 foo = new SqlInt32(5);
- Assert.Equal((int)foo, 5);
+ Assert.Equal(5, (int)foo);
}
[Fact]
// Case 7: Test non-null conversion to SqlDecimal
x = new SqlInt32(27);
- Assert.Equal(x.ToSqlDecimal().Value, 27);
+ Assert.Equal(27, x.ToSqlDecimal().Value);
// Case 8: SqlInt32.Null -> SqlDouble == SqlDouble.Null
x = SqlInt32.Null;
// Case 9: Test non-null conversion to SqlDouble
x = new SqlInt32(27);
- Assert.Equal(x.ToSqlDouble().Value, 27);
+ Assert.Equal(27, x.ToSqlDouble().Value);
// Case 10: SqlInt32.Null -> SqlInt16 == SqlInt16.Null
x = SqlInt32.Null;
// Case 13: Test non-null conversion to SqlInt64
x = new SqlInt32(27);
- Assert.Equal(x.ToSqlInt64().Value, 27);
+ Assert.Equal(27, x.ToSqlInt64().Value);
// Case 14: SqlInt32.Null -> SqlMoney == SqlMoney.Null
x = SqlInt32.Null;
// Case 15: Test non-null conversion to SqlMoney
x = new SqlInt32(27);
- Assert.Equal(x.ToSqlMoney().Value, 27.0000M);
+ Assert.Equal(27.0000M, x.ToSqlMoney().Value);
// Case 16: SqlInt32.Null -> SqlSingle == SqlSingle.Null
x = SqlInt32.Null;
// Case 17: Test non-null conversion to SqlSingle
x = new SqlInt32(27);
- Assert.Equal(x.ToSqlSingle().Value, 27);
+ Assert.Equal(27, x.ToSqlSingle().Value);
}
[Fact]
command.CommandText = "select 1";
command.CommandTimeout = 45;
command.ResetCommandTimeout();
- Assert.Equal(command.CommandTimeout, 30);
+ Assert.Equal(30, command.CommandTimeout);
command.CommandType = CommandType.Text;
SqlParameter parameter = command.CreateParameter();
var cmd = new SqlCommand("select @input", conn);
cmd.Parameters.AddWithValue("@input", MyEnum.B);
object value = cmd.ExecuteScalar();
- Assert.Equal((MyEnum)value, MyEnum.B);
+ Assert.Equal(MyEnum.B, (MyEnum)value);
}
}
cmd.ExecuteNonQuery();
- Assert.Equal((MyEnum)outputParam.Value, MyEnum.B);
+ Assert.Equal(MyEnum.B, (MyEnum)outputParam.Value);
}
}
int count = 0;
while (reader.Read()) { count++; }
Assert.True(count == 1, "Error: incorrect number of rows in table after update.");
- Assert.Equal(count, 1);
+ Assert.Equal(1, count);
}
}
}
Assert.False(reader.HasRows, "Error Rollback Test : incorrect number of rows in table after rollback.");
int count = 0;
while (reader.Read()) count++;
- Assert.Equal(count, 0);
+ Assert.Equal(0, count);
}
connection.Close();
Assert.True(reader.HasRows, "Error Scoped Transaction Test : incorrect number of rows in table after rollback to save state one.");
int count = 0;
while (reader.Read()) count++;
- Assert.Equal(count, 1);
+ Assert.Equal(1, count);
}
tx.Rollback();
// Validate Microsoft.SqlServer.Types.SqlHierarchyId, Microsoft.SqlServer.Types, Version=11.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91
column = columns[0];
- Assert.Equal(column.ColumnName, "col0");
+ Assert.Equal("col0", column.ColumnName);
Assert.True(column.DataTypeName.EndsWith(".hierarchyid"), $"Unexpected DataTypeName \"{column.DataTypeName}\"");
Assert.NotNull(column.UdtAssemblyQualifiedName);
AssertSqlUdtAssemblyQualifiedName(column.UdtAssemblyQualifiedName, "Microsoft.SqlServer.Types.SqlHierarchyId");
// Validate Microsoft.SqlServer.Types.SqlGeometry, Microsoft.SqlServer.Types, Version = 11.0.0.0, Culture = neutral, PublicKeyToken = 89845dcd8080cc91
column = columns[1];
- Assert.Equal(column.ColumnName, "col1");
+ Assert.Equal("col1", column.ColumnName);
Assert.True(column.DataTypeName.EndsWith(".geometry"), $"Unexpected DataTypeName \"{column.DataTypeName}\"");
Assert.NotNull(column.UdtAssemblyQualifiedName);
AssertSqlUdtAssemblyQualifiedName(column.UdtAssemblyQualifiedName, "Microsoft.SqlServer.Types.SqlGeometry");
// Validate Microsoft.SqlServer.Types.SqlGeography, Microsoft.SqlServer.Types, Version = 11.0.0.0, Culture = neutral, PublicKeyToken = 89845dcd8080cc91
column = columns[2];
- Assert.Equal(column.ColumnName, "col2");
+ Assert.Equal("col2", column.ColumnName);
Assert.True(column.DataTypeName.EndsWith(".geography"), $"Unexpected DataTypeName \"{column.DataTypeName}\"");
Assert.NotNull(column.UdtAssemblyQualifiedName);
AssertSqlUdtAssemblyQualifiedName(column.UdtAssemblyQualifiedName, "Microsoft.SqlServer.Types.SqlGeography");
using (SqlDataReader rdr = cmd.ExecuteReader())
{
rdr.Read();
- Assert.Equal(rdr.FieldCount, 1);
+ Assert.Equal(1, rdr.FieldCount);
Assert.Equal(rdr.GetName(0), COLUMN_NAME_2);
}
break;
cmd.Transaction = con.BeginTransaction();
cmd.CommandText = "select @@trancount";
int tranCount = (int)cmd.ExecuteScalar();
- Assert.Equal(tranCount, 1);
+ Assert.Equal(1, tranCount);
break;
}
}
{
cmd.CommandText = "select @@trancount";
int tranCount = (int)cmd.ExecuteScalar();
- Assert.Equal(tranCount, 0);
+ Assert.Equal(0, tranCount);
}
}
}
Assert.Equal(arguments, observer.EventObject);
Assert.NotNull(observer.Activity);
- Assert.NotEqual(activity.StartTimeUtc, default(DateTime));
+ Assert.NotEqual(default(DateTime), activity.StartTimeUtc);
Assert.Equal(TimeSpan.Zero, observer.Activity.Duration);
observer.Reset();
// add two new subscribers
using (var listener1 = new DiagnosticListener("TestListen1"))
{
- Assert.Equal(listener1.Name, "TestListen1");
+ Assert.Equal("TestListen1", listener1.Name);
Assert.Equal(listener1, returnedListener);
returnedListener = null;
using (var listener2 = new DiagnosticListener("TestListen2"))
{
- Assert.Equal(listener2.Name, "TestListen2");
+ Assert.Equal("TestListen2", listener2.Name);
Assert.Equal(listener2, returnedListener);
returnedListener = null;
} // Dispose of listener2
"An unexpected event of name " + pair.Key + "was received");
WebRequest request = ReadPublicProperty<WebRequest>(eventFields, "Request");
- Assert.Equal(request.GetType().Name, "HttpWebRequest");
+ Assert.Equal("HttpWebRequest", request.GetType().Name);
if (pair.Key == "System.Net.Http.Desktop.HttpRequestOut.Start")
{
{
// This must be the response.
WebResponse response = ReadPublicProperty<WebResponse>(eventFields, "Response");
- Assert.Equal(response.GetType().Name, "HttpWebResponse");
+ Assert.Equal("HttpWebResponse", response.GetType().Name);
// By the time we see the response, the request object may already have been redirected with a different
// url. Hence, it's not reliable to just look up requestData by the URL/hostname. Instead, we have to look
[PlatformSpecific(TestPlatforms.Linux)] // test relies on xdg-open
public void ProcessStart_UseShellExecute_OnUnix_DocumentFile_IgnoresArguments()
{
- Assert.Equal(s_allowedProgramsToRun[0], "xdg-open");
+ Assert.Equal("xdg-open", s_allowedProgramsToRun[0]);
if (!IsProgramInstalled("xdg-open"))
{
ProcessPriorityClass priorityClass = _process.PriorityClass;
_process.PriorityClass = ProcessPriorityClass.Idle;
- Assert.Equal(_process.PriorityClass, ProcessPriorityClass.Idle);
+ Assert.Equal(ProcessPriorityClass.Idle, _process.PriorityClass);
try
{
_process.PriorityClass = ProcessPriorityClass.High;
- Assert.Equal(_process.PriorityClass, ProcessPriorityClass.High);
+ Assert.Equal(ProcessPriorityClass.High, _process.PriorityClass);
_process.PriorityClass = ProcessPriorityClass.Normal;
- Assert.Equal(_process.PriorityClass, ProcessPriorityClass.Normal);
+ Assert.Equal(ProcessPriorityClass.Normal, _process.PriorityClass);
_process.PriorityClass = priorityClass;
}
try
{
_process.PriorityClass = ProcessPriorityClass.High;
- Assert.Equal(_process.PriorityClass, ProcessPriorityClass.High);
+ Assert.Equal(ProcessPriorityClass.High, _process.PriorityClass);
_process.PriorityClass = ProcessPriorityClass.Normal;
- Assert.Equal(_process.PriorityClass, ProcessPriorityClass.Normal);
+ Assert.Equal(ProcessPriorityClass.Normal, _process.PriorityClass);
}
finally
{
{
if (data.ProviderName == "TestHarnessEventSource")
{
- Assert.Equal(data.EventName, "StartTest");
+ Assert.Equal("StartTest", data.EventName);
int testNumber = (int)data.PayloadValue(1, "testNumber");
Assert.Equal(expectedTestNumber, testNumber);
else
{
// we only expect exactly one reply
- Assert.Equal(replies.Count, 1);
+ Assert.Equal(1, replies.Count);
currentTest.EventValidator(replies[0]);
}
}
}
EventTestHarness.LogWriteLine("Validating: Count={0} RequestSum={1:n3} TimeSum={2:n3} ", evts.Count, requestSum, timeSum);
- Assert.Equal(requestCount, 5);
- Assert.Equal(requestSum, 31);
- Assert.Equal(requestMin, 1);
- Assert.Equal(requestMax, 16);
+ Assert.Equal(5, requestCount);
+ Assert.Equal(31, requestSum);
+ Assert.Equal(1, requestMin);
+ Assert.Equal(16, requestMax);
- Assert.Equal(errorCount, 2);
- Assert.Equal(errorSum, 2);
- Assert.Equal(errorMin, 1);
- Assert.Equal(errorMax, 1);
+ Assert.Equal(2, errorCount);
+ Assert.Equal(2, errorSum);
+ Assert.Equal(1, errorMin);
+ Assert.Equal(1, errorMax);
Assert.True(.4 < timeSum, $"FAILURE: .4 < {timeSum}"); // We should have at least 400 msec
Assert.True(timeSum < 2, $"FAILURE: {timeSum} < 2"); // But well under 2 sec.
using (var mySource = new ContractEventSourceWithTraits())
{
// By default we are self-describing.
- Assert.Equal(mySource.Settings, EventSourceSettings.EtwSelfDescribingEventFormat);
- Assert.Equal(mySource.GetTrait("MyTrait"), "MyTraitValue");
- Assert.Equal(mySource.GetTrait("ETW_GROUP"), "{4f50731a-89cf-4782-b3e0-dce8c90476ba}");
- Assert.Equal(mySource.GetTrait("ETW_2"), "#01 02 03 04");
- Assert.Equal(mySource.GetTrait("ETW_3"), "@Hello");
+ Assert.Equal(EventSourceSettings.EtwSelfDescribingEventFormat, mySource.Settings);
+ Assert.Equal("MyTraitValue", mySource.GetTrait("MyTrait"));
+ Assert.Equal("{4f50731a-89cf-4782-b3e0-dce8c90476ba}", mySource.GetTrait("ETW_GROUP"));
+ Assert.Equal("#01 02 03 04", mySource.GetTrait("ETW_2"));
+ Assert.Equal("@Hello", mySource.GetTrait("ETW_3"));
}
TestUtilities.CheckNoEventSourcesRunning("Stop");
}
"ETW_GROUP", "{4f50731a-89cf-4782-b3e0-dce8c90476ba}"))
{
// By default we are self-describing.
- Assert.Equal(mySource.Settings, EventSourceSettings.EtwSelfDescribingEventFormat);
- Assert.Equal(mySource.GetTrait("MyTrait"), "MyTraitValue");
- Assert.Equal(mySource.GetTrait("ETW_GROUP"), "{4f50731a-89cf-4782-b3e0-dce8c90476ba}");
+ Assert.Equal(EventSourceSettings.EtwSelfDescribingEventFormat, mySource.Settings);
+ Assert.Equal("MyTraitValue", mySource.GetTrait("MyTrait"));
+ Assert.Equal("{4f50731a-89cf-4782-b3e0-dce8c90476ba}", mySource.GetTrait("ETW_GROUP"));
}
TestUtilities.CheckNoEventSourcesRunning("Stop");
}
listener.Dispose();
// Confirm that we get exactly one event from this whole process, that has the error message we expect.
- Assert.Equal(events.Count, 1);
+ Assert.Equal(1, events.Count);
Event _event = events[0];
Assert.Equal("EventSourceMessage", _event.EventName);
listener.Dispose();
// Confirm that we get exactly one event from this whole process, that has the error message we expect.
- Assert.Equal(events.Count, 1);
+ Assert.Equal(1, events.Count);
Event _event = events[0];
Assert.Equal("EventSourceMessage", _event.EventName);
string message = _event.PayloadString(0, "message");
bes.RelatedActivity(newGuid2, "Hello", 42, "AA", "BB");
// Confirm that we get exactly one event from this whole process, that has the error message we expect.
- Assert.Equal(events.Count, 1);
+ Assert.Equal(1, events.Count);
Event _event = events[0];
Assert.Equal("EventSourceMessage", _event.EventName);
string message = _event.PayloadString(0, "message");
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EmbeddedNullStringEvent", evt.EventName);
- Assert.Equal(evt.PayloadValue(0, "a"), "Hello");
- Assert.Equal(evt.PayloadValue(1, "b"), "");
+ Assert.Equal("Hello", evt.PayloadValue(0, "a"));
+ Assert.Equal("", evt.PayloadValue(1, "b"));
}));
}
}
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("Greeting", evt.EventName);
- Assert.Equal(evt.PayloadValue(0, "msg"), "Hello, world!");
+ Assert.Equal("Hello, world!", evt.PayloadValue(0, "msg"));
}));
/*************************************************************************/
decimal myMoney = 300;
var structValue = evt.PayloadValue(0, "PartB_UserInfo");
var structValueAsDictionary = structValue as IDictionary<string, object>;
Assert.NotNull(structValueAsDictionary);
- Assert.Equal(structValueAsDictionary["UserName"], "Someone Else");
+ Assert.Equal("Someone Else", structValueAsDictionary["UserName"]);
}));
/*************************************************************************/
var structValue = evt.PayloadValue(0, "PartB_UserInfo");
var structValueAsDictionary = structValue as IDictionary<string, object>;
Assert.NotNull(structValueAsDictionary);
- Assert.Equal(structValueAsDictionary["UserName"], "Myself");
+ Assert.Equal("Myself", structValueAsDictionary["UserName"]);
- Assert.Equal(evt.PayloadValue(1, "msec"), 10);
+ Assert.Equal(10, evt.PayloadValue(1, "msec"));
}));
/*************************************************************************/
var keyValues = evt.PayloadValue(0, "myDict");
IDictionary<string, object> vDict = GetDictionaryFromKeyValueArray(keyValues);
- Assert.Equal(vDict["elem1"], "10");
- Assert.Equal(vDict["elem2"], "20");
- Assert.Equal(evt.PayloadValue(1, "s"), "end");
+ Assert.Equal("10", vDict["elem1"]);
+ Assert.Equal("20", vDict["elem2"]);
+ Assert.Equal("end", evt.PayloadValue(1, "s"));
}));
/*************************************************************************/
tests.Add(new SubTest("Write/Dict/EventWithStringDict_BC",
var structValue = evt.PayloadValue(0, "PartB_UserInfo");
var structValueAsDictionary = structValue as IDictionary<string, object>;
Assert.NotNull(structValueAsDictionary);
- Assert.Equal(structValueAsDictionary["UserName"], "Me");
- Assert.Equal(structValueAsDictionary["LogTime"], "Now");
+ Assert.Equal("Me", structValueAsDictionary["UserName"]);
+ Assert.Equal("Now", structValueAsDictionary["LogTime"]);
var keyValues = evt.PayloadValue(1, "PartC_Dict");
var vDict = GetDictionaryFromKeyValueArray(keyValues);
Assert.NotNull(dict);
- Assert.Equal(vDict["elem1"], "10"); // string values.
- Assert.Equal(vDict["elem2"], "20");
+ Assert.Equal("10", vDict["elem1"]); // string values.
+ Assert.Equal("20", vDict["elem2"]);
- Assert.Equal(evt.PayloadValue(2, "s"), "end");
+ Assert.Equal("end", evt.PayloadValue(2, "s"));
}));
/*************************************************************************/
tests.Add(new SubTest("Write/Dict/EventWithIntDict_BC",
var structValue = evt.PayloadValue(0, "PartB_UserInfo");
var structValueAsDictionary = structValue as IDictionary<string, object>;
Assert.NotNull(structValueAsDictionary);
- Assert.Equal(structValueAsDictionary["UserName"], "Me");
- Assert.Equal(structValueAsDictionary["LogTime"], "Now");
+ Assert.Equal("Me", structValueAsDictionary["UserName"]);
+ Assert.Equal("Now", structValueAsDictionary["LogTime"]);
var keyValues = evt.PayloadValue(1, "PartC_Dict");
var vDict = GetDictionaryFromKeyValueArray(keyValues);
Assert.NotNull(vDict);
- Assert.Equal(vDict["elem1"], 10); // Notice they are integers, not strings.
- Assert.Equal(vDict["elem2"], 20);
+ Assert.Equal(10, vDict["elem1"]); // Notice they are integers, not strings.
+ Assert.Equal(20, vDict["elem2"]);
- Assert.Equal(evt.PayloadValue(2, "s"), "end");
+ Assert.Equal("end", evt.PayloadValue(2, "s"));
}));
/*************************************************************************/
/**************************** Empty Event TESTING ************************/
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("OptionsEvent", evt.EventName);
- Assert.Equal(evt.PayloadValue(0, "OptionsEvent"), "test options!");
+ Assert.Equal("test options!", evt.PayloadValue(0, "OptionsEvent"));
}));
tests.Add(new SubTest("Write/Basic/WriteOfTWithRefOptios",
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("RefOptionsEvent", evt.EventName);
- Assert.Equal(evt.PayloadValue(0, "OptionsEvent"), "test ref options!");
+ Assert.Equal("test ref options!", evt.PayloadValue(0, "OptionsEvent"));
}));
tests.Add(new SubTest("Write/Basic/WriteOfTWithNullString",
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("NullStringEvent", evt.EventName);
- Assert.Equal(evt.PayloadValue(0, "a"), "");
- Assert.Equal(evt.PayloadValue(1, "b"), "");
+ Assert.Equal("", evt.PayloadValue(0, "a"));
+ Assert.Equal("", evt.PayloadValue(1, "b"));
}));
// This test only applies to ETW and will fail on EventListeners due to different behavior
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("ActivityEvent", evt.EventName);
- Assert.Equal(evt.PayloadValue(0, "ActivityMsg"), "test activity!");
+ Assert.Equal("test activity!", evt.PayloadValue(0, "ActivityMsg"));
}));
}
}
- Assert.Equal(events.Count, 1);
+ Assert.Equal(1, events.Count);
Event _event = events[0];
Assert.Equal("MyTestEvent", _event.EventName);
Assert.Equal(3, (int)_event.PayloadValue(0, "arg1"));
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EnumEvent" + subTestName, evt.EventName);
- Assert.Equal(evt.PayloadValue(0, "b"), "start");
+ Assert.Equal("start", evt.PayloadValue(0, "b"));
if (evt.IsEtw)
{
var value = evt.PayloadValue(1, "v");
{
Assert.Equal(evt.PayloadValue(1, "v"), enumValue);
}
- Assert.Equal(evt.PayloadValue(2, "s"), "end");
+ Assert.Equal("end", evt.PayloadValue(2, "s"));
}));
}
foreach (var item in asArray)
{
var keyValue = item as IDictionary<string, object>;
- Assert.Equal(keyValue.Count, 2);
+ Assert.Equal(2, keyValue.Count);
ret.Add((string)keyValue["Key"], keyValue["Value"]);
}
return ret;
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventII", evt.EventName);
- Assert.Equal(evt.PayloadValue(0, "arg1"), 10);
- Assert.Equal(evt.PayloadValue(1, "arg2"), 11);
+ Assert.Equal(10, evt.PayloadValue(0, "arg1"));
+ Assert.Equal(11, evt.PayloadValue(1, "arg2"));
}));
/*************************************************************************/
tests.Add(new SubTest("WriteEvent/Basic/EventSS",
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventSS", evt.EventName);
- Assert.Equal(evt.PayloadValue(0, "arg1"), "one");
- Assert.Equal(evt.PayloadValue(1, "arg2"), "two");
+ Assert.Equal("one", evt.PayloadValue(0, "arg1"));
+ Assert.Equal("two", evt.PayloadValue(1, "arg2"));
}));
/*************************************************************************/
tests.Add(new SubTest("Write/Basic/EventWith7Strings",
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventWithIntIntString", evt.EventName);
- Assert.Equal(evt.PayloadValue(0, "i1"), 10);
- Assert.Equal(evt.PayloadValue(1, "i2"), 11);
- Assert.Equal(evt.PayloadValue(2, "str"), "test");
+ Assert.Equal(10, evt.PayloadValue(0, "i1"));
+ Assert.Equal(11, evt.PayloadValue(1, "i2"));
+ Assert.Equal("test", evt.PayloadValue(2, "str"));
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithIntLongString",
{
Assert.Equal(logger.Name, evt.ProviderName);
Assert.Equal("EventWithIntLongString", evt.EventName);
- Assert.Equal(evt.PayloadValue(0, "i1"), 10);
+ Assert.Equal(10, evt.PayloadValue(0, "i1"));
Assert.Equal(evt.PayloadValue(1, "l1"), (long)11);
- Assert.Equal(evt.PayloadValue(2, "str"), "test");
+ Assert.Equal("test", evt.PayloadValue(2, "str"));
}));
tests.Add(new SubTest("WriteEvent/Basic/EventWithString",
{
// we expect to get top only entries
string s = (string) child.Properties["objectClass"][0];
- Assert.Equal(s, "top", StringComparer.OrdinalIgnoreCase);
+ Assert.Equal("top", s, StringComparer.OrdinalIgnoreCase);
newTopClassCount += 1;
}
Assert.Equal(0, types[0]);
Assert.Equal(0, types[2]);
- Assert.Equal((types[path.PointCount - 3] & 128), 128);
+ Assert.Equal(128, (types[path.PointCount - 3] & 128));
Assert.Equal(0, types[path.PointCount - 2]);
Assert.Equal(1, types[path.PointCount - 1]);
}
AssertExtensions.GreaterThanOrEqualTo(flat.PointCount, original.PointCount);
for (int i = 0; i < flat.PointCount; i++)
{
- Assert.NotEqual(flat.PathTypes[i], 3);
+ Assert.NotEqual(3, flat.PathTypes[i]);
}
}
{
if (yearHasLeapMonth > 0)
{
- Assert.NotEqual(calendar.GetLeapMonth(yearHasLeapMonth), 0);
+ Assert.NotEqual(0, calendar.GetLeapMonth(yearHasLeapMonth));
Assert.Equal(0, calendar.GetLeapMonth(yearHasLeapMonth - 1));
}
else
// Windows and OSX always throw exception. some versions of Linux succeed and others throw exception
Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.Windows));
Assert.False(RuntimeInformation.IsOSPlatform(OSPlatform.OSX));
- Assert.Equal(result, ".");
+ Assert.Equal(".", result);
}
else
{
[Fact]
public static void DigitsDecimalTest()
{
- Assert.Equal(s_numericsCodepoints.Length % 10, 0);
+ Assert.Equal(0, s_numericsCodepoints.Length % 10);
for (int i=0; i < s_numericsCodepoints.Length; i+= 10)
{
for (int j=0; j < 10; j++)
Assert.Equal(1, rules.Count);
CustomAccessRule rule = (CustomAccessRule)rules[0];
// Should be users group
- Assert.Equal(rule.IdentityReference.Value, "S-1-5-32-545");
+ Assert.Equal("S-1-5-32-545", rule.IdentityReference.Value);
Assert.Equal(AccessControlType.Allow, rule.AccessControlType);
Assert.Equal(InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, rule.InheritanceFlags);
Assert.Equal(0x1200a9, rule.AccessMaskValue);
{
var auditRule = new FileSystemAuditRule(Helpers.s_WorldSidNTAccount, FileSystemRights.ReadData, AuditFlags.Failure);
Assert.Equal(auditRule.IdentityReference, Helpers.s_WorldSidNTAccount);
- Assert.Equal(auditRule.FileSystemRights, FileSystemRights.ReadData);
- Assert.Equal(auditRule.AuditFlags, AuditFlags.Failure);
+ Assert.Equal(FileSystemRights.ReadData, auditRule.FileSystemRights);
+ Assert.Equal(AuditFlags.Failure, auditRule.AuditFlags);
}
[Fact]
{
var auditRule = new FileSystemAuditRule(@"MYDOMAIN\MyAccount", FileSystemRights.ReadData,
InheritanceFlags.ObjectInherit, PropagationFlags.InheritOnly, AuditFlags.Failure);
- Assert.Equal(auditRule.PropagationFlags, PropagationFlags.InheritOnly);
- Assert.Equal(auditRule.InheritanceFlags, InheritanceFlags.ObjectInherit);
+ Assert.Equal(PropagationFlags.InheritOnly, auditRule.PropagationFlags);
+ Assert.Equal(InheritanceFlags.ObjectInherit, auditRule.InheritanceFlags);
}
[Fact]
public void ObjectInitialization_Identity_FileSystemRights_AuditFlags_Success()
{
var auditRule = new FileSystemAuditRule(@"MYDOMAIN\MyAccount", FileSystemRights.ReadData, AuditFlags.Failure);
- Assert.Equal(auditRule.FileSystemRights, FileSystemRights.ReadData);
- Assert.Equal(auditRule.AuditFlags, AuditFlags.Failure);
- Assert.Equal(auditRule.IdentityReference.Value, @"MYDOMAIN\MyAccount");
+ Assert.Equal(FileSystemRights.ReadData, auditRule.FileSystemRights);
+ Assert.Equal(AuditFlags.Failure, auditRule.AuditFlags);
+ Assert.Equal(@"MYDOMAIN\MyAccount", auditRule.IdentityReference.Value);
}
[Fact]
{
var auditRule = new FileSystemAuditRule(@"MYDOMAIN\MyAccount", FileSystemRights.ReadData, AuditFlags.Failure);
FileSystemRights fileSystemRights = auditRule.FileSystemRights;
- Assert.Equal(fileSystemRights, FileSystemRights.ReadData);
+ Assert.Equal(FileSystemRights.ReadData, fileSystemRights);
}
}
}
// Test Invalid drive
var invalidDrive = new DriveInfo(GetInvalidDriveLettersOnMachine().First().ToString());
- Assert.Equal(invalidDrive.DriveType, DriveType.NoRootDirectory);
+ Assert.Equal(DriveType.NoRootDirectory, invalidDrive.DriveType);
}
[Fact]
private IEnumerable<char> GetValidDriveLettersOnMachine()
{
uint mask = (uint)GetLogicalDrives();
- Assert.NotEqual<uint>(mask, 0);
+ Assert.NotEqual<uint>(0, mask);
var bits = new BitArray(new int[] { (int)mask });
for (int i = 0; i < bits.Length; i++)
private IEnumerable<char> GetInvalidDriveLettersOnMachine()
{
uint mask = (uint)GetLogicalDrives();
- Assert.NotEqual<uint>(mask, 0);
+ Assert.NotEqual<uint>(0, mask);
var bits = new BitArray(new int[] { (int)mask });
for (int i = 0; i < bits.Length; i++)
using (Stream partStream = mainPart.GetStream(FileMode.OpenOrCreate, FileAccess.Read))
{
var len = partStream.Length;
- Assert.Equal(len, 2142);
+ Assert.Equal(2142, len);
}
}
}
{
var rootUri = new Uri("/", UriKind.Relative);
var rootRelationshipPartUri = PackUriHelper.GetRelationshipPartUri(rootUri);
- Assert.Equal(rootRelationshipPartUri.ToString(), "/_rels/.rels");
+ Assert.Equal("/_rels/.rels", rootRelationshipPartUri.ToString());
PackageRelationship docPackageRelationship =
package
docPackageRelationship.TargetUri);
var docRelationshipPartUri = PackUriHelper.GetRelationshipPartUri(documentUri);
- Assert.Equal(docRelationshipPartUri.ToString(), "/word/_rels/document.xml.rels");
+ Assert.Equal("/word/_rels/document.xml.rels", docRelationshipPartUri.ToString());
}
}
}
Assert.Throws<ArgumentNullException>(() => PackUriHelper.GetRelativeUri(null, stylesUri));
Assert.Throws<ArgumentNullException>(() => PackUriHelper.GetRelativeUri(documentUri, null));
var relativeUri = PackUriHelper.GetRelativeUri(documentUri, stylesUri);
- Assert.Equal(relativeUri.ToString(), "styles.xml");
+ Assert.Equal("styles.xml", relativeUri.ToString());
}
}
}
else
nonRel++;
}
- Assert.Equal(nonRel, 8);
- Assert.Equal(rel, 2);
+ Assert.Equal(8, nonRel);
+ Assert.Equal(2, rel);
}
}
}
Assert.Throws<ArgumentNullException>(() => new PackageRelationshipSelector(documentUri, PackageRelationshipSelectorType.Id, null));
PackageRelationshipSelector prs = new PackageRelationshipSelector(documentUri, PackageRelationshipSelectorType.Id, "rId1");
var cnt = prs.Select(package).Count();
- Assert.Equal(cnt, 1);
+ Assert.Equal(1, cnt);
}
}
}
var mainPartUri = new Uri("/", UriKind.Relative);
PackageRelationshipSelector prs = new PackageRelationshipSelector(mainPartUri, PackageRelationshipSelectorType.Id, "rId1");
var cnt = prs.Select(package).Count();
- Assert.Equal(cnt, 1);
+ Assert.Equal(1, cnt);
}
}
}
var mainPartUri = new Uri("/", UriKind.Relative);
PackageRelationshipSelector prs = new PackageRelationshipSelector(mainPartUri, PackageRelationshipSelectorType.Type, DocumentRelationshipType);
var cnt = prs.Select(package).Count();
- Assert.Equal(cnt, 1);
+ Assert.Equal(1, cnt);
}
}
}
var mainPartUri = new Uri("/word/document.xml", UriKind.Relative);
PackageRelationshipSelector prs = new PackageRelationshipSelector(mainPartUri, PackageRelationshipSelectorType.Type, StylesRelationshipType);
var cnt = prs.Select(package).Count();
- Assert.Equal(cnt, 1);
+ Assert.Equal(1, cnt);
}
}
}
var validCompressionOption = documentPart.CompressionOption == CompressionOption.Normal ||
documentPart.CompressionOption == CompressionOption.SuperFast;
Assert.True(validCompressionOption);
- Assert.Equal(documentPart.ContentType, "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml");
+ Assert.Equal("application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml", documentPart.ContentType);
Assert.NotNull(documentPart.Package);
- Assert.Equal(documentPart.Uri.ToString(), "/word/document.xml");
+ Assert.Equal("/word/document.xml", documentPart.Uri.ToString());
}
}
}
var mainDocumentPart = package.GetPart(documentUri);
Uri documentUri2 = new Uri("/word/document.xml", UriKind.RelativeOrAbsolute);
Assert.True(package.PartExists(documentUri));
- Assert.Equal(package.FileOpenAccess, FileAccess.ReadWrite);
+ Assert.Equal(FileAccess.ReadWrite, package.FileOpenAccess);
}
}
}
Assert.Null(pp.Category);
Assert.Null(pp.ContentStatus);
Assert.Null(pp.ContentType);
- Assert.Equal(pp.Creator, "Eric White");
- Assert.Equal(pp.Description, "");
+ Assert.Equal("Eric White", pp.Creator);
+ Assert.Equal("", pp.Description);
Assert.Null(pp.Identifier);
Assert.Null(pp.Language);
- Assert.Equal(pp.Subject, "");
- Assert.Equal(pp.Title, "");
+ Assert.Equal("", pp.Subject);
+ Assert.Equal("", pp.Title);
Assert.Null(pp.Version);
}
fiGuidName.Delete();
sb.AppendFormatComma("pp.Version: >{0}<", pp.Version);
string s = sb.ToString();
- Assert.Equal(sb.ToString().Trim(), @"pp.Category: >(null)<, pp.ContentStatus: >(null)<, pp.ContentType: >(null)<, pp.Creator: >Eric White<, pp.Description: ><, pp.Identifier: >(null)<, pp.Keywords: ><, pp.Language: >(null)<, pp.LastModifiedBy: >Eric White<, pp.LastPrinted: >(null)<, pp.Revision: >2<, pp.Subject: ><, pp.Title: ><, pp.Version: >(null)<,");
+ Assert.Equal(@"pp.Category: >(null)<, pp.ContentStatus: >(null)<, pp.ContentType: >(null)<, pp.Creator: >Eric White<, pp.Description: ><, pp.Identifier: >(null)<, pp.Keywords: ><, pp.Language: >(null)<, pp.LastModifiedBy: >Eric White<, pp.LastPrinted: >(null)<, pp.Revision: >2<, pp.Subject: ><, pp.Title: ><, pp.Version: >(null)<,", sb.ToString().Trim());
pp.Category = "Category";
pp.ContentStatus = "ContentStatus";
sb.AppendFormatComma("pp.Version: >{0}<", pp.Version);
s = sb.ToString();
- Assert.Equal(sb.ToString().Trim(), @"pp.Category: >Category<, pp.ContentStatus: >ContentStatus<, pp.ContentType: >ContentType<, pp.Creator: >Creator<, pp.Description: >Description<, pp.Identifier: >Identifier<, pp.Keywords: >Keywords<, pp.Language: >Language<, pp.LastModifiedBy: >LastModifiedBy<, pp.Revision: >Revision<, pp.Subject: >Subject<, pp.Title: >Title<, pp.Version: >Version<,");
+ Assert.Equal(@"pp.Category: >Category<, pp.ContentStatus: >ContentStatus<, pp.ContentType: >ContentType<, pp.Creator: >Creator<, pp.Description: >Description<, pp.Identifier: >Identifier<, pp.Keywords: >Keywords<, pp.Language: >Language<, pp.LastModifiedBy: >LastModifiedBy<, pp.Revision: >Revision<, pp.Subject: >Subject<, pp.Title: >Title<, pp.Version: >Version<,", sb.ToString().Trim());
}
}
using (Package package = Package.Open(fiGuidName.FullName, FileMode.Open))
using (PackageProperties pp = package.PackageProperties)
{
- Assert.Equal(pp.Category, "Test-Category");
- Assert.Equal(pp.ContentStatus, "Test-Status");
+ Assert.Equal("Test-Category", pp.Category);
+ Assert.Equal("Test-Status", pp.ContentStatus);
Assert.Null(pp.ContentType);
- Assert.Equal(pp.Creator, "Eric White");
- Assert.Equal(pp.Description, "Test-Comments");
+ Assert.Equal("Eric White", pp.Creator);
+ Assert.Equal("Test-Comments", pp.Description);
Assert.Null(pp.Identifier);
Assert.Null(pp.Language);
- Assert.Equal(pp.Subject, "Test-Subject");
- Assert.Equal(pp.Title, "Test-Title");
+ Assert.Equal("Test-Subject", pp.Subject);
+ Assert.Equal("Test-Title", pp.Title);
Assert.Null(pp.Version);
}
fiGuidName.Delete();
Assert.Null(pp.Category);
Assert.Null(pp.ContentStatus);
Assert.Null(pp.ContentType);
- Assert.Equal(pp.Creator, "Eric White");
- Assert.Equal(pp.Description, "");
+ Assert.Equal("Eric White", pp.Creator);
+ Assert.Equal("", pp.Description);
Assert.Null(pp.Identifier);
Assert.Null(pp.Language);
- Assert.Equal(pp.Subject, "");
- Assert.Equal(pp.Title, "");
+ Assert.Equal("", pp.Subject);
+ Assert.Equal("", pp.Title);
Assert.Null(pp.Version);
}
fiGuidName.Delete();
{
var parts = package.GetParts();
var numberOfParts = parts.Count();
- Assert.Equal(numberOfParts, 10);
+ Assert.Equal(10, numberOfParts);
long sumLen = 0;
foreach (var part in parts)
{
}
sumLen += len;
}
- Assert.Equal(sumLen, 44768);
+ Assert.Equal(44768, sumLen);
}
fiGuidName.Delete();
}
UmsTests.ReadUmsInvariants(stream);
var position = stream.Position;
- Assert.Equal(stream.ReadByte(), 100);
+ Assert.Equal(100, stream.ReadByte());
Assert.Equal(stream.Position, position + 1);
position = stream.Position;
buffer.Write(0, (byte)100);
var position = stream.Position;
- Assert.Equal(stream.ReadByte(), 100);
+ Assert.Equal(100, stream.ReadByte());
Assert.Equal(stream.Position, position + 1);
Assert.Equal(stream.ReadByte(), -1); // end of stream
var read = await sr.ReadAsync(chArr, 4, 3);
- Assert.Equal(read, 3);
+ Assert.Equal(3, read);
for (int i = 0; i < 3; i++)
{
Assert.Equal(baseInfo.Item1[i], chArr[i + 4]);
char[] chArr = new char[baseInfo.chArr.Length];
var read = await tr.ReadAsync(chArr, 4, 3);
- Assert.Equal(read, 3);
+ Assert.Equal(3, read);
for (int count = 0; count < 3; ++count)
{
[Fact]
public void JsonPrimitive_QuoteEscape()
{
- Assert.Equal((new JsonPrimitive("\"\"")).ToString(), "\"\\\"\\\"\"");
+ Assert.Equal("\"\\\"\\\"\"", (new JsonPrimitive("\"\"")).ToString());
}
[Fact]
Assert.Equal(0, changeCount);
dict.Add("X", 1);
Assert.Equal(1, changeCount);
- Assert.Equal(lastKey, "X");
+ Assert.Equal("X", lastKey);
dict["Y"] = 2;
Assert.Equal(2, changeCount);
- Assert.Equal(lastKey, "Y");
+ Assert.Equal("Y", lastKey);
object boxed = 0;
dict["Z"] = boxed;
Assert.Equal(3, changeCount);
Type delType = exp.Type;
Assert.Equal(new[] { delType }, exp.GetType().GetGenericArguments());
MethodInfo delMethod = delType.GetMethod("Invoke");
- Assert.Equal(delMethod.ReturnType, typeof(int));
+ Assert.Equal(typeof(int), delMethod.ReturnType);
Assert.Equal(20, delMethod.GetParameters().Length);
Assert.True(delMethod.GetParameters().All(p => p.ParameterType == typeof(int)));
Assert.Same(delType, Expression.Lambda(Expression.Constant(9), paramList).Type);
delType = exp.Type;
Assert.Equal(new[] { delType }, exp.GetType().GetGenericArguments());
delMethod = delType.GetMethod("Invoke");
- Assert.Equal(delMethod.ReturnType, typeof(long));
+ Assert.Equal(typeof(long), delMethod.ReturnType);
Assert.Equal(1, delMethod.GetParameters().Length);
Assert.Equal(typeof(int).MakeByRefType(), delMethod.GetParameters()[0].ParameterType);
Assert.Same(delType, Expression.Lambda(Expression.Constant(3L), Expression.Parameter(typeof(int).MakeByRefType())).Type);
Expression<Func<int, int[]>> exp1 = i => new int[i];
NewArrayExpression aex1 = exp1.Body as NewArrayExpression;
Assert.NotNull(aex1);
- Assert.Equal(aex1.NodeType, ExpressionType.NewArrayBounds);
+ Assert.Equal(ExpressionType.NewArrayBounds, aex1.NodeType);
Expression<Func<int[], int>> exp2 = (i) => i.Length;
UnaryExpression uex2 = exp2.Body as UnaryExpression;
Assert.NotNull(uex2);
- Assert.Equal(uex2.NodeType, ExpressionType.ArrayLength);
+ Assert.Equal(ExpressionType.ArrayLength, uex2.NodeType);
}
private void Method3<T, U, V>()
Expression<Func<int, int, int>> exp = (a, b) => unchecked(a + b);
BinaryExpression bex = exp.Body as BinaryExpression;
Assert.NotNull(bex);
- Assert.Equal(bex.NodeType, ExpressionType.Add);
+ Assert.Equal(ExpressionType.Add, bex.NodeType);
exp = (a, b) => checked(a + b);
bex = exp.Body as BinaryExpression;
Assert.NotNull(bex);
- Assert.Equal(bex.NodeType, ExpressionType.AddChecked);
+ Assert.Equal(ExpressionType.AddChecked, bex.NodeType);
exp = (a, b) => unchecked(a * b);
bex = exp.Body as BinaryExpression;
Assert.NotNull(bex);
- Assert.Equal(bex.NodeType, ExpressionType.Multiply);
+ Assert.Equal(ExpressionType.Multiply, bex.NodeType);
exp = (a, b) => checked(a * b);
bex = exp.Body as BinaryExpression;
Assert.NotNull(bex);
- Assert.Equal(bex.NodeType, ExpressionType.MultiplyChecked);
+ Assert.Equal(ExpressionType.MultiplyChecked, bex.NodeType);
Expression<Func<double, int>> exp2 = (a) => unchecked((int)a);
UnaryExpression uex = exp2.Body as UnaryExpression;
Assert.NotNull(uex);
- Assert.Equal(uex.NodeType, ExpressionType.Convert);
+ Assert.Equal(ExpressionType.Convert, uex.NodeType);
exp2 = (a) => checked((int)a);
uex = exp2.Body as UnaryExpression;
Assert.NotNull(uex);
- Assert.Equal(uex.NodeType, ExpressionType.ConvertChecked);
+ Assert.Equal(ExpressionType.ConvertChecked, uex.NodeType);
}
protected virtual int Foo(int x)
Func<TC1?> f1 = e1.Compile(useInterpreter);
Assert.NotNull(f1());
- Assert.Equal(f1().Value.Name, "And");
+ Assert.Equal("And", f1().Value.Name);
BinaryExpression resultOr = (BinaryExpression)Expression.OrElse(left, right);
Expression<Func<TC1?>> e2 = Expression.Lambda<Func<TC1?>>(
Func<TC1?> f2 = e2.Compile(useInterpreter);
Assert.NotNull(f2());
- Assert.Equal(f2().Value.Name, "lhs");
+ Assert.Equal("lhs", f2().Value.Name);
ConstantExpression constant = Expression.Constant(1.0, typeof(double));
AssertExtensions.Throws<ArgumentException>(null, () => Expression.Lambda<Func<double?>>(constant, null));
null);
Func<string> f = e.Compile(useInterpreter);
string r = f();
- Assert.Equal(a.m_x, "Changed");
+ Assert.Equal("Changed", a.m_x);
Expression<Func<Customer>> e2 = Expression.Lambda<Func<Customer>>(
Expression.Call(
Assert.True((comp1.x == comp.x + 1 && comp1.y == comp.y + 1));
Expression<Func<Complex, Complex>> testExpr = (x) => +x;
- Assert.Equal(testExpr.ToString(), "x => +x");
+ Assert.Equal("x => +x", testExpr.ToString());
Func<Complex, Complex> v = testExpr.Compile(useInterpreter);
}
{
// Using an unchecked cast to ensure that a Convert expression is used (and not ConvertChecked)
Expression<Func<int, int?>> f = x => unchecked((int?)x);
- Assert.Equal(f.Body.NodeType, ExpressionType.Convert);
+ Assert.Equal(ExpressionType.Convert, f.Body.NodeType);
Func<int, int?> d = f.Compile(useInterpreter);
Assert.Equal(2, d(2));
}
f(0);
- Assert.Equal(s.Type, typeof(void));
+ Assert.Equal(typeof(void), s.Type);
}
[Fact]
public void Range_ToArray_ProduceCorrectResult()
{
var array = Enumerable.Range(1, 100).ToArray();
- Assert.Equal(array.Length, 100);
+ Assert.Equal(100, array.Length);
for (var i = 0; i < array.Length; i++)
Assert.Equal(i + 1, array[i]);
}
public void Range_ToList_ProduceCorrectResult()
{
var list = Enumerable.Range(1, 100).ToList();
- Assert.Equal(list.Count, 100);
+ Assert.Equal(100, list.Count);
for (var i = 0; i < list.Count; i++)
Assert.Equal(i + 1, list[i]);
}
var array = Enumerable.Range(1, 0).ToArray();
var array2 = Enumerable.Range(int.MinValue, 0).ToArray();
var array3 = Enumerable.Range(int.MaxValue, 0).ToArray();
- Assert.Equal(array.Length, 0);
- Assert.Equal(array2.Length, 0);
- Assert.Equal(array3.Length, 0);
+ Assert.Equal(0, array.Length);
+ Assert.Equal(0, array2.Length);
+ Assert.Equal(0, array3.Length);
}
[Fact]
public void Repeat_ToArray_ProduceCorrectResult()
{
var array = Enumerable.Repeat(1, 100).ToArray();
- Assert.Equal(array.Length, 100);
+ Assert.Equal(100, array.Length);
for (var i = 0; i < array.Length; i++)
Assert.Equal(1, array[i]);
}
public void Repeat_ToList_ProduceCorrectResult()
{
var list = Enumerable.Repeat(1, 100).ToList();
- Assert.Equal(list.Count, 100);
+ Assert.Equal(100, list.Count);
for (var i = 0; i < list.Count; i++)
Assert.Equal(1, list[i]);
}
{
object objectInstance = new object();
var array = Enumerable.Repeat(objectInstance, 100).ToArray();
- Assert.Equal(array.Length, 100);
+ Assert.Equal(100, array.Length);
for (var i = 0; i < array.Length; i++)
Assert.Same(objectInstance, array[i]);
}
{
object objectInstance = null;
var array = Enumerable.Repeat(objectInstance, 100).ToArray();
- Assert.Equal(array.Length, 100);
+ Assert.Equal(100, array.Length);
for (var i = 0; i < array.Length; i++)
Assert.Null(array[i]);
}
public void Repeat_ZeroCountLeadToEmptySequence()
{
var array = Enumerable.Repeat(1, 0).ToArray();
- Assert.Equal(array.Length, 0);
+ Assert.Equal(0, array.Length);
}
[Fact]
ReadOnlySpan<byte> span = new byte[] { 0x11, 0x22, 0x22, 0x11 };
ref readonly int asInt = ref MemoryMarshal.AsRef<int>(span);
- Assert.Equal(asInt, 0x11222211);
+ Assert.Equal(0x11222211, asInt);
Assert.True(Unsafe.AreSame<byte>(ref Unsafe.As<int, byte>(ref Unsafe.AsRef(in asInt)), ref MemoryMarshal.GetReference(span)));
var array = new byte[100];
Span<byte> span = new byte[] { 0x11, 0x22, 0x22, 0x11 };
ref int asInt = ref MemoryMarshal.AsRef<int>(span);
- Assert.Equal(asInt, 0x11222211);
+ Assert.Equal(0x11222211, asInt);
Assert.True(Unsafe.AreSame<byte>(ref Unsafe.As<int, byte>(ref asInt), ref MemoryMarshal.GetReference(span)));
var array = new byte[100];
ReadOnlySequence<byte> buffer = Factory.CreateOfSize(100);
SequencePosition position = buffer.GetPosition(65);
- Assert.Equal(buffer.Slice(position).Length, 35);
+ Assert.Equal(35, buffer.Slice(position).Length);
position = buffer.GetPosition(65, buffer.Start);
- Assert.Equal(buffer.Slice(position).Length, 35);
+ Assert.Equal(35, buffer.Slice(position).Length);
}
[Fact]
{
ReadOnlySequence<char> buffer = Factory.CreateOfSize(100);
SequencePosition position = buffer.GetPosition(65);
- Assert.Equal(buffer.Slice(position).Length, 35);
+ Assert.Equal(35, buffer.Slice(position).Length);
position = buffer.GetPosition(65, buffer.Start);
- Assert.Equal(buffer.Slice(position).Length, 35);
+ Assert.Equal(35, buffer.Slice(position).Length);
}
[Fact]
handler.DefaultProxyCredentials = defaultSystemProxyCreds;
using (HttpResponseMessage response = await client.GetAsync("http://notatrealserver.com/")) // URL does not matter
{
- Assert.Equal(response.StatusCode, HttpStatusCode.OK);
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
}, async server =>
handler.DefaultProxyCredentials = new NetworkCredential("UsernameNotUsed", "PasswordNotUsed");
HttpResponseMessage response = await client.GetAsync(Configuration.Http.RemoteEchoServer);
- Assert.Equal(response.StatusCode, HttpStatusCode.OK);
+ Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
}
}
{
if (line.StartsWith("Host:",StringComparison.InvariantCultureIgnoreCase))
{
- Assert.Equal(line, "Host: foo.com:345");
+ Assert.Equal("Host: foo.com:345", line);
break;
}
}
public void DisplayName_Precedence()
{
var ma = new MailAddress("Hola <foo@bar.com>");
- Assert.Equal(ma.DisplayName, "Hola");
+ Assert.Equal("Hola", ma.DisplayName);
ma = new MailAddress("Hola <foo@bar.com>", "Adios");
- Assert.Equal(ma.DisplayName, "Adios");
+ Assert.Equal("Adios", ma.DisplayName);
ma = new MailAddress("Hola <foo@bar.com>", "");
- Assert.Equal(ma.DisplayName, "Hola");
+ Assert.Equal("Hola", ma.DisplayName);
ma = new MailAddress("<foo@bar.com>", "");
- Assert.Equal(ma.DisplayName, "");
+ Assert.Equal("", ma.DisplayName);
}
[Fact]
[Fact]
public void TestRecipients()
{
- Assert.Equal(emptyMessage.To.Count, 2);
- Assert.Equal(emptyMessage.To[0].Address, "r1@t1.com");
- Assert.Equal(emptyMessage.To[1].Address, "r2@t1.com");
+ Assert.Equal(2, emptyMessage.To.Count);
+ Assert.Equal("r1@t1.com", emptyMessage.To[0].Address);
+ Assert.Equal("r2@t1.com", emptyMessage.To[1].Address);
}
[Fact]
[Fact]
public void AlternateViewTest()
{
- Assert.Equal(messageWithSubjectAndBody.AlternateViews.Count, 1);
+ Assert.Equal(1, messageWithSubjectAndBody.AlternateViews.Count);
AlternateView av = messageWithSubjectAndBody.AlternateViews[0];
Assert.Equal(0, av.LinkedResources.Count);
Assert.Equal("text/html; charset=us-ascii", av.ContentType.ToString());
[Fact]
public void AttachmentTest()
{
- Assert.Equal(messageWithSubjectAndBody.Attachments.Count, 1);
+ Assert.Equal(1, messageWithSubjectAndBody.Attachments.Count);
Attachment at = messageWithSubjectAndBody.Attachments[0];
Assert.Equal("text/plain", at.ContentType.MediaType);
}
[Fact]
public void BodyTest()
{
- Assert.Equal(messageWithSubjectAndBody.Body, "hello");
+ Assert.Equal("hello", messageWithSubjectAndBody.Body);
}
[Fact]
[Fact]
public void FromTest()
{
- Assert.Equal(messageWithSubjectAndBody.From.Address, "from@example.com");
+ Assert.Equal("from@example.com", messageWithSubjectAndBody.From.Address);
}
[Fact]
[Fact]
public void PriorityTest()
{
- Assert.Equal(messageWithSubjectAndBody.Priority, MailPriority.Normal);
+ Assert.Equal(MailPriority.Normal, messageWithSubjectAndBody.Priority);
}
[Fact]
public void SubjectTest()
{
- Assert.Equal(messageWithSubjectAndBody.Subject, "the subject");
+ Assert.Equal("the subject", messageWithSubjectAndBody.Subject);
}
[Fact]
public void ToTest()
{
- Assert.Equal(messageWithSubjectAndBody.To.Count, 1);
- Assert.Equal(messageWithSubjectAndBody.To[0].Address, "to@example.com");
+ Assert.Equal(1, messageWithSubjectAndBody.To.Count);
+ Assert.Equal("to@example.com", messageWithSubjectAndBody.To[0].Address);
messageWithSubjectAndBody = new MailMessage();
messageWithSubjectAndBody.To.Add("to@example.com");
messageWithSubjectAndBody.To.Add("you@nowhere.com");
- Assert.Equal(messageWithSubjectAndBody.To.Count, 2);
- Assert.Equal(messageWithSubjectAndBody.To[0].Address, "to@example.com");
- Assert.Equal(messageWithSubjectAndBody.To[1].Address, "you@nowhere.com");
+ Assert.Equal(2, messageWithSubjectAndBody.To.Count);
+ Assert.Equal("to@example.com", messageWithSubjectAndBody.To[0].Address);
+ Assert.Equal("you@nowhere.com", messageWithSubjectAndBody.To[1].Address);
}
[Fact]
DnsEndPoint ep3 = new DnsEndPoint("name", 700, AddressFamily.InterNetwork);
DnsEndPoint ep4 = new DnsEndPoint("name", 500, AddressFamily.InterNetworkV6);
- Assert.NotEqual(ep1, null);
+ Assert.NotNull(ep1);
Assert.False(ep1.Equals("string"));
Assert.Equal(ep1, ep2);
Assert.Equal(0, ip.ScopeId);
ip.ScopeId = 700;
- Assert.Equal(ip.ScopeId, 700);
+ Assert.Equal(700, ip.ScopeId);
ip.ScopeId = 700;
}
Assert.Null(request.Proxy);
Assert.Equal(request.ReadWriteTimeout, 5 * 60 * 1000);
Assert.Null(request.RenameTo);
- Assert.Equal(request.RequestUri.Scheme, "ftp");
- Assert.Equal(request.RequestUri.Host, "foo.com");
- Assert.Equal(request.RequestUri.Port, 21);
+ Assert.Equal("ftp", request.RequestUri.Scheme);
+ Assert.Equal("foo.com", request.RequestUri.Host);
+ Assert.Equal(21, request.RequestUri.Port);
Assert.True(request.RequestUri.IsDefaultPort);
- Assert.Equal(request.RequestUri.AbsolutePath, "/bar");
+ Assert.Equal("/bar", request.RequestUri.AbsolutePath);
Assert.Equal(request.ServicePoint, ServicePointManager.FindServicePoint(new Uri("ftp://foo.com/bar")));
- Assert.Equal(request.Timeout, 100000);
+ Assert.Equal(100000, request.Timeout);
Assert.True(request.UseBinary);
Assert.True(request.UsePassive);
}
byte[] responseBody = Do(mode, method, uri, requestBody);
// Should be no response
- Assert.Equal(responseBody.Length, 0);
+ Assert.Equal(0, responseBody.Length);
}
private static void DoCommand(FtpExecutionMode mode, string method, string uri, string renameTo = null)
byte[] responseBody = Do(mode, method, uri, null, renameTo);
// Should be no response
- Assert.Equal(responseBody.Length, 0);
+ Assert.Equal(0, responseBody.Length);
}
public static List<object[]> Modes = new List<object[]>
Assert.Equal(0, request.Headers.Count);
Assert.Equal(HttpVersion.Version11, request.ProtocolVersion);
Assert.Equal("GET", request.Method);
- Assert.Equal(HttpWebRequest.DefaultMaximumResponseHeadersLength, 64);
+ Assert.Equal(64, HttpWebRequest.DefaultMaximumResponseHeadersLength);
Assert.NotNull(HttpWebRequest.DefaultCachePolicy);
- Assert.Equal(HttpWebRequest.DefaultCachePolicy.Level, RequestCacheLevel.BypassCache);
+ Assert.Equal(RequestCacheLevel.BypassCache, HttpWebRequest.DefaultCachePolicy.Level);
Assert.Equal(0, HttpWebRequest.DefaultMaximumErrorResponseLength);
Assert.NotNull(request.Proxy);
Assert.Equal(remoteServer, request.RequestUri);
request.CookieContainer.Add(remoteServer, new Cookie("1", "cookie1"));
request.CookieContainer.Add(remoteServer, new Cookie("2", "cookie2"));
Assert.True(request.SupportsCookieContainer);
- Assert.Equal(request.CookieContainer.GetCookies(remoteServer).Count, 2);
+ Assert.Equal(2, request.CookieContainer.GetCookies(remoteServer).Count);
}
[Theory, MemberData(nameof(EchoServers))]
{
HttpWebRequest request = WebRequest.CreateHttp(remoteServer);
request.AddRange(1, 5);
- Assert.Equal(request.Headers["Range"], "bytes=1-5");
+ Assert.Equal("bytes=1-5", request.Headers["Range"]);
}
[Theory]
IPEndPoint ep = (IPEndPoint)listener.LocalEndpoint;
Assert.Equal(ep.Address, IPAddress.IPv6Any);
- Assert.Equal(ep.Port, 0);
+ Assert.Equal(0, ep.Port);
Assert.True(listener.Server.DualMode);
listener.Start();
int received = serverSocket.EndReceiveFrom(async, ref receivedFrom);
Assert.Equal(1, received);
- Assert.Equal<Type>(receivedFrom.GetType(), typeof(IPEndPoint));
+ Assert.Equal<Type>(typeof(IPEndPoint), receivedFrom.GetType());
IPEndPoint remoteEndPoint = receivedFrom as IPEndPoint;
Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily);
}
Assert.Equal(1, args.BytesTransferred);
- Assert.Equal<Type>(args.RemoteEndPoint.GetType(), typeof(IPEndPoint));
+ Assert.Equal<Type>(typeof(IPEndPoint), args.RemoteEndPoint.GetType());
IPEndPoint remoteEndPoint = args.RemoteEndPoint as IPEndPoint;
Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily);
Assert.Equal(connectTo.MapToIPv6(), remoteEndPoint.Address);
received = serverSocket.ReceiveMessageFrom(new byte[1], 0, 1, ref socketFlags, ref receivedFrom, out ipPacketInformation);
Assert.Equal(1, received);
- Assert.Equal<Type>(receivedFrom.GetType(), typeof(IPEndPoint));
+ Assert.Equal<Type>(typeof(IPEndPoint), receivedFrom.GetType());
IPEndPoint remoteEndPoint = receivedFrom as IPEndPoint;
Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily);
int received = serverSocket.EndReceiveMessageFrom(async, ref socketFlags, ref receivedFrom, out IPPacketInformation ipPacketInformation);
Assert.Equal(1, received);
- Assert.Equal<Type>(receivedFrom.GetType(), typeof(IPEndPoint));
+ Assert.Equal<Type>(typeof(IPEndPoint), receivedFrom.GetType());
IPEndPoint remoteEndPoint = receivedFrom as IPEndPoint;
Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily);
}
Assert.Equal(1, args.BytesTransferred);
- Assert.Equal<Type>(args.RemoteEndPoint.GetType(), typeof(IPEndPoint));
+ Assert.Equal<Type>(typeof(IPEndPoint), args.RemoteEndPoint.GetType());
IPEndPoint remoteEndPoint = args.RemoteEndPoint as IPEndPoint;
Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily);
int received = serverSocket.ReceiveFrom(new byte[1], ref receivedFrom);
Assert.Equal(1, received);
- Assert.Equal<Type>(receivedFrom.GetType(), typeof(IPEndPoint));
+ Assert.Equal<Type>(typeof(IPEndPoint), receivedFrom.GetType());
IPEndPoint remoteEndPoint = receivedFrom as IPEndPoint;
Assert.Equal(AddressFamily.InterNetworkV6, remoteEndPoint.AddressFamily);
Assert.True(packetInfo == packetInfoCopy);
Assert.False(packetInfo != packetInfoCopy);
- Assert.NotEqual(packetInfo, default(IPPacketInformation));
+ Assert.NotEqual(default, packetInfo);
Assert.False(packetInfo == default(IPPacketInformation));
Assert.True(packetInfo != default(IPPacketInformation));
Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
Assert.False(sock.LingerState.Enabled, "Linger was turned on by default!");
- Assert.Equal<int>(sock.LingerState.LingerTime, 0);
+ Assert.Equal<int>(0, sock.LingerState.LingerTime);
TestLingerState_ArgumentException(sock, true, -1);
}
catch (SocketException e)
{
- Assert.Equal(e.SocketErrorCode, SocketError.WouldBlock);
+ Assert.Equal(SocketError.WouldBlock, e.SocketErrorCode);
//No more requests in queue
break;
{
SocketException e;
e = Assert.Throws<SocketException>(() => socket.SendBufferSize = 0);
- Assert.Equal(e.SocketErrorCode, SocketError.InvalidArgument);
+ Assert.Equal(SocketError.InvalidArgument, e.SocketErrorCode);
e = Assert.Throws<SocketException>(() => socket.ReceiveBufferSize = 0);
- Assert.Equal(e.SocketErrorCode, SocketError.InvalidArgument);
+ Assert.Equal(SocketError.InvalidArgument, e.SocketErrorCode);
}
}
public void Vector2ConstructorTest2()
{
Vector2 target = new Vector2();
- Assert.Equal(target.X, 0.0f);
- Assert.Equal(target.Y, 0.0f);
+ Assert.Equal(0.0f, target.X);
+ Assert.Equal(0.0f, target.Y);
}
// A test for Vector2f (float, float)
{
Vector3 a = new Vector3();
- Assert.Equal(a.X, 0.0f);
- Assert.Equal(a.Y, 0.0f);
- Assert.Equal(a.Z, 0.0f);
+ Assert.Equal(0.0f, a.X);
+ Assert.Equal(0.0f, a.Y);
+ Assert.Equal(0.0f, a.Z);
}
// A test for Vector2f (float, float)
{
Vector4 a = new Vector4();
- Assert.Equal(a.X, 0.0f);
- Assert.Equal(a.Y, 0.0f);
- Assert.Equal(a.Z, 0.0f);
- Assert.Equal(a.W, 0.0f);
+ Assert.Equal(0.0f, a.X);
+ Assert.Equal(0.0f, a.Y);
+ Assert.Equal(0.0f, a.Z);
+ Assert.Equal(0.0f, a.W);
}
// A test for Vector4f ()
string[] ss;
s = uri.ToString();
- Assert.Equal(s, @"http://foo/bar/baz#frag");
+ Assert.Equal(@"http://foo/bar/baz#frag", s);
s = uri.AbsolutePath;
- Assert.Equal<String>(s, @"/bar/baz");
+ Assert.Equal<String>(@"/bar/baz", s);
s = uri.AbsoluteUri;
- Assert.Equal<String>(s, @"http://foo/bar/baz#frag");
+ Assert.Equal<String>(@"http://foo/bar/baz#frag", s);
s = uri.Authority;
- Assert.Equal<String>(s, @"foo");
+ Assert.Equal<String>(@"foo", s);
s = uri.DnsSafeHost;
- Assert.Equal<String>(s, @"foo");
+ Assert.Equal<String>(@"foo", s);
s = uri.Fragment;
- Assert.Equal<String>(s, @"#frag");
+ Assert.Equal<String>(@"#frag", s);
s = uri.Host;
- Assert.Equal<String>(s, @"foo");
+ Assert.Equal<String>(@"foo", s);
uriHostNameType = uri.HostNameType;
- Assert.Equal<UriHostNameType>(uriHostNameType, UriHostNameType.Dns);
+ Assert.Equal<UriHostNameType>(UriHostNameType.Dns, uriHostNameType);
b = uri.IsAbsoluteUri;
Assert.True(b);
Assert.False(b);
s = uri.LocalPath;
- Assert.Equal<String>(s, @"/bar/baz");
+ Assert.Equal<String>(@"/bar/baz", s);
s = uri.OriginalString;
- Assert.Equal<String>(s, @"http://foo/bar/baz#frag");
+ Assert.Equal<String>(@"http://foo/bar/baz#frag", s);
s = uri.PathAndQuery;
- Assert.Equal<String>(s, @"/bar/baz");
+ Assert.Equal<String>(@"/bar/baz", s);
i = uri.Port;
- Assert.Equal<int>(i, 80);
+ Assert.Equal<int>(80, i);
s = uri.Query;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
s = uri.Scheme;
- Assert.Equal<String>(s, @"http");
+ Assert.Equal<String>(@"http", s);
ss = uri.Segments;
- Assert.Equal<int>(ss.Length, 3);
- Assert.Equal<String>(ss[0], @"/");
- Assert.Equal<String>(ss[1], @"bar/");
- Assert.Equal<String>(ss[2], @"baz");
+ Assert.Equal<int>(3, ss.Length);
+ Assert.Equal<String>(@"/", ss[0]);
+ Assert.Equal<String>(@"bar/", ss[1]);
+ Assert.Equal<String>(@"baz", ss[2]);
b = uri.UserEscaped;
Assert.Equal(b, dontEscape);
s = uri.UserInfo;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
}
[InlineData(true)]
string[] ss;
s = uri.ToString();
- Assert.Equal(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.AbsolutePath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.AbsoluteUri;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.Authority;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.DnsSafeHost;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.Fragment;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
s = uri.Host;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
uriHostNameType = uri.HostNameType;
- Assert.Equal<UriHostNameType>(uriHostNameType, UriHostNameType.Dns);
+ Assert.Equal<UriHostNameType>(UriHostNameType.Dns, uriHostNameType);
b = uri.IsAbsoluteUri;
Assert.True(b);
Assert.False(b);
s = uri.LocalPath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.OriginalString;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.PathAndQuery;
- Assert.Equal<String>(s, @"/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"/catalog/shownew.htm?date=today", s);
i = uri.Port;
- Assert.Equal<int>(i, 80);
+ Assert.Equal<int>(80, i);
s = uri.Query;
- Assert.Equal<String>(s, @"?date=today");
+ Assert.Equal<String>(@"?date=today", s);
s = uri.Scheme;
- Assert.Equal<String>(s, @"http");
+ Assert.Equal<String>(@"http", s);
ss = uri.Segments;
- Assert.Equal<int>(ss.Length, 3);
- Assert.Equal<String>(ss[0], @"/");
- Assert.Equal<String>(ss[1], @"catalog/");
- Assert.Equal<String>(ss[2], @"shownew.htm");
+ Assert.Equal<int>(3, ss.Length);
+ Assert.Equal<String>(@"/", ss[0]);
+ Assert.Equal<String>(@"catalog/", ss[1]);
+ Assert.Equal<String>(@"shownew.htm", ss[2]);
b = uri.UserEscaped;
Assert.Equal(b, dontEscape);
s = uri.UserInfo;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
}
[Fact]
string uriStr3 = address3.MakeRelative(address4);
#pragma warning restore 0618
- Assert.Equal(uriStr1, @"index.htm");
- Assert.Equal(uriStr2, @"http://www.contoso.com/index.htm?date=today");
- Assert.Equal(uriStr3, @"index.htm");
+ Assert.Equal(@"index.htm", uriStr1);
+ Assert.Equal(@"http://www.contoso.com/index.htm?date=today", uriStr2);
+ Assert.Equal(@"index.htm", uriStr3);
}
[Fact]
Assert.Equal(14, Uri.FromHex(testChar));
string hexString = Uri.HexEscape(testChar);
- Assert.Equal(hexString, "%65");
+ Assert.Equal("%65", hexString);
int index = 0;
Assert.True(Uri.IsHexEncoding(hexString, index));
{
var u = new Uri("https://a.net/1@1.msg");
var result = u.GetComponents(UriComponents.Scheme | UriComponents.Host | UriComponents.Port | UriComponents.Path, UriFormat.UriEscaped);
- Assert.Equal(result, "https://a.net/1@1.msg");
+ Assert.Equal("https://a.net/1@1.msg", result);
}
string[] ss;
s = uri.ToString();
- Assert.Equal(s, @"http://foo/bar/baz#frag");
+ Assert.Equal(@"http://foo/bar/baz#frag", s);
s = uri.AbsolutePath;
- Assert.Equal<String>(s, @"/bar/baz");
+ Assert.Equal<String>(@"/bar/baz", s);
s = uri.AbsoluteUri;
- Assert.Equal<String>(s, @"http://foo/bar/baz#frag");
+ Assert.Equal<String>(@"http://foo/bar/baz#frag", s);
s = uri.Authority;
- Assert.Equal<String>(s, @"foo");
+ Assert.Equal<String>(@"foo", s);
s = uri.DnsSafeHost;
- Assert.Equal<String>(s, @"foo");
+ Assert.Equal<String>(@"foo", s);
s = uri.Fragment;
- Assert.Equal<String>(s, @"#frag");
+ Assert.Equal<String>(@"#frag", s);
s = uri.Host;
- Assert.Equal<String>(s, @"foo");
+ Assert.Equal<String>(@"foo", s);
uriHostNameType = uri.HostNameType;
- Assert.Equal<UriHostNameType>(uriHostNameType, UriHostNameType.Dns);
+ Assert.Equal<UriHostNameType>(UriHostNameType.Dns, uriHostNameType);
b = uri.IsAbsoluteUri;
Assert.True(b);
Assert.False(b);
s = uri.LocalPath;
- Assert.Equal<String>(s, @"/bar/baz");
+ Assert.Equal<String>(@"/bar/baz", s);
s = uri.OriginalString;
- Assert.Equal<String>(s, @"http://foo/bar/baz#frag");
+ Assert.Equal<String>(@"http://foo/bar/baz#frag", s);
s = uri.PathAndQuery;
- Assert.Equal<String>(s, @"/bar/baz");
+ Assert.Equal<String>(@"/bar/baz", s);
i = uri.Port;
- Assert.Equal<int>(i, 80);
+ Assert.Equal<int>(80, i);
s = uri.Query;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
s = uri.Scheme;
- Assert.Equal<String>(s, @"http");
+ Assert.Equal<String>(@"http", s);
ss = uri.Segments;
- Assert.Equal<int>(ss.Length, 3);
- Assert.Equal<String>(ss[0], @"/");
- Assert.Equal<String>(ss[1], @"bar/");
- Assert.Equal<String>(ss[2], @"baz");
+ Assert.Equal<int>(3, ss.Length);
+ Assert.Equal<String>(@"/", ss[0]);
+ Assert.Equal<String>(@"bar/", ss[1]);
+ Assert.Equal<String>(@"baz", ss[2]);
b = uri.UserEscaped;
Assert.False(b);
s = uri.UserInfo;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
}
[Fact]
string[] ss;
s = uri.ToString();
- Assert.Equal(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.AbsolutePath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.AbsoluteUri;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.Authority;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.DnsSafeHost;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.Fragment;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
s = uri.Host;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
uriHostNameType = uri.HostNameType;
- Assert.Equal<UriHostNameType>(uriHostNameType, UriHostNameType.Dns);
+ Assert.Equal<UriHostNameType>(UriHostNameType.Dns, uriHostNameType);
b = uri.IsAbsoluteUri;
Assert.True(b);
Assert.False(b);
s = uri.LocalPath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.OriginalString;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.PathAndQuery;
- Assert.Equal<String>(s, @"/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"/catalog/shownew.htm?date=today", s);
i = uri.Port;
- Assert.Equal<int>(i, 80);
+ Assert.Equal<int>(80, i);
s = uri.Query;
- Assert.Equal<String>(s, @"?date=today");
+ Assert.Equal<String>(@"?date=today", s);
s = uri.Scheme;
- Assert.Equal<String>(s, @"http");
+ Assert.Equal<String>(@"http", s);
ss = uri.Segments;
- Assert.Equal<int>(ss.Length, 3);
- Assert.Equal<String>(ss[0], @"/");
- Assert.Equal<String>(ss[1], @"catalog/");
- Assert.Equal<String>(ss[2], @"shownew.htm");
+ Assert.Equal<int>(3, ss.Length);
+ Assert.Equal<String>(@"/", ss[0]);
+ Assert.Equal<String>(@"catalog/", ss[1]);
+ Assert.Equal<String>(@"shownew.htm", ss[2]);
b = uri.UserEscaped;
Assert.False(b);
s = uri.UserInfo;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
}
[Fact]
bool b;
s = uri.ToString();
- Assert.Equal(s, @"catalog/shownew.htm?date=today");
+ Assert.Equal(@"catalog/shownew.htm?date=today", s);
Assert.Throws<System.InvalidOperationException>(() => { object o = uri.AbsolutePath; });
Assert.Throws<System.InvalidOperationException>(() => { object o = uri.LocalPath; });
s = uri.OriginalString;
- Assert.Equal<String>(s, @"catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"catalog/shownew.htm?date=today", s);
Assert.Throws<System.InvalidOperationException>(() => { object o = uri.PathAndQuery; });
string[] ss;
s = uri.ToString();
- Assert.Equal(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.AbsolutePath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.AbsoluteUri;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.Authority;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.DnsSafeHost;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.Fragment;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
s = uri.Host;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
uriHostNameType = uri.HostNameType;
- Assert.Equal<UriHostNameType>(uriHostNameType, UriHostNameType.Dns);
+ Assert.Equal<UriHostNameType>(UriHostNameType.Dns, uriHostNameType);
b = uri.IsAbsoluteUri;
Assert.True(b);
Assert.False(b);
s = uri.LocalPath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.OriginalString;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.PathAndQuery;
- Assert.Equal<String>(s, @"/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"/catalog/shownew.htm?date=today", s);
i = uri.Port;
- Assert.Equal<int>(i, 80);
+ Assert.Equal<int>(80, i);
s = uri.Query;
- Assert.Equal<String>(s, @"?date=today");
+ Assert.Equal<String>(@"?date=today", s);
s = uri.Scheme;
- Assert.Equal<String>(s, @"http");
+ Assert.Equal<String>(@"http", s);
ss = uri.Segments;
- Assert.Equal<int>(ss.Length, 3);
- Assert.Equal<String>(ss[0], @"/");
- Assert.Equal<String>(ss[1], @"catalog/");
- Assert.Equal<String>(ss[2], @"shownew.htm");
+ Assert.Equal<int>(3, ss.Length);
+ Assert.Equal<String>(@"/", ss[0]);
+ Assert.Equal<String>(@"catalog/", ss[1]);
+ Assert.Equal<String>(@"shownew.htm", ss[2]);
b = uri.UserEscaped;
Assert.False(b);
s = uri.UserInfo;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
}
[Fact]
string[] ss;
s = uri.ToString();
- Assert.Equal(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.AbsolutePath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.AbsoluteUri;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.Authority;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.DnsSafeHost;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.Fragment;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
s = uri.Host;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
uriHostNameType = uri.HostNameType;
- Assert.Equal<UriHostNameType>(uriHostNameType, UriHostNameType.Dns);
+ Assert.Equal<UriHostNameType>(UriHostNameType.Dns, uriHostNameType);
b = uri.IsAbsoluteUri;
Assert.True(b);
Assert.False(b);
s = uri.LocalPath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.OriginalString;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.PathAndQuery;
- Assert.Equal<String>(s, @"/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"/catalog/shownew.htm?date=today", s);
i = uri.Port;
- Assert.Equal<int>(i, 80);
+ Assert.Equal<int>(80, i);
s = uri.Query;
- Assert.Equal<String>(s, @"?date=today");
+ Assert.Equal<String>(@"?date=today", s);
s = uri.Scheme;
- Assert.Equal<String>(s, @"http");
+ Assert.Equal<String>(@"http", s);
ss = uri.Segments;
- Assert.Equal<int>(ss.Length, 3);
- Assert.Equal<String>(ss[0], @"/");
- Assert.Equal<String>(ss[1], @"catalog/");
- Assert.Equal<String>(ss[2], @"shownew.htm");
+ Assert.Equal<int>(3, ss.Length);
+ Assert.Equal<String>(@"/", ss[0]);
+ Assert.Equal<String>(@"catalog/", ss[1]);
+ Assert.Equal<String>(@"shownew.htm", ss[2]);
b = uri.UserEscaped;
Assert.False(b);
s = uri.UserInfo;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
}
[Fact]
string[] ss;
s = uri.ToString();
- Assert.Equal(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.AbsolutePath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.AbsoluteUri;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.Authority;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.DnsSafeHost;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.Fragment;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
s = uri.Host;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
uriHostNameType = uri.HostNameType;
- Assert.Equal<UriHostNameType>(uriHostNameType, UriHostNameType.Dns);
+ Assert.Equal(UriHostNameType.Dns, uriHostNameType);
b = uri.IsAbsoluteUri;
Assert.True(b);
Assert.False(b);
s = uri.LocalPath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.OriginalString;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.PathAndQuery;
- Assert.Equal<String>(s, @"/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"/catalog/shownew.htm?date=today", s);
i = uri.Port;
- Assert.Equal<int>(i, 80);
+ Assert.Equal<int>(80, i);
s = uri.Query;
- Assert.Equal<String>(s, @"?date=today");
+ Assert.Equal<String>(@"?date=today", s);
s = uri.Scheme;
- Assert.Equal<String>(s, @"http");
+ Assert.Equal<String>(@"http", s);
ss = uri.Segments;
- Assert.Equal<int>(ss.Length, 3);
- Assert.Equal<String>(ss[0], @"/");
- Assert.Equal<String>(ss[1], @"catalog/");
- Assert.Equal<String>(ss[2], @"shownew.htm");
+ Assert.Equal<int>(3, ss.Length);
+ Assert.Equal<String>(@"/", ss[0]);
+ Assert.Equal<String>(@"catalog/", ss[1]);
+ Assert.Equal<String>(@"shownew.htm", ss[2]);
b = uri.UserEscaped;
Assert.False(b);
s = uri.UserInfo;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
}
[Fact]
string[] ss;
s = uri.ToString();
- Assert.Equal(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.AbsolutePath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.AbsoluteUri;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.Authority;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.DnsSafeHost;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
s = uri.Fragment;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
s = uri.Host;
- Assert.Equal<String>(s, @"www.contoso.com");
+ Assert.Equal<String>(@"www.contoso.com", s);
uriHostNameType = uri.HostNameType;
- Assert.Equal<UriHostNameType>(uriHostNameType, UriHostNameType.Dns);
+ Assert.Equal<UriHostNameType>(UriHostNameType.Dns, uriHostNameType);
b = uri.IsAbsoluteUri;
Assert.True(b);
Assert.False(b);
s = uri.LocalPath;
- Assert.Equal<String>(s, @"/catalog/shownew.htm");
+ Assert.Equal<String>(@"/catalog/shownew.htm", s);
s = uri.OriginalString;
- Assert.Equal<String>(s, @"http://www.contoso.com/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"http://www.contoso.com/catalog/shownew.htm?date=today", s);
s = uri.PathAndQuery;
- Assert.Equal<String>(s, @"/catalog/shownew.htm?date=today");
+ Assert.Equal<String>(@"/catalog/shownew.htm?date=today", s);
i = uri.Port;
- Assert.Equal<int>(i, 80);
+ Assert.Equal<int>(80, i);
s = uri.Query;
- Assert.Equal<String>(s, @"?date=today");
+ Assert.Equal<String>(@"?date=today", s);
s = uri.Scheme;
- Assert.Equal<String>(s, @"http");
+ Assert.Equal<String>(@"http", s);
ss = uri.Segments;
- Assert.Equal<int>(ss.Length, 3);
- Assert.Equal<String>(ss[0], @"/");
- Assert.Equal<String>(ss[1], @"catalog/");
- Assert.Equal<String>(ss[2], @"shownew.htm");
+ Assert.Equal<int>(3, ss.Length);
+ Assert.Equal<String>(@"/", ss[0]);
+ Assert.Equal<String>(@"catalog/", ss[1]);
+ Assert.Equal<String>(@"shownew.htm", ss[2]);
b = uri.UserEscaped;
Assert.False(b);
s = uri.UserInfo;
- Assert.Equal<String>(s, @"");
+ Assert.Equal<String>(@"", s);
}
[Fact]
bool b;
s = uri.ToString();
- Assert.Equal(s, @"index.htm?date=today");
+ Assert.Equal(@"index.htm?date=today", s);
Assert.Throws<System.InvalidOperationException>(() => { object o = uri.AbsolutePath; });
Assert.Throws<System.InvalidOperationException>(() => { object o = uri.LocalPath; });
s = uri.OriginalString;
- Assert.Equal<String>(s, @"index.htm?date=today");
+ Assert.Equal<String>(@"index.htm?date=today", s);
Assert.Throws<System.InvalidOperationException>(() => { object o = uri.PathAndQuery; });
UriHostNameType u;
u = Uri.CheckHostName("www.contoso.com");
- Assert.Equal(u, UriHostNameType.Dns);
+ Assert.Equal(UriHostNameType.Dns, u);
u = Uri.CheckHostName("1.2.3.4");
- Assert.Equal(u, UriHostNameType.IPv4);
+ Assert.Equal(UriHostNameType.IPv4, u);
u = Uri.CheckHostName(null);
- Assert.Equal(u, UriHostNameType.Unknown);
+ Assert.Equal(UriHostNameType.Unknown, u);
u = Uri.CheckHostName("!@*(@#&*#$&*#");
- Assert.Equal(u, UriHostNameType.Unknown);
+ Assert.Equal(UriHostNameType.Unknown, u);
}
[Fact]
Assert.Equal(i, -1);
i = Uri.Compare(uri1, uri2, UriComponents.Query, UriFormat.UriEscaped, StringComparison.CurrentCulture);
- Assert.Equal(i, 0);
+ Assert.Equal(0, i);
i = Uri.Compare(uri1, uri2, UriComponents.Query | UriComponents.Fragment, UriFormat.UriEscaped, StringComparison.CurrentCulture);
Assert.Equal(i, -1);
string s;
s = Uri.EscapeDataString("Hello");
- Assert.Equal(s, "Hello");
+ Assert.Equal("Hello", s);
s = Uri.EscapeDataString(@"He\l/lo");
- Assert.Equal(s, "He%5Cl%2Flo");
+ Assert.Equal("He%5Cl%2Flo", s);
}
[Fact]
string s;
s = Uri.UnescapeDataString("Hello");
- Assert.Equal(s, "Hello");
+ Assert.Equal("Hello", s);
s = Uri.UnescapeDataString("He%5Cl%2Flo");
- Assert.Equal(s, @"He\l/lo");
+ Assert.Equal(@"He\l/lo", s);
}
[Fact]
string s;
s = Uri.EscapeUriString("Hello");
- Assert.Equal(s, "Hello");
+ Assert.Equal("Hello", s);
s = Uri.EscapeUriString(@"He\l/lo");
- Assert.Equal(s, @"He%5Cl/lo");
+ Assert.Equal(@"He%5Cl/lo", s);
}
[Fact]
string s;
s = uri.GetComponents(UriComponents.Fragment, UriFormat.UriEscaped);
- Assert.Equal(s, "frag");
+ Assert.Equal("frag", s);
s = uri.GetComponents(UriComponents.Host, UriFormat.UriEscaped);
- Assert.Equal(s, "www.contoso.com");
+ Assert.Equal("www.contoso.com", s);
}
[Fact]
Assert.Equal(2, element.Attributes().Count());
- Assert.Equal(element.Attribute("att").Name, "att");
- Assert.Equal(element.Attribute("att").Value, "bar");
+ Assert.Equal("att", element.Attribute("att").Name);
+ Assert.Equal("bar", element.Attribute("att").Value);
- Assert.Equal(element.Attribute("att2").Name, "att2");
- Assert.Equal(element.Attribute("att2").Value, "att-value");
+ Assert.Equal("att2", element.Attribute("att2").Name);
+ Assert.Equal("att-value", element.Attribute("att2").Value);
}
/// <summary>
Assert.Null(e1.Attribute("foo"));
Assert.Null(e2.Attribute("foo"));
- Assert.Equal(e2.Attribute("a3").Name.ToString(), "a3");
- Assert.Equal(e2.Attribute("a3").Value, "3");
+ Assert.Equal("a3", e2.Attribute("a3").Name.ToString());
+ Assert.Equal("3", e2.Attribute("a3").Value);
Assert.Equal(new[] { "a1", "a2", "a3", "a4", "a5" }, e2.Attributes().Select(x => x.Name.ToString()));
Assert.Equal(new[] { "1", "2", "3", "4", "5" }, e2.Attributes().Select(x => x.Value));
// Add of non-existent attribute
e1.SetAttributeValue("foo", "foo-value");
- Assert.Equal(e1.Attribute("foo").Name.ToString(), "foo");
- Assert.Equal(e1.Attribute("foo").Value, "foo-value");
+ Assert.Equal("foo", e1.Attribute("foo").Name.ToString());
+ Assert.Equal("foo-value", e1.Attribute("foo").Value);
// Overwriting of existing attribute
e1.SetAttributeValue("foo", "noo-value");
- Assert.Equal(e1.Attribute("foo").Name.ToString(), "foo");
- Assert.Equal(e1.Attribute("foo").Value, "noo-value");
+ Assert.Equal("foo", e1.Attribute("foo").Name.ToString());
+ Assert.Equal("noo-value", e1.Attribute("foo").Value);
// Effective removal of existing attribute
e1.SetAttributeValue("foo", null);
// Verify that without annotation the output gets indented and the duplicate ns decls are not removed
if (testXElement)
{
- Assert.Equal(NormalizeNewLines(serialize(child)), "<child xmlns:a=\"uri\"> <baby xmlns:a=\"uri\">text</baby></child>");
+ Assert.Equal("<child xmlns:a=\"uri\"> <baby xmlns:a=\"uri\">text</baby></child>", NormalizeNewLines(serialize(child)));
}
// Now add annotation to the leaf element node
if (testXElement)
{
- Assert.Equal(serialize(baby), "<baby xmlns:a=\"uri\">text</baby>");
+ Assert.Equal("<baby xmlns:a=\"uri\">text</baby>", serialize(baby));
}
// Now add annotation to the middle node
if (testXElement)
{
// Verify that the options are applied correctly
- Assert.Equal(NormalizeNewLines(serialize(child)), "<child xmlns:a=\"uri\"><baby>text</baby></child>");
+ Assert.Equal("<child xmlns:a=\"uri\"><baby>text</baby></child>", NormalizeNewLines(serialize(child)));
// Verify that the root node is not affected as we don't look for the annotation among descendants
- Assert.Equal(NormalizeNewLines(serialize(root)), "<root xmlns:a=\"uri\"> <child xmlns:a=\"uri\"> <baby xmlns:a=\"uri\">text</baby> </child></root>");
+ Assert.Equal("<root xmlns:a=\"uri\"> <child xmlns:a=\"uri\"> <baby xmlns:a=\"uri\">text</baby> </child></root>", NormalizeNewLines(serialize(root)));
}
// And now add the annotation to the root and remove it from the child to test that we can correctly skip over a node
if (testXElement)
{
// Verify that the options are still applied to child
- Assert.Equal(serialize(child), "<child xmlns:a=\"uri\"><baby>text</baby></child>");
+ Assert.Equal("<child xmlns:a=\"uri\"><baby>text</baby></child>", serialize(child));
// And they should be also applied to the root now
- Assert.Equal(serialize(root), "<root xmlns:a=\"uri\"><child><baby>text</baby></child></root>");
+ Assert.Equal("<root xmlns:a=\"uri\"><child><baby>text</baby></child></root>", serialize(root));
}
// Add a document node above it all to test that it works on non-XElement as well
// Options should still apply to root as well as the doc
if (testXElement)
{
- Assert.Equal(serialize(root), "<root xmlns:a=\"uri\"><child><baby>text</baby></child></root>");
+ Assert.Equal("<root xmlns:a=\"uri\"><child><baby>text</baby></child></root>", serialize(root));
}
if (testXDocument)
{
- Assert.Equal(serialize(doc), "<root xmlns:a=\"uri\"><child><baby>text</baby></child></root>");
+ Assert.Equal("<root xmlns:a=\"uri\"><child><baby>text</baby></child></root>", serialize(doc));
}
}
Assert.True(elem.IsEmpty, "Did not remove correctly");
}
undo.Undo();
- Assert.Equal(elem.Value, "text2text0text1");
+ Assert.Equal("text2text0text1", elem.Value);
}
}
Assert.True(elem.IsEmpty, "Did not remove correctly");
}
undo.Undo();
- Assert.Equal(elem.Value, "text1text0text2");
+ Assert.Equal("text1text0text2", elem.Value);
}
}
Assert.True(elem.IsEmpty, "Did not remove correctly");
}
undo.Undo();
- Assert.Equal(elem.Value, "text1text0text2");
+ Assert.Equal("text1text0text2", elem.Value);
}
}
Assert.True(elem.IsEmpty, "Did not remove correctly");
}
undo.Undo();
- Assert.Equal(elem.Value, "text2text0text1");
+ Assert.Equal("text2text0text1", elem.Value);
}
}
Assert.Equal("<!---->", comment.OuterXml);
Assert.Equal(string.Empty, comment.InnerText);
- Assert.Equal(comment.NodeType, XmlNodeType.Comment);
+ Assert.Equal(XmlNodeType.Comment, comment.NodeType);
}
}
}
var node = (XmlElement)xmlDocument.DocumentElement;
var attribute = node.GetAttributeNode("ns1:att1");
- Assert.Equal(attribute.Value, "value1");
+ Assert.Equal("value1", attribute.Value);
node.SetAttribute("ns1:att1", "value3");
- Assert.Equal(attribute.Value, "value3");
+ Assert.Equal("value3", attribute.Value);
}
[Fact]
var node = (XmlElement)xmlDocument.DocumentElement;
var attribute = node.GetAttributeNode("attr1");
- Assert.Equal(attribute.Value, "test");
+ Assert.Equal("test", attribute.Value);
node.SetAttribute("attr1", "newvalue");
- Assert.Equal(attribute.Value, "newvalue");
+ Assert.Equal("newvalue", attribute.Value);
}
[Fact]
var node = (XmlElement)xmlDocument.DocumentElement;
var attribute = node.GetAttributeNode("attr1");
- Assert.Equal(attribute.Value, "test");
+ Assert.Equal("test", attribute.Value);
node.SetAttribute("attr1", "newvalue");
- Assert.Equal(attribute.Value, "newvalue");
+ Assert.Equal("newvalue", attribute.Value);
}
[Fact]
var node = (XmlElement)xmlDocument.DocumentElement;
var attribute = node.GetAttributeNode("attr1");
- Assert.Equal(attribute.Value, "test");
+ Assert.Equal("test", attribute.Value);
node.SetAttribute("attr1", "newvalue");
- Assert.Equal(attribute.Value, "newvalue");
+ Assert.Equal("newvalue", attribute.Value);
}
[Fact]
node.SetAttribute("attr2", "newvalue");
var attribute = node.Attributes.GetNamedItem("attr2");
- Assert.Equal(attribute.Value, "newvalue");
+ Assert.Equal("newvalue", attribute.Value);
Assert.Equal(2, node.Attributes.Count);
}
}
var namedNodeMap = (XmlNamedNodeMap)xmlDocument.FirstChild.Attributes;
Assert.Equal(namedNodeMap.Item(0), namedNodeMap.GetNamedItem("child1"));
- Assert.Equal(namedNodeMap.Item(0).Value, string.Empty);
+ Assert.Equal(string.Empty, namedNodeMap.Item(0).Value);
Assert.Equal(namedNodeMap.Item(1), namedNodeMap.GetNamedItem("child2"));
- Assert.Equal(namedNodeMap.Item(1).Value, "duu");
+ Assert.Equal("duu", namedNodeMap.Item(1).Value);
Assert.Equal(namedNodeMap.Item(4), namedNodeMap.GetNamedItem("child5"));
- Assert.Equal(namedNodeMap.Item(4).Value, "goody");
+ Assert.Equal("goody", namedNodeMap.Item(4).Value);
}
}
}
Assert.Equal("textNode", node.LastChild.Value);
Assert.Equal(XmlNodeType.Text, node.LastChild.NodeType);
- Assert.Equal(node.ChildNodes.Count, 1);
+ Assert.Equal(1, node.ChildNodes.Count);
}
[Fact]
var xmlDocument = new XmlDocument();
xmlDocument.LoadXml("<Root xmlns:aa=\"aa\" xmlns:bb=\"bb\"><aa:elem1><bb:elem2 /></aa:elem1></Root>");
- Assert.Equal(xmlDocument.DocumentElement.FirstChild.LocalName, "elem1");
- Assert.Equal(xmlDocument.DocumentElement.FirstChild.FirstChild.LocalName, "elem2");
+ Assert.Equal("elem1", xmlDocument.DocumentElement.FirstChild.LocalName);
+ Assert.Equal("elem2", xmlDocument.DocumentElement.FirstChild.FirstChild.LocalName);
}
}
}
var namespaceResolver = nodeReader as IXmlNamespaceResolver;
Assert.Null(namespaceResolver.LookupNamespace("prefix"));
Assert.Collection(namespaceResolver.GetNamespacesInScope(XmlNamespaceScope.All)
- , kv => Assert.Equal(kv.Key, "xml"));
+ , kv => Assert.Equal("xml", kv.Key));
Assert.Empty(namespaceResolver.GetNamespacesInScope(XmlNamespaceScope.Local));
}
{
try
{
- Assert.Equal(sc.Count, 0);
- Assert.Equal(sc.Contains((XmlSchema)null), false);
+ Assert.Equal(0, sc.Count);
+ Assert.False(sc.Contains((XmlSchema)null));
}
catch (ArgumentNullException)
{
- Assert.Equal(sc.Contains((string)null), false);
- Assert.Equal(sc.IsCompiled, false);
+ Assert.False(sc.Contains((string)null));
+ Assert.False(sc.IsCompiled);
return;
}
}
XmlSchema Schema = XmlSchema.Read(new StreamReader(new FileStream(TestData._FileXSD1, FileMode.Open, FileAccess.Read)), null);
XmlSchema SchemaNew = sc.Add(Schema);
- Assert.Equal(sc.Count, 1);
- Assert.Equal(sc.Contains(SchemaNew), true);
- Assert.Equal(sc.IsCompiled, false);
- Assert.Equal(Schema == SchemaNew, true);
+ Assert.Equal(1, sc.Count);
+ Assert.True(sc.Contains(SchemaNew));
+ Assert.False(sc.IsCompiled);
+ Assert.True(Schema == SchemaNew);
}
XmlSchema SchemaNew1 = sc.Add(Schema);
XmlSchema SchemaNew2 = sc.Add(Schema);
- Assert.Equal(sc.Count, 1);
- Assert.Equal(sc.Contains(SchemaNew1), true);
- Assert.Equal(sc.Contains(SchemaNew2), true);
- Assert.Equal(sc.IsCompiled, false);
- Assert.Equal(Schema == SchemaNew1, true);
- Assert.Equal(Schema == SchemaNew2, true);
+ Assert.Equal(1, sc.Count);
+ Assert.True(sc.Contains(SchemaNew1));
+ Assert.True(sc.Contains(SchemaNew2));
+ Assert.False(sc.IsCompiled);
+ Assert.True(Schema == SchemaNew1);
+ Assert.True(Schema == SchemaNew2);
sc.Compile();
- Assert.Equal(sc.Count, 1);
- Assert.Equal(sc.Contains(SchemaNew1), true);
- Assert.Equal(sc.Contains(SchemaNew2), true);
- Assert.Equal(sc.IsCompiled, true);
+ Assert.Equal(1, sc.Count);
+ Assert.True(sc.Contains(SchemaNew1));
+ Assert.True(sc.Contains(SchemaNew2));
+ Assert.True(sc.IsCompiled);
}
//-----------------------------------------------------------------------------------
XmlSchema SchemaNew2 = sc.Add("schema1.xsd", TestData._FileXSD1);
// both schemas are added but they are dup
- Assert.Equal(sc.Count, 2);
- Assert.Equal(sc.Contains(SchemaNew1), true);
- Assert.Equal(sc.Contains(SchemaNew2), true);
- Assert.Equal(sc.IsCompiled, false);
+ Assert.Equal(2, sc.Count);
+ Assert.True(sc.Contains(SchemaNew1));
+ Assert.True(sc.Contains(SchemaNew2));
+ Assert.False(sc.IsCompiled);
// check its not the same schema as first
- Assert.Equal(Schema == SchemaNew1, true);
- Assert.Equal(Schema == SchemaNew2, false);
+ Assert.True(Schema == SchemaNew1);
+ Assert.False(Schema == SchemaNew2);
try
{
}
catch (XmlSchemaException)
{
- Assert.Equal(sc.Count, 2);
- Assert.Equal(sc.Contains(SchemaNew1), true);
- Assert.Equal(sc.Contains(SchemaNew2), true);
- Assert.Equal(sc.IsCompiled, false);
+ Assert.Equal(2, sc.Count);
+ Assert.True(sc.Contains(SchemaNew1));
+ Assert.True(sc.Contains(SchemaNew2));
+ Assert.False(sc.IsCompiled);
return;
}
XmlSchema SchemaNew2 = sc.Add(null, TestData._XsdAuthorNoNs);
// both schemas are added but they are dup
- Assert.Equal(sc.Count, 2);
- Assert.Equal(sc.Contains(SchemaNew1), true);
- Assert.Equal(sc.Contains(SchemaNew2), true);
- Assert.Equal(sc.IsCompiled, false);
+ Assert.Equal(2, sc.Count);
+ Assert.True(sc.Contains(SchemaNew1));
+ Assert.True(sc.Contains(SchemaNew2));
+ Assert.False(sc.IsCompiled);
// check its not the same schema as first
- Assert.Equal(Schema == SchemaNew1, true);
- Assert.Equal(Schema == SchemaNew2, false);
+ Assert.True(Schema == SchemaNew1);
+ Assert.False(Schema == SchemaNew2);
sc.Compile();
- Assert.Equal(sc.Count, 2);
- Assert.Equal(sc.Contains(SchemaNew1), true);
- Assert.Equal(sc.Contains(SchemaNew2), true);
- Assert.Equal(sc.IsCompiled, true);
+ Assert.Equal(2, sc.Count);
+ Assert.True(sc.Contains(SchemaNew1));
+ Assert.True(sc.Contains(SchemaNew2));
+ Assert.True(sc.IsCompiled);
}
//-----------------------------------------------------------------------------------
XmlSchema SchemaNew2 = sc.Add(null, TestData._XsdNoNs);
// both schemas are added but they are dup
- Assert.Equal(sc.Count, 2);
- Assert.Equal(sc.Contains(SchemaNew1), true);
- Assert.Equal(sc.Contains(SchemaNew2), true);
- Assert.Equal(sc.IsCompiled, false);
+ Assert.Equal(2, sc.Count);
+ Assert.True(sc.Contains(SchemaNew1));
+ Assert.True(sc.Contains(SchemaNew2));
+ Assert.False(sc.IsCompiled);
// check its not the same schema as first
- Assert.Equal(Schema == SchemaNew1, true);
- Assert.Equal(Schema == SchemaNew2, false);
+ Assert.True(Schema == SchemaNew1);
+ Assert.False(Schema == SchemaNew2);
try
{
sc.Compile();
}
catch (XmlSchemaException)
{
- Assert.Equal(sc.Count, 2);
- Assert.Equal(sc.Contains(SchemaNew1), true);
- Assert.Equal(sc.Contains(SchemaNew2), true);
- Assert.Equal(sc.IsCompiled, false);
+ Assert.Equal(2, sc.Count);
+ Assert.True(sc.Contains(SchemaNew1));
+ Assert.True(sc.Contains(SchemaNew2));
+ Assert.False(sc.IsCompiled);
return;
}
XmlSchema aSchema = XmlSchema.Read(new XmlTextReader(path1), null);
XmlSchema bSchema = XmlSchema.Read(new XmlTextReader(path2), null);
- Assert.Equal(s.Count, 0);
- Assert.Equal(s.Contains(aSchema), false);
- Assert.Equal(s.Contains(bSchema), false);
- Assert.Equal(s.IsCompiled, false);
+ Assert.Equal(0, s.Count);
+ Assert.False(s.Contains(aSchema));
+ Assert.False(s.Contains(bSchema));
+ Assert.False(s.IsCompiled);
s.Add(aSchema);
Assert.Equal(s.Count, expCount);
- Assert.Equal(s.Contains(aSchema), true);
- Assert.Equal(s.Contains(bSchema), false);
- Assert.Equal(s.IsCompiled, false);
+ Assert.True(s.Contains(aSchema));
+ Assert.False(s.Contains(bSchema));
+ Assert.False(s.IsCompiled);
s.Add(bSchema);
Assert.Equal(s.Count, expCount + 1);
- Assert.Equal(s.Contains(aSchema), true);
- Assert.Equal(s.Contains(bSchema), true);
- Assert.Equal(s.IsCompiled, false);
+ Assert.True(s.Contains(aSchema));
+ Assert.True(s.Contains(bSchema));
+ Assert.False(s.IsCompiled);
try
{
s.Compile();
{
_output.WriteLine(e.ToString());
Assert.Equal(s.Count, expCount + 1);
- Assert.Equal(s.Contains(aSchema), true);
- Assert.Equal(s.Contains(bSchema), true);
- Assert.Equal(s.IsCompiled, false);
+ Assert.True(s.Contains(aSchema));
+ Assert.True(s.Contains(bSchema));
+ Assert.False(s.IsCompiled);
}
return 0;
set.XmlResolver = resolver;
set.Add(s2);
- Assert.Equal(set.Count, 1);
- Assert.Equal(set.Contains(s2), true);
- Assert.Equal(set.IsCompiled, false);
+ Assert.Equal(1, set.Count);
+ Assert.True(set.Contains(s2));
+ Assert.False(set.IsCompiled);
set.Add(s);
- Assert.Equal(set.Count, 2);
- Assert.Equal(set.Contains(s), true);
- Assert.Equal(set.IsCompiled, false);
+ Assert.Equal(2, set.Count);
+ Assert.True(set.Contains(s));
+ Assert.False(set.IsCompiled);
set.Compile();
- Assert.Equal(set.Count, 2);
- Assert.Equal(set.Contains(s2), true);
- Assert.Equal(set.Contains(s), true);
- Assert.Equal(set.IsCompiled, true);
+ Assert.Equal(2, set.Count);
+ Assert.True(set.Contains(s2));
+ Assert.True(set.Contains(s));
+ Assert.True(set.IsCompiled);
XmlTextReader r3 = new XmlTextReader(Path.Combine(TestData._Root, @"BaseEmployee2.xsd"));
XmlSchema s3 = XmlSchema.Read(r3, null);
set2.ValidationEventHandler += new ValidationEventHandler(callback);
set2.XmlResolver = resolver;
set2.Add(s3);
- Assert.Equal(set2.Count, 1);
- Assert.Equal(set2.Contains(s2), false);
- Assert.Equal(set2.Contains(s), false);
- Assert.Equal(set2.Contains(s3), true);
- Assert.Equal(set2.IsCompiled, false);
+ Assert.Equal(1, set2.Count);
+ Assert.False(set2.Contains(s2));
+ Assert.False(set2.Contains(s));
+ Assert.True(set2.Contains(s3));
+ Assert.False(set2.IsCompiled);
set2.Add(s);
- Assert.Equal(set2.Count, 2);
- Assert.Equal(set2.Contains(s2), false);
- Assert.Equal(set2.Contains(s), true);
- Assert.Equal(set2.Contains(s3), true);
- Assert.Equal(set2.IsCompiled, false);
+ Assert.Equal(2, set2.Count);
+ Assert.False(set2.Contains(s2));
+ Assert.True(set2.Contains(s));
+ Assert.True(set2.Contains(s3));
+ Assert.False(set2.IsCompiled);
set2.Compile();
- Assert.Equal(set2.Count, 2);
- Assert.Equal(set2.Contains(s2), false);
- Assert.Equal(set2.Contains(s), true);
- Assert.Equal(set2.Contains(s3), true);
- Assert.Equal(set2.IsCompiled, true);
+ Assert.Equal(2, set2.Count);
+ Assert.False(set2.Contains(s2));
+ Assert.True(set2.Contains(s));
+ Assert.True(set2.Contains(s3));
+ Assert.True(set2.IsCompiled);
- Assert.Equal(errorCount, 0);
+ Assert.Equal(0, errorCount);
}
//[Variation(Desc = "525477b: XSD Redefine doesn't work")]
XmlSchemaSet set = new XmlSchemaSet();
set.XmlResolver = resolver;
set.Add(s2);
- Assert.Equal(set.Count, 1);
- Assert.Equal(set.Contains(s2), true);
- Assert.Equal(set.IsCompiled, false);
+ Assert.Equal(1, set.Count);
+ Assert.True(set.Contains(s2));
+ Assert.False(set.IsCompiled);
set.Add(s);
- Assert.Equal(set.Count, 2);
- Assert.Equal(set.Contains(s), true);
- Assert.Equal(set.IsCompiled, false);
+ Assert.Equal(2, set.Count);
+ Assert.True(set.Contains(s));
+ Assert.False(set.IsCompiled);
set.Compile();
- Assert.Equal(set.Count, 2);
- Assert.Equal(set.Contains(s2), true);
- Assert.Equal(set.Contains(s), true);
- Assert.Equal(set.IsCompiled, true);
+ Assert.Equal(2, set.Count);
+ Assert.True(set.Contains(s2));
+ Assert.True(set.Contains(s));
+ Assert.True(set.IsCompiled);
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
XmlSchemaSet set2 = new XmlSchemaSet();
set2.XmlResolver = resolver;
set2.Add(s3);
- Assert.Equal(set2.Count, 1);
- Assert.Equal(set2.Contains(s2), false);
- Assert.Equal(set2.Contains(s), false);
- Assert.Equal(set2.Contains(s3), true);
- Assert.Equal(set2.IsCompiled, false);
+ Assert.Equal(1, set2.Count);
+ Assert.False(set2.Contains(s2));
+ Assert.False(set2.Contains(s));
+ Assert.True(set2.Contains(s3));
+ Assert.False(set2.IsCompiled);
foreach (XmlSchemaRedefine redefine in s.Includes)
{
}
set2.Add(s);
- Assert.Equal(set2.Count, 2);
- Assert.Equal(set2.Contains(s2), false);
- Assert.Equal(set2.Contains(s), true);
- Assert.Equal(set2.Contains(s3), true);
- Assert.Equal(set2.IsCompiled, false);
+ Assert.Equal(2, set2.Count);
+ Assert.False(set2.Contains(s2));
+ Assert.True(set2.Contains(s));
+ Assert.True(set2.Contains(s3));
+ Assert.False(set2.IsCompiled);
set2.Compile();
- Assert.Equal(set2.Count, 2);
- Assert.Equal(set2.Contains(s2), false);
- Assert.Equal(set2.Contains(s), true);
- Assert.Equal(set2.Contains(s3), true);
- Assert.Equal(set2.IsCompiled, true);
+ Assert.Equal(2, set2.Count);
+ Assert.False(set2.Contains(s2));
+ Assert.True(set2.Contains(s));
+ Assert.True(set2.Contains(s3));
+ Assert.True(set2.IsCompiled);
settings.Schemas = set2;
{
while (reader.Read()) ;
}
- Assert.Equal(errorCount, 0);
+ Assert.Equal(0, errorCount);
}
//[Variation(Desc = "649967a.XmlSchemaSet.Reprocess() fix is changing a collection where schemas are stored")]
XmlSchemaSet scnew = new XmlSchemaSet();
sc.Add(scnew);
- Assert.Equal(sc.Count, 0);
+ Assert.Equal(0, sc.Count);
return;
}
sc.Add(scnew);
// adding schemaset with same schema should be ignored
- Assert.Equal(sc.Count, 1);
+ Assert.Equal(1, sc.Count);
return;
}
sc.Add("xsdauthor", TestData._XsdAuthor);
sc.Add(sc);
- Assert.Equal(sc.Count, 1);
+ Assert.Equal(1, sc.Count);
return;
}
scnew.Add(null, TestData._XsdNoNs);
scnew.Add(null, TestData._FileXSD1);
sc.Add(scnew);
- Assert.Equal(sc.Count, 3);
+ Assert.Equal(3, sc.Count);
return;
}
scnew.Add(null, TestData._FileXSD1);
scnew.Add(null, TestData._FileXSD2);
sc.Add(scnew);
- Assert.Equal(sc.Count, 4);
+ Assert.Equal(4, sc.Count);
return;
}
scnew.Add(null, TestData._FileXSD1);
scnew.Add(null, TestData._XsdAuthorDup); // this conflicts with _XsdAuthor
sc.Add(scnew);
- Assert.Equal(sc.IsCompiled, false);
- Assert.Equal(sc.Count, 4); //ok
+ Assert.False(sc.IsCompiled);
+ Assert.Equal(4, sc.Count); //ok
try
{
sc.Compile(); // should fail
sc.Add("xsdauthor", TestData._XsdAuthor);
sc.Add(null, TestData._XsdNoNs);
sc.Compile();
- Assert.Equal(sc.IsCompiled, true);
+ Assert.True(sc.IsCompiled);
scnew.Add(null, TestData._FileXSD1);
scnew.Add(null, TestData._XsdAuthorDup); // this conflicts with _XsdAuthor
sc.Add(scnew);
- Assert.Equal(sc.IsCompiled, false);
- Assert.Equal(sc.Count, 4); //ok
+ Assert.False(sc.IsCompiled);
+ Assert.Equal(4, sc.Count); //ok
try
{
sc.Compile(); // should fail
sc.Add("xsdauthor", TestData._XsdAuthor);
sc.Add(null, TestData._XsdNoNs);
sc.Compile();
- Assert.Equal(sc.IsCompiled, true);
+ Assert.True(sc.IsCompiled);
scnew.Add(null, TestData._FileXSD1);
scnew.Add(null, TestData._XsdAuthorDup); // this conflicts with _XsdAuthor
scnew.Compile();
}
catch (XmlSchemaException)
{
- Assert.Equal(schemaSet2.Count, 0); // no schema should be added
- Assert.Equal(schemaSet1.Count, 2); // no schema should be added
- Assert.Equal(schemaSet2.IsCompiled, false); // no schema should be added
- Assert.Equal(schemaSet1.IsCompiled, false); // no schema should be added
+ Assert.Equal(0, schemaSet2.Count); // no schema should be added
+ Assert.Equal(2, schemaSet1.Count); // no schema should be added
+ Assert.False(schemaSet2.IsCompiled); // no schema should be added
+ Assert.False(schemaSet1.IsCompiled); // no schema should be added
return;
}
- Assert.Equal(schemaSet2.Count, 0); // no schema should be added
+ Assert.Equal(0, schemaSet2.Count); // no schema should be added
Assert.True(false);
}
try
{
schemaSet2.Add(schemaSet1);
- Assert.Equal(schemaSet1.Count, 3); // no schema should be added
- Assert.Equal(schemaSet2.Count, 3); // no schema should be added
- Assert.Equal(schemaSet1.IsCompiled, true); // no schema should be added
+ Assert.Equal(3, schemaSet1.Count); // no schema should be added
+ Assert.Equal(3, schemaSet2.Count); // no schema should be added
+ Assert.True(schemaSet1.IsCompiled); // no schema should be added
schemaSet2.Compile();
- Assert.Equal(schemaSet2.IsCompiled, true); // no schema should be added
+ Assert.True(schemaSet2.IsCompiled); // no schema should be added
// shound not reach here
}
catch (XmlSchemaException)
return;
}
}
-}
\ No newline at end of file
+}
{
XmlSchemaSet sc = new XmlSchemaSet();
XmlSchema Schema = sc.Add((string)null, TestData._FileXSD1);
- Assert.Equal(Schema != null, true);
+ Assert.True(Schema != null);
return;
}
XmlSchemaSet sc = new XmlSchemaSet();
XmlSchema Schema = sc.Add("xsdauthor", TestData._XsdAuthor);
- Assert.Equal(Schema != null, true);
+ Assert.True(Schema != null);
return;
}
XmlSchema Schema1 = sc.Add("xsdauthor1", TestData._XsdNoNs);
XmlSchema Schema2 = sc.Add("xsdauthor2", TestData._XsdNoNs);
- Assert.Equal(sc.Count, 2);
- Assert.Equal(Schema1 != null, true);
+ Assert.Equal(2, sc.Count);
+ Assert.True(Schema1 != null);
// the second call to add should be ignored with Add returning the first obj
- Assert.Equal((Schema2 == Schema1), false);
+ Assert.False((Schema2 == Schema1));
return;
}
XmlSchema Schema1 = sc.Add(null, TestData._XsdAuthor);
XmlSchema Schema2 = sc.Add(null, TestData._XsdAuthor);
- Assert.Equal(sc.Count, 1);
- Assert.Equal(Schema1 != null, true);
+ Assert.Equal(1, sc.Count);
+ Assert.True(Schema1 != null);
// the second call to add should be ignored with Add returning the first obj
Assert.Equal(Schema2, Schema1);
XmlSchema Schema1 = sc.Add("xsdauthor", TestData._XsdAuthor);
XmlSchema Schema2 = sc.Add("xsdauthor", TestData._XsdNoNs);
- Assert.Equal(sc.Count, 2);
- Assert.Equal(Schema1 != null, true);
- Assert.Equal((Schema2 == Schema1), false);
+ Assert.Equal(2, sc.Count);
+ Assert.True(Schema1 != null);
+ Assert.False((Schema2 == Schema1));
return;
}
}
catch (XmlSchemaException)
{
- Assert.Equal(sc.Count, 0);
+ Assert.Equal(0, sc.Count);
// GLOBALIZATION
return;
}
XmlSchema Schema2 = sc.Add("xsdauthor", TestData._XsdAuthorDup);
// schemas should be successfully added
- Assert.Equal(sc.Count, 2);
+ Assert.Equal(2, sc.Count);
try
{
sc.Compile();
}
catch (XmlSchemaException)
{
- Assert.Equal(sc.Count, 2);
+ Assert.Equal(2, sc.Count);
// GLOBALIZATION
return;
}
XmlSchema Schema2 = sc.Add("xsdauthor", TestData._XsdAuthorDup);
// schemas should be successfully added
- Assert.Equal(sc.Count, 2);
+ Assert.Equal(2, sc.Count);
try
{
sc.Compile();
}
catch (XmlSchemaException)
{
- Assert.Equal(sc.Count, 2);
+ Assert.Equal(2, sc.Count);
// GLOBALIZATION
return;
public void v1()
{
XmlSchemaSet sc = new XmlSchemaSet();
- Assert.Equal(sc.Contains((string)null), false);
+ Assert.False(sc.Contains((string)null));
return;
}
{
XmlSchemaSet sc = new XmlSchemaSet();
sc.Add("xsdauthor", TestData._XsdAuthor);
- Assert.Equal(sc.Contains("test"), false);
+ Assert.False(sc.Contains("test"));
return;
}
{
XmlSchemaSet sc = new XmlSchemaSet();
XmlSchema Schema = sc.Add("xsdauthor", TestData._XsdAuthor);
- Assert.Equal(sc.Contains("xsdauthor"), true);
+ Assert.True(sc.Contains("xsdauthor"));
sc.Remove(Schema);
- Assert.Equal(sc.Contains("xsdauthor"), false);
+ Assert.False(sc.Contains("xsdauthor"));
return;
}
XmlSchema Schema1 = sc.Add("xsdauthor", TestData._XsdAuthor);
XmlSchema Schema2 = sc.Add("xsdauthor", TestData._XsdNoNs);
- Assert.Equal(sc.Contains("xsdauthor"), true);
+ Assert.True(sc.Contains("xsdauthor"));
sc.Remove(Schema1);
- Assert.Equal(sc.Contains("xsdauthor"), true);
+ Assert.True(sc.Contains("xsdauthor"));
return;
}
}
-}
\ No newline at end of file
+}
XmlSchema Schema = scl.Add(null, TestData._XsdAuthor);
- Assert.Equal(sc.Contains(Schema), false);
+ Assert.False(sc.Contains(Schema));
return;
}
XmlSchema Schema = scl.Add(null, TestData._XsdAuthor);
sc.Add(Schema);
- Assert.Equal(sc.Contains(Schema), true);
+ Assert.True(sc.Contains(Schema));
sc.Remove(Schema);
- Assert.Equal(sc.Contains(Schema), false);
+ Assert.False(sc.Contains(Schema));
return;
}
XmlSchemaSet sc = new XmlSchemaSet();
XmlSchema Schema = sc.Add(null, TestData._XsdAuthor);
- Assert.Equal(sc.Contains(Schema), true);
+ Assert.True(sc.Contains(Schema));
return;
}
}
-}
\ No newline at end of file
+}
}
val = new XmlSchemaValidator(nt, sch, new XmlNamespaceManager(new NameTable()), AllFlags);
- Assert.NotEqual(val, null);
+ Assert.NotNull(val);
val.Initialize();
val.ValidateElement("root", "", info);
Assert.True(nt.IsAddCalled);
- Assert.Equal(nt.IsGetCalled, false);
+ Assert.False(nt.IsGetCalled);
return;
}
}
val = new XmlSchemaValidator(new NameTable(), sch, new XmlNamespaceManager(new NameTable()), AllFlags);
- Assert.NotEqual(val, null);
+ Assert.NotNull(val);
val.Initialize();
val.ValidateElement("elem1", "", null);
if (after == "init")
{
val.Initialize();
- Assert.Equal(val.GetExpectedParticles().Length, 18);
+ Assert.Equal(18, val.GetExpectedParticles().Length);
}
else if (after == "end")
{
{
result = val.GetExpectedParticles();
- Assert.Equal(result.Length, 1);
+ Assert.Equal(1, result.Length);
Assert.True(result[0] is XmlSchemaAny);
- Assert.Equal((result[0] as XmlSchemaAny).Namespace, "uri:tempuri");
- Assert.Equal((result[0] as XmlSchemaAny).ProcessContents, XmlSchemaContentProcessing.Strict);
+ Assert.Equal("uri:tempuri", (result[0] as XmlSchemaAny).Namespace);
+ Assert.Equal(XmlSchemaContentProcessing.Strict, (result[0] as XmlSchemaAny).ProcessContents);
}
else
{
{
result = val.GetExpectedParticles();
- Assert.Equal(result.Length, 2);
+ Assert.Equal(2, result.Length);
if (result[0] is XmlSchemaAny)
{
- Assert.Equal((result[0] as XmlSchemaAny).Namespace, "uri:tempuri");
- Assert.Equal((result[0] as XmlSchemaAny).ProcessContents, XmlSchemaContentProcessing.Strict);
+ Assert.Equal("uri:tempuri", (result[0] as XmlSchemaAny).Namespace);
+ Assert.Equal(XmlSchemaContentProcessing.Strict, (result[0] as XmlSchemaAny).ProcessContents);
Assert.True(result[1] is XmlSchemaElement);
Assert.Equal((result[1] as XmlSchemaElement).QualifiedName, new XmlQualifiedName("foo"));
else
{
Assert.True(result[1] is XmlSchemaAny);
- Assert.Equal((result[1] as XmlSchemaAny).Namespace, "uri:tempuri");
- Assert.Equal((result[1] as XmlSchemaAny).ProcessContents, XmlSchemaContentProcessing.Strict);
+ Assert.Equal("uri:tempuri", (result[1] as XmlSchemaAny).Namespace);
+ Assert.Equal(XmlSchemaContentProcessing.Strict, (result[1] as XmlSchemaAny).ProcessContents);
Assert.True(result[0] is XmlSchemaElement);
Assert.Equal((result[0] as XmlSchemaElement).QualifiedName, new XmlQualifiedName("foo"));
result = val.GetExpectedParticles();
- Assert.Equal(result.Length, 1);
+ Assert.Equal(1, result.Length);
Assert.True(result[0] is XmlSchemaAny);
- Assert.Equal((result[0] as XmlSchemaAny).Namespace, null);
- Assert.Equal((result[0] as XmlSchemaAny).ProcessContents, XmlSchemaContentProcessing.Lax);
+ Assert.Null((result[0] as XmlSchemaAny).Namespace);
+ Assert.Equal(XmlSchemaContentProcessing.Lax, (result[0] as XmlSchemaAny).ProcessContents);
return;
}
val.ValidateText(StringGetter("123"));
val.ValidateEndElement(info);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.SchemaElement.Name, "PartialElement");
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal("PartialElement", info.SchemaElement.Name);
return;
}
val.ValidateEndOfAttributes(null);
val.ValidateEndElement(info);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.SchemaType.Name, "PartialType");
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal("PartialType", info.SchemaType.Name);
return;
}
val.ValidateAttribute("PartialAttribute", "", StringGetter("123"), info);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.SchemaAttribute.Name, "PartialAttribute");
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal("PartialAttribute", info.SchemaAttribute.Name);
return;
}
val.ValidateEndElement(null);
val.ValidateEndElement(info);
- Assert.Equal(info.ContentType, XmlSchemaContentType.ElementOnly);
+ Assert.Equal(XmlSchemaContentType.ElementOnly, info.ContentType);
Assert.True(info.SchemaType != null);
return;
}
catch (XmlSchemaValidationException e)
{
- Assert.Equal(e.LineNumber, 2);
- Assert.Equal(e.LinePosition, 8);
+ Assert.Equal(2, e.LineNumber);
+ Assert.Equal(8, e.LinePosition);
}
return;
val.Initialize();
val.ValidateElement("bar", "", info);
- Assert.Equal(holder.NestingDepth, 3);
+ Assert.Equal(3, holder.NestingDepth);
return;
}
val.ValidateAttribute(attrType, "", StringGetter("foo"), info);
Assert.Equal(info.SchemaAttribute.QualifiedName, new XmlQualifiedName(attrType));
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.SchemaType.TypeCode, XmlTypeCode.String);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlTypeCode.String, info.SchemaType.TypeCode);
return;
}
val.ValidateAttribute("attr1", "uri:tempuri", StringGetter("123"), info);
Assert.Equal(info.SchemaAttribute.QualifiedName, new XmlQualifiedName("attr1", "uri:tempuri"));
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.SchemaType.TypeCode, XmlTypeCode.Int);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlTypeCode.Int, info.SchemaType.TypeCode);
return;
}
val.ValidateElement("AnyAttributeElement", "", null);
val.ValidateAttribute("SomeAttribute", "", StringGetter("foo"), info);
- Assert.Equal(info.Validity, XmlSchemaValidity.NotKnown);
+ Assert.Equal(XmlSchemaValidity.NotKnown, info.Validity);
return;
}
atts.Clear();
val.GetUnspecifiedDefaultAttributes(atts);
- Assert.Equal(atts.Count, 0);
+ Assert.Equal(0, atts.Count);
return;
}
if (attr.QualifiedName.Name == str)
nFound++;
}
- Assert.Equal(nFound, 1);
+ Assert.Equal(1, nFound);
}
}
}
val.ValidateAttribute(attrType, "", "foo", info);
Assert.Equal(info.SchemaAttribute.QualifiedName, new XmlQualifiedName(attrType));
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.SchemaType.TypeCode, XmlTypeCode.String);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlTypeCode.String, info.SchemaType.TypeCode);
return;
}
val.ValidateAttribute("attr1", "uri:tempuri", "123", info);
Assert.Equal(info.SchemaAttribute.QualifiedName, new XmlQualifiedName("attr1", "uri:tempuri"));
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.SchemaType.TypeCode, XmlTypeCode.Int);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlTypeCode.Int, info.SchemaType.TypeCode);
return;
}
val.ValidateElement("AnyAttributeElement", "", null);
val.ValidateAttribute("SomeAttribute", "", "foo", info);
- Assert.Equal(info.Validity, XmlSchemaValidity.NotKnown);
+ Assert.Equal(XmlSchemaValidity.NotKnown, info.Validity);
return;
}
atts.Clear();
val.GetUnspecifiedDefaultAttributes(atts);
- Assert.Equal(atts.Count, 0);
+ Assert.Equal(0, atts.Count);
return;
}
val.ValidateElement(name, "", info, null, null, null, null);
Assert.Equal(info.ContentType, schemaContentType);
- Assert.Equal(info.Validity, XmlSchemaValidity.NotKnown);
+ Assert.Equal(XmlSchemaValidity.NotKnown, info.Validity);
Assert.Equal(info.SchemaElement, schemas.GlobalElements[new XmlQualifiedName(name)]);
- Assert.Equal(info.IsNil, false);
- Assert.Equal(info.IsDefault, false);
+ Assert.False(info.IsNil);
+ Assert.False(info.IsDefault);
if (name == "SimpleElement")
Assert.True(info.SchemaType is XmlSchemaSimpleType);
else
val.ValidateElement("bar", "", info);
Assert.Equal(info.SchemaElement.QualifiedName, new XmlQualifiedName("bar"));
Assert.True(info.SchemaType is XmlSchemaSimpleType);
- Assert.Equal(info.SchemaType.TypeCode, XmlTypeCode.String);
+ Assert.Equal(XmlTypeCode.String, info.SchemaType.TypeCode);
return;
}
val.ValidateEndOfAttributes(null);
val.ValidateEndElement(info);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
return;
}
val.ValidateElement("root", "", info, "t:rootType", null, "uri:tempuri " + Path.Combine(TestData, "__NonExistingFile__.xsd"), null);
Assert.True(holder.IsCalledA);
- Assert.Equal(holder.lastSeverity, XmlSeverityType.Warning);
+ Assert.Equal(XmlSeverityType.Warning, holder.lastSeverity);
_exVerifier.IsExceptionOk(holder.lastException, "Sch_CannotLoadSchema", new string[] { "uri:tempuri", null });
return;
val.ValidateElement("root", "", info, "rootType", null, null, Path.Combine(TestData, "__NonExistingFile__.xsd"));
Assert.True(holder.IsCalledA);
- Assert.Equal(holder.lastSeverity, XmlSeverityType.Warning);
+ Assert.Equal(XmlSeverityType.Warning, holder.lastSeverity);
_exVerifier.IsExceptionOk(holder.lastException, "Sch_CannotLoadSchema", new string[] { "", null });
return;
val.ValidateElement("undefined", "", null);
Assert.True(holder.IsCalledA);
- Assert.Equal(holder.lastSeverity, XmlSeverityType.Warning);
+ Assert.Equal(XmlSeverityType.Warning, holder.lastSeverity);
_exVerifier.IsExceptionOk(holder.lastException, "Sch_NoElementSchemaFound", new string[] { "undefined" });
return;
val.ValidateEndElement(si);
val.ValidateEndElement(si);
- Assert.Equal(warningCount, 0);
- Assert.Equal(errorCount, 2);
+ Assert.Equal(0, warningCount);
+ Assert.Equal(2, errorCount);
return;
}
ValidateSchemaSet(ss, expCount, true, expCountGT, expCountGE, expCountGA, "Validation after repr/comp");
ValidateWithSchemaInfo(ss);
- Assert.Equal(ss.RemoveRecursive(Schema), true);
+ Assert.True(ss.RemoveRecursive(Schema));
ValidateSchemaSet(ss, 0, false, 1, 0, 0, "Validation after remRec");
ValidateWithSchemaInfo(ss);
ValidateSchemaSet(ss, expCount, true, expCountGT, expCountGE, expCountGA, "Validation after repr/comp");
ValidateWithXmlReader(ss, xml, xsd);
- Assert.Equal(ss.RemoveRecursive(Schema), true);
+ Assert.True(ss.RemoveRecursive(Schema));
ValidateSchemaSet(ss, 0, false, 1, 0, 0, "Validation after remRec");
ValidateWithXmlReader(ss, xml, xsd);
ValidateSchemaSet(ss, expCount - 1, true, expCountGERC, expCountGER, 0, "Validation after repr");
ValidateWithSchemaInfo(ss);
- Assert.Equal(ss.RemoveRecursive(Schema), false);
+ Assert.False(ss.RemoveRecursive(Schema));
ValidateSchemaSet(ss, expCount - 1, true, expCountGERC, expCountGER, 0, "Validation after add");
ValidateWithSchemaInfo(ss);
ValidateSchemaSet(ss, expCount - 1, true, expCountGERC, expCountGER, 0, "Validation after repr");
ValidateWithXmlReader(ss, xml, xsd);
- Assert.Equal(ss.RemoveRecursive(Schema), false);
+ Assert.False(ss.RemoveRecursive(Schema));
ValidateSchemaSet(ss, expCount - 1, true, expCountGERC, expCountGER, 0, "Validation after remRec");
ValidateWithXmlReader(ss, xml, xsd);
Assert.Equal(ss.Count, expCount);
ss.RemoveRecursive(Schema);
- Assert.Equal(ss.Count, 0);
+ Assert.Equal(0, ss.Count);
ss.Compile();
- Assert.Equal(ss.Count, 0);
+ Assert.Equal(0, ss.Count);
try
{
catch (ArgumentException e)
{
_output.WriteLine(e.Message);
- Assert.Equal(ss.Count, 0);
+ Assert.Equal(0, ss.Count);
}
return;
}
Assert.Equal(ss.Count, expCount);
ss.RemoveRecursive(schema);
- Assert.Equal(ss.Count, 0);
+ Assert.Equal(0, ss.Count);
ss.Compile();
- Assert.Equal(ss.Count, 0);
+ Assert.Equal(0, ss.Count);
try
{
catch (ArgumentException e)
{
_output.WriteLine(e.Message);
- Assert.Equal(ss.Count, 0);
+ Assert.Equal(0, ss.Count);
}
return;
}
XmlSchema schema = XmlSchema.Read(new StringReader(schemaXml), null);
ss.Add(schema);
- Assert.Equal(ss.Count, 1);
+ Assert.Equal(1, ss.Count);
ss.Compile();
- Assert.Equal(ss.Count, 1);
+ Assert.Equal(1, ss.Count);
XmlReaderSettings settings = new XmlReaderSettings();
settings.Schemas = ss;
}
XmlSchema removedSchema = ss.Remove(schema);
- Assert.Equal(ss.Count, 0);
+ Assert.Equal(0, ss.Count);
ss.Compile();
- Assert.Equal(ss.Count, 0);
+ Assert.Equal(0, ss.Count);
settings = new XmlReaderSettings();
settings.Schemas = ss;
XmlSchema schema = XmlSchema.Read(new StringReader(schemaXml), null);
ss.Add(schema);
- Assert.Equal(ss.Count, 1);
+ Assert.Equal(1, ss.Count);
ss.Compile();
- Assert.Equal(ss.Count, 1);
+ Assert.Equal(1, ss.Count);
XmlReaderSettings settings = new XmlReaderSettings();
settings.Schemas = ss;
}
XmlSchema removedSchema = ss.Remove(schema);
- Assert.Equal(ss.Count, 0);
+ Assert.Equal(0, ss.Count);
ss.Compile();
- Assert.Equal(ss.Count, 0);
+ Assert.Equal(0, ss.Count);
settings = new XmlReaderSettings();
settings.Schemas = ss;
ValidationEventHandler valEventHandler = new ValidationEventHandler(ValidationCallback);
doc.Validate(valEventHandler);
- Assert.Equal(warningCount, 0);
- Assert.Equal(errorCount, 0);
+ Assert.Equal(0, warningCount);
+ Assert.Equal(0, errorCount);
}
}
ValidationEventHandler valEventHandler = new ValidationEventHandler(ValidationCallback);
doc.Validate(valEventHandler);
- Assert.Equal(warningCount, 0);
- Assert.Equal(errorCount, 0);
+ Assert.Equal(0, warningCount);
+ Assert.Equal(0, errorCount);
}
}
while (r.Read()) ;
}
- Assert.Equal(warningCount, 0);
- Assert.Equal(errorCount, 0);
+ Assert.Equal(0, warningCount);
+ Assert.Equal(0, errorCount);
return;
}
xss.Add(schema);
xss.Compile();
- Assert.Equal(warningCount, 0);
- Assert.Equal(errorCount, 0);
+ Assert.Equal(0, warningCount);
+ Assert.Equal(0, errorCount);
return;
}
while (r.Read()) ;
}
- Assert.Equal(warningCount, 0);
- Assert.Equal(errorCount, 2);
+ Assert.Equal(0, warningCount);
+ Assert.Equal(2, errorCount);
return;
}
while (r.Read()) ;
}
- Assert.Equal(warningCount, 0);
- Assert.Equal(errorCount, 1);
+ Assert.Equal(0, warningCount);
+ Assert.Equal(1, errorCount);
return;
}
}
val.EndValidation();
Assert.True(!holder.IsCalledA);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.TextOnly);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.TextOnly, info.ContentType);
return;
}
val.EndValidation();
Assert.True(!holder.IsCalledA);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.Mixed);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.Mixed, info.ContentType);
return;
}
val.EndValidation();
Assert.True(!holder.IsCalledA);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.ElementOnly);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.ElementOnly, info.ContentType);
return;
}
val.ValidateEndOfAttributes(null);
val.ValidateEndElement(info);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.TextOnly);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.TextOnly, info.ContentType);
}
val.ValidateEndElement(info);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.ElementOnly);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.ElementOnly, info.ContentType);
val.EndValidation();
val.ValidateEndElement(info);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.ElementOnly);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.ElementOnly, info.ContentType);
val.EndValidation();
val.ValidateEndElement(info);
Assert.True(holder.IsCalledA);
- Assert.Equal(holder.lastSeverity, XmlSeverityType.Error);
- Assert.Equal(info.Validity, XmlSchemaValidity.Invalid);
+ Assert.Equal(XmlSeverityType.Error, holder.lastSeverity);
+ Assert.Equal(XmlSchemaValidity.Invalid, info.Validity);
return;
}
val.ValidateEndElement(info);
val.EndValidation();
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.TextOnly);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.TextOnly, info.ContentType);
return;
}
val.ValidateEndElement(info, "123");
val.EndValidation();
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.TextOnly);
- Assert.Equal(info.IsDefault, false);
- Assert.Equal(info.IsNil, false);
- Assert.Equal(info.SchemaType.TypeCode, XmlTypeCode.Int);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.TextOnly, info.ContentType);
+ Assert.False(info.IsDefault);
+ Assert.False(info.IsNil);
+ Assert.Equal(XmlTypeCode.Int, info.SchemaType.TypeCode);
return;
}
val.ValidateEndElement(info);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.Empty);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.Empty, info.ContentType);
val.EndValidation();
else
val.ValidateEndElement(info, "false");
- Assert.Equal(info.MemberType.TypeCode, XmlTypeCode.Boolean);
+ Assert.Equal(XmlTypeCode.Boolean, info.MemberType.TypeCode);
return;
}
val.SkipToEndElement(info);
val.EndValidation();
- Assert.Equal(info.Validity, XmlSchemaValidity.NotKnown);
+ Assert.Equal(XmlSchemaValidity.NotKnown, info.Validity);
return;
}
val.ValidateText(StringGetter("foo"));
val.SkipToEndElement(info);
- Assert.Equal(info.Validity, XmlSchemaValidity.NotKnown);
+ Assert.Equal(XmlSchemaValidity.NotKnown, info.Validity);
return;
}
val.ValidateAttribute("attr1", "", StringGetter("foo"), info);
val.SkipToEndElement(info);
- Assert.Equal(info.Validity, XmlSchemaValidity.NotKnown);
+ Assert.Equal(XmlSchemaValidity.NotKnown, info.Validity);
return;
}
Assert.True(false);
}
}
-}
\ No newline at end of file
+}
val.EndValidation();
Assert.True(!holder.IsCalledA);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.TextOnly);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.TextOnly, info.ContentType);
return;
}
val.EndValidation();
Assert.True(!holder.IsCalledA);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.Mixed);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.Mixed, info.ContentType);
return;
}
Assert.True(false);
}
}
-}
\ No newline at end of file
+}
val.EndValidation();
Assert.True(!holder.IsCalledA);
- Assert.Equal(info.Validity, XmlSchemaValidity.Valid);
- Assert.Equal(info.ContentType, XmlSchemaContentType.ElementOnly);
+ Assert.Equal(XmlSchemaValidity.Valid, info.Validity);
+ Assert.Equal(XmlSchemaContentType.ElementOnly, info.ContentType);
return;
}
return;
}
}
-}
\ No newline at end of file
+}
val.ValidateEndElement(si);
val.ValidateEndElement(si);
- Assert.Equal(warningCount, 0);
- Assert.Equal(errorCount, 0);
+ Assert.Equal(0, warningCount);
+ Assert.Equal(0, errorCount);
}
public void ValidateWithXmlReader(XmlSchemaSet schemas, string xml, string xsd)
{
while (r.Read()) ;
}
- Assert.Equal(warningCount, 0);
- Assert.Equal(errorCount, 0);
+ Assert.Equal(0, warningCount);
+ Assert.Equal(0, errorCount);
}
public void ValidateSchemaSet(XmlSchemaSet ss, int schCount, bool isCompiled, int countGT, int countGE, int countGA, string str)
[Fact]
public static void Xml_BoolAsRoot()
{
- Assert.StrictEqual(SerializeAndDeserialize<bool>(true,
+ Assert.True(SerializeAndDeserialize<bool>(true,
@"<?xml version=""1.0""?>
-<boolean>true</boolean>"), true);
- Assert.StrictEqual(SerializeAndDeserialize<bool>(false,
+<boolean>true</boolean>"));
+ Assert.False(SerializeAndDeserialize<bool>(false,
@"<?xml version=""1.0""?>
-<boolean>false</boolean>"), false);
+<boolean>false</boolean>"));
}
[Fact]
Assert.StrictEqual(SerializeAndDeserialize<char>(char.MaxValue,
@"<?xml version=""1.0""?>
<char>65535</char>"), char.MaxValue);
- Assert.StrictEqual(SerializeAndDeserialize<char>('a',
+ Assert.StrictEqual('a', SerializeAndDeserialize<char>('a',
@"<?xml version=""1.0""?>
-<char>97</char>"), 'a');
- Assert.StrictEqual(SerializeAndDeserialize<char>('ñ',
+<char>97</char>"));
+ Assert.StrictEqual('\u00F1', SerializeAndDeserialize<char>('\u00F1',
@"<?xml version=""1.0""?>
-<char>241</char>"), 'ñ');
- Assert.StrictEqual(SerializeAndDeserialize<char>('æ¼¢',
+<char>241</char>"));
+ Assert.StrictEqual('\u6F22', SerializeAndDeserialize<char>('\u6F22',
@"<?xml version=""1.0""?>
-<char>28450</char>"), 'æ¼¢');
+<char>28450</char>"));
}
[Fact]
public static void Xml_ByteAsRoot()
{
- Assert.StrictEqual(SerializeAndDeserialize<byte>(10,
+ Assert.StrictEqual(10, SerializeAndDeserialize<byte>(10,
@"<?xml version=""1.0""?>
-<unsignedByte>10</unsignedByte>"), 10);
+<unsignedByte>10</unsignedByte>"));
Assert.StrictEqual(SerializeAndDeserialize<byte>(byte.MinValue,
@"<?xml version=""1.0""?>
<unsignedByte>0</unsignedByte>"), byte.MinValue);
Assert.StrictEqual(SerializeAndDeserialize<double>(-1.2,
@"<?xml version=""1.0""?>
<double>-1.2</double>"), -1.2);
- Assert.StrictEqual(SerializeAndDeserialize<double>(0,
+ Assert.StrictEqual(0, SerializeAndDeserialize<double>(0,
@"<?xml version=""1.0""?>
-<double>0</double>"), 0);
- Assert.StrictEqual(SerializeAndDeserialize<double>(2.3,
+<double>0</double>"));
+ Assert.StrictEqual(2.3, SerializeAndDeserialize<double>(2.3,
@"<?xml version=""1.0""?>
-<double>2.3</double>"), 2.3);
+<double>2.3</double>"));
Assert.StrictEqual(SerializeAndDeserialize<double>(double.MinValue,
@"<?xml version=""1.0""?>
<double>-1.7976931348623157E+308</double>"), double.MinValue);
[Fact]
public static void Xml_ObjectAsRoot()
{
- Assert.StrictEqual(SerializeAndDeserialize<object>(1,
+ Assert.StrictEqual(1, SerializeAndDeserialize<object>(1,
@"<?xml version=""1.0""?>
-<anyType xmlns:q1=""http://www.w3.org/2001/XMLSchema"" d1p1:type=""q1:int"" xmlns:d1p1=""http://www.w3.org/2001/XMLSchema-instance"">1</anyType>"), 1);
- Assert.StrictEqual(SerializeAndDeserialize<object>(true,
+<anyType xmlns:q1=""http://www.w3.org/2001/XMLSchema"" d1p1:type=""q1:int"" xmlns:d1p1=""http://www.w3.org/2001/XMLSchema-instance"">1</anyType>"));
+ Assert.StrictEqual(true, SerializeAndDeserialize<object>(true,
@"<?xml version=""1.0""?>
-<anyType xmlns:q1=""http://www.w3.org/2001/XMLSchema"" d1p1:type=""q1:boolean"" xmlns:d1p1=""http://www.w3.org/2001/XMLSchema-instance"">true</anyType>"), true);
- Assert.StrictEqual(SerializeAndDeserialize<object>("abc",
+<anyType xmlns:q1=""http://www.w3.org/2001/XMLSchema"" d1p1:type=""q1:boolean"" xmlns:d1p1=""http://www.w3.org/2001/XMLSchema-instance"">true</anyType>"));
+ Assert.StrictEqual("abc", SerializeAndDeserialize<object>("abc",
@"<?xml version=""1.0""?>
-<anyType xmlns:q1=""http://www.w3.org/2001/XMLSchema"" d1p1:type=""q1:string"" xmlns:d1p1=""http://www.w3.org/2001/XMLSchema-instance"">abc</anyType>"), "abc");
- Assert.StrictEqual(SerializeAndDeserialize<object>(null,
-@"<?xml version=""1.0""?><anyType xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xsi:nil=""true"" />"), null);
+<anyType xmlns:q1=""http://www.w3.org/2001/XMLSchema"" d1p1:type=""q1:string"" xmlns:d1p1=""http://www.w3.org/2001/XMLSchema-instance"">abc</anyType>"));
+ Assert.Null(SerializeAndDeserialize<object>(null,
+@"<?xml version=""1.0""?><anyType xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xsi:nil=""true"" />"));
}
[Fact]
[Fact]
public static void Xml_StringAsRoot()
{
- Assert.StrictEqual(SerializeAndDeserialize<string>("abc",
+ Assert.StrictEqual("abc", SerializeAndDeserialize<string>("abc",
@"<?xml version=""1.0""?>
-<string>abc</string>"), "abc");
- Assert.StrictEqual(SerializeAndDeserialize<string>(" a b ",
+<string>abc</string>"));
+ Assert.StrictEqual(" a b ", SerializeAndDeserialize<string>(" a b ",
@"<?xml version=""1.0""?>
-<string> a b </string>"), " a b ");
- Assert.StrictEqual(SerializeAndDeserialize<string>(null,
+<string> a b </string>"));
+ Assert.Null(SerializeAndDeserialize<string>(null,
@"<?xml version=""1.0""?>
-<string d1p1:nil=""true"" xmlns:d1p1=""http://www.w3.org/2001/XMLSchema-instance"" />"), null);
- Assert.StrictEqual(SerializeAndDeserialize<string>("",
+<string d1p1:nil=""true"" xmlns:d1p1=""http://www.w3.org/2001/XMLSchema-instance"" />"));
+ Assert.StrictEqual("", SerializeAndDeserialize<string>("",
@"<?xml version=""1.0""?>
-<string />"), "");
+<string />"));
Assert.StrictEqual(SerializeAndDeserialize<string>(" ",
@"<?xml version=""1.0""?>
<string> </string>"), string.Empty);
- Assert.StrictEqual(SerializeAndDeserialize<string>("Hello World! 漢 ñ",
+ Assert.StrictEqual("Hello World! \u6F22 \u00F1", SerializeAndDeserialize<string>("Hello World! \u6F22 \u00F1",
@"<?xml version=""1.0""?>
-<string>Hello World! 漢 ñ</string>"), "Hello World! 漢 ñ");
+<string>Hello World! 漢 ñ</string>"));
}
[Fact]
public static void Xml_DefaultNamespaceChangeTest()
{
Assert.StrictEqual(
+ "Teststring",
SerializeAndDeserialize<string>("Teststring",
@"<?xml version=""1.0""?>
<string xmlns=""MycustomDefaultNamespace"">Teststring</string>",
- () => { return new XmlSerializer(typeof(string), "MycustomDefaultNamespace"); }),
- "Teststring");
+ () => { return new XmlSerializer(typeof(string), "MycustomDefaultNamespace"); }));
}
[Fact]
[Fact]
public static void Xml_EnumAsRoot()
{
- Assert.StrictEqual(SerializeAndDeserialize<MyEnum>(MyEnum.Two,
+ Assert.StrictEqual(MyEnum.Two, SerializeAndDeserialize<MyEnum>(MyEnum.Two,
@"<?xml version=""1.0""?>
-<MyEnum>Two</MyEnum>"), MyEnum.Two);
- Assert.StrictEqual(SerializeAndDeserialize<ByteEnum>(ByteEnum.Option1,
+<MyEnum>Two</MyEnum>"));
+ Assert.StrictEqual(ByteEnum.Option1, SerializeAndDeserialize<ByteEnum>(ByteEnum.Option1,
@"<?xml version=""1.0""?>
-<ByteEnum>Option1</ByteEnum>"), ByteEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<SByteEnum>(SByteEnum.Option1,
+<ByteEnum>Option1</ByteEnum>"));
+ Assert.StrictEqual(SByteEnum.Option1, SerializeAndDeserialize<SByteEnum>(SByteEnum.Option1,
@"<?xml version=""1.0""?>
-<SByteEnum>Option1</SByteEnum>"), SByteEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<ShortEnum>(ShortEnum.Option1,
+<SByteEnum>Option1</SByteEnum>"));
+ Assert.StrictEqual(ShortEnum.Option1, SerializeAndDeserialize<ShortEnum>(ShortEnum.Option1,
@"<?xml version=""1.0""?>
-<ShortEnum>Option1</ShortEnum>"), ShortEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<IntEnum>(IntEnum.Option1,
+<ShortEnum>Option1</ShortEnum>"));
+ Assert.StrictEqual(IntEnum.Option1, SerializeAndDeserialize<IntEnum>(IntEnum.Option1,
@"<?xml version=""1.0""?>
-<IntEnum>Option1</IntEnum>"), IntEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<UIntEnum>(UIntEnum.Option1,
+<IntEnum>Option1</IntEnum>"));
+ Assert.StrictEqual(UIntEnum.Option1, SerializeAndDeserialize<UIntEnum>(UIntEnum.Option1,
@"<?xml version=""1.0""?>
-<UIntEnum>Option1</UIntEnum>"), UIntEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<LongEnum>(LongEnum.Option1,
+<UIntEnum>Option1</UIntEnum>"));
+ Assert.StrictEqual(LongEnum.Option1, SerializeAndDeserialize<LongEnum>(LongEnum.Option1,
@"<?xml version=""1.0""?>
-<LongEnum>Option1</LongEnum>"), LongEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<ULongEnum>(ULongEnum.Option1,
+<LongEnum>Option1</LongEnum>"));
+ Assert.StrictEqual(
ULongEnum.Option1, SerializeAndDeserialize<ULongEnum>(ULongEnum.Option1,
@"<?xml version=""1.0""?>
-<ULongEnum>Option1</ULongEnum>"), ULongEnum.Option1);
+<ULongEnum>Option1</ULongEnum>"));
}
[Fact]
var actual = SerializeAndDeserialize<TypeWithPropertyNameSpecified>(value,
@"<?xml version=""1.0""?><TypeWithPropertyNameSpecified xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema""><MyField>MyField</MyField></TypeWithPropertyNameSpecified>");
Assert.StrictEqual(value.MyField, actual.MyField);
- Assert.StrictEqual(actual.MyFieldIgnored, 0);
+ Assert.StrictEqual(0, actual.MyFieldIgnored);
}
[Fact]
switch ((int)param2)
{
case 2:
- Assert.Equal(os.OutputMethod, XmlOutputMethod.AutoDetect);
+ Assert.Equal(XmlOutputMethod.AutoDetect, os.OutputMethod);
break;
case 3:
- Assert.Equal(os.OutputMethod, XmlOutputMethod.Xml);
+ Assert.Equal(XmlOutputMethod.Xml, os.OutputMethod);
break;
case 4:
- Assert.Equal(os.OutputMethod, XmlOutputMethod.Html);
+ Assert.Equal(XmlOutputMethod.Html, os.OutputMethod);
break;
case 5:
- Assert.Equal(os.OutputMethod, XmlOutputMethod.Text);
+ Assert.Equal(XmlOutputMethod.Text, os.OutputMethod);
break;
case 6:
- Assert.Equal(os.OutputMethod, XmlOutputMethod.AutoDetect);
+ Assert.Equal(XmlOutputMethod.AutoDetect, os.OutputMethod);
break;
case 7:
- Assert.Equal(os.OutputMethod, XmlOutputMethod.Text);
+ Assert.Equal(XmlOutputMethod.Text, os.OutputMethod);
break;
case 8:
- Assert.Equal(os.OutputMethod, XmlOutputMethod.Xml);
+ Assert.Equal(XmlOutputMethod.Xml, os.OutputMethod);
break;
case 9:
- Assert.Equal(os.OutputMethod, XmlOutputMethod.Html);
+ Assert.Equal(XmlOutputMethod.Html, os.OutputMethod);
break;
}
{
_output.WriteLine(e.ToString());
XmlWriterSettings os = _xsl.OutputSettings;
- Assert.Equal(os, null);
+ Assert.Null(os);
}
return;
{
_output.WriteLine(e.ToString());
XmlWriterSettings os = _xsl.OutputSettings;
- Assert.Equal(os, null);
+ Assert.Null(os);
}
return;
{
_output.WriteLine(e.ToString());
XmlWriterSettings os = _xsl.OutputSettings;
- Assert.Equal(os, null);
+ Assert.Null(os);
}
return;
{
_output.WriteLine(e.ToString());
XmlWriterSettings os = _xsl.OutputSettings;
- Assert.Equal(os, null);
+ Assert.Null(os);
}
return;
_xsl.Load(_xslFile);
XmlWriterSettings os = _xsl.OutputSettings;
_output.WriteLine("OmitXmlDeclaration : {0}", os.OmitXmlDeclaration);
- Assert.Equal(os.OmitXmlDeclaration, true);
+ Assert.True(os.OmitXmlDeclaration);
_output.WriteLine("Indent : {0}", os.Indent);
- Assert.Equal(os.Indent, true);
+ Assert.True(os.Indent);
_output.WriteLine("OutputMethod : {0}", os.OutputMethod);
- Assert.Equal(os.OutputMethod, XmlOutputMethod.Xml);
+ Assert.Equal(XmlOutputMethod.Xml, os.OutputMethod);
_output.WriteLine("Encoding : {0}", os.Encoding.ToString());
Assert.Equal(os.Encoding, System.Text.Encoding.GetEncoding("utf-8"));
Assert.True(field.IsStatic);
Assert.Equal((attributes & FieldAttributes.Public) != 0 , field.IsPublic);
Assert.Equal((attributes & FieldAttributes.Private) != 0, field.IsPrivate);
- Assert.Equal(field.Name, "MyField");
+ Assert.Equal("MyField", field.Name);
}
[Fact]
var reader1 = provider.GetMetadataReader(MetadataReaderOptions.None, decoder);
Assert.Equal("str", reader1.MetadataVersion);
Assert.Same(reader1.UTF8Decoder, decoder);
- Assert.Equal(reader1.Options, MetadataReaderOptions.None);
+ Assert.Equal(MetadataReaderOptions.None, reader1.Options);
var reader2 = provider.GetMetadataReader(MetadataReaderOptions.None, decoder);
Assert.Same(reader1, reader2);
Assert.NotSame(reader2, reader3);
Assert.Equal("v9.9.9.9", reader3.MetadataVersion);
Assert.Same(reader3.UTF8Decoder, MetadataStringDecoder.DefaultUTF8);
- Assert.Equal(reader3.Options, MetadataReaderOptions.None);
+ Assert.Equal(MetadataReaderOptions.None, reader3.Options);
var reader4 = provider.GetMetadataReader(MetadataReaderOptions.None);
Assert.Same(reader3, reader4);
Assert.NotSame(reader4, reader5);
Assert.Equal("v9.9.9.9", reader5.MetadataVersion);
Assert.Same(reader5.UTF8Decoder, MetadataStringDecoder.DefaultUTF8);
- Assert.Equal(reader5.Options, MetadataReaderOptions.ApplyWindowsRuntimeProjections);
+ Assert.Equal(MetadataReaderOptions.ApplyWindowsRuntimeProjections, reader5.Options);
provider.Dispose();
Assert.Throws<ObjectDisposedException>(() => provider.GetMetadataReader(MetadataReaderOptions.ApplyWindowsRuntimeProjections));
var sig = reader.GetBlobBytes(row.Signature);
// calling convention, always 6 for field
- Assert.Equal(sig[0], 6);
+ Assert.Equal(6, sig[0]);
int len = 0;
if (isMod)
{
{
var reader = GetMetadataReader(Interop.OtherAccessors);
var typeDef = reader.GetTypeDefinition(reader.TypeDefinitions.First());
- Assert.Equal(reader.GetString(typeDef.Name), "<Module>");
+ Assert.Equal("<Module>", reader.GetString(typeDef.Name));
typeDef = reader.GetTypeDefinition(reader.TypeDefinitions.Skip(1).First());
- Assert.Equal(reader.GetString(typeDef.Name), "IContainerObject");
+ Assert.Equal("IContainerObject", reader.GetString(typeDef.Name));
var propertyDef = reader.GetPropertyDefinition(typeDef.GetProperties().First());
var propertyAccessors = propertyDef.GetAccessors();
Assert.Equal("let_Value", reader.GetString(reader.GetMethodDefinition(propertyAccessors.Others.Single()).Name));
typeDef = reader.GetTypeDefinition(reader.TypeDefinitions.Skip(2).First());
- Assert.Equal(reader.GetString(typeDef.Name), "IEventSource");
+ Assert.Equal("IEventSource", reader.GetString(typeDef.Name));
var eventDef = reader.GetEventDefinition(typeDef.GetEvents().First());
var eventAccessors = eventDef.GetAccessors();
fixed (byte* bufferPtr2 = buffer2)
{
var reader = new BlobReader(new MemoryBlock(bufferPtr2, buffer2.Length));
- Assert.Equal(reader.Offset, 0);
+ Assert.Equal(0, reader.Offset);
Assert.Equal(0x0807060504030201UL, reader.ReadUInt64());
- Assert.Equal(reader.Offset, 8);
+ Assert.Equal(8, reader.Offset);
reader.Reset();
- Assert.Equal(reader.Offset, 0);
+ Assert.Equal(0, reader.Offset);
Assert.Equal(0x0807060504030201L, reader.ReadInt64());
reader.Reset();
- Assert.Equal(reader.Offset, 0);
+ Assert.Equal(0, reader.Offset);
Assert.Equal(BitConverter.ToDouble(buffer2, 0), reader.ReadDouble());
}
}
Assert.Equal("\u0001", block.PeekUtf8NullTerminated(1, null, stringDecoder, out bytesRead));
- Assert.Equal(bytesRead, 2);
+ Assert.Equal(2, bytesRead);
Assert.Equal("\u0002", block.PeekUtf8NullTerminated(3, null, stringDecoder, out bytesRead));
- Assert.Equal(bytesRead, 1);
+ Assert.Equal(1, bytesRead);
Assert.Equal("", block.PeekUtf8NullTerminated(4, null, stringDecoder, out bytesRead));
- Assert.Equal(bytesRead, 0);
+ Assert.Equal(0, bytesRead);
byte[] helloPrefix = Encoding.UTF8.GetBytes("Hello");
Assert.Equal("Hello\u0001", block.PeekUtf8NullTerminated(1, helloPrefix, stringDecoder, out bytesRead));
- Assert.Equal(bytesRead, 2);
+ Assert.Equal(2, bytesRead);
Assert.Equal("Hello\u0002", block.PeekUtf8NullTerminated(3, helloPrefix, stringDecoder, out bytesRead));
- Assert.Equal(bytesRead, 1);
+ Assert.Equal(1, bytesRead);
Assert.Equal("Hello", block.PeekUtf8NullTerminated(4, helloPrefix, stringDecoder, out bytesRead));
- Assert.Equal(bytesRead, 0);
+ Assert.Equal(0, bytesRead);
}
}
Assert.Throws<FileNotFoundException>(() => t.BaseType);
Assert.Same(lc, resolver.Context);
- Assert.Equal(resolver.AssemblyName.Name, "Foo");
+ Assert.Equal("Foo", resolver.AssemblyName.Name);
Assert.Equal(2, resolver.CallCount);
}
}
Type bt = t.BaseType;
Assert.Same(lc, resolver.Context);
- Assert.Equal(resolver.AssemblyName.Name, "Foo");
+ Assert.Equal("Foo", resolver.AssemblyName.Name);
Assert.Equal(2, resolver.CallCount);
Assembly a = bt.Assembly;
Type systemInt32 = type.BaseType.Assembly.GetType("System.Int32", throwOnError: true);
ConstructorInfo[] cis = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly);
- Assert.Equal(cis.Length, 2);
+ Assert.Equal(2, cis.Length);
ConstructorInfo c1 = cis.Single(c => c.GetParameters().Length == rank);
foreach (ParameterInfo p in c1.GetParameters())
Assert.Equal(p.ParameterType, systemInt32);
Type t = typeof(TestClass).Project();
MemberInfo[] members = t.GetMember("My*", MemberTypes.Event, BindingFlags.Public | BindingFlags.Instance);
- Assert.Equal(members.Length, 1);
+ Assert.Equal(1, members.Length);
Assert.Equal("MyEvent", members[0].Name);
}
Type t = typeof(TestClass).Project();
MemberInfo[] members = t.GetMember("My*", MemberTypes.Field, BindingFlags.Public | BindingFlags.Instance);
- Assert.Equal(members.Length, 1);
+ Assert.Equal(1, members.Length);
Assert.Equal("MyField", members[0].Name);
}
Type t = typeof(TestClass).Project();
MemberInfo[] members = t.GetMember("My*", MemberTypes.Method, BindingFlags.Public | BindingFlags.Instance);
- Assert.Equal(members.Length, 1);
+ Assert.Equal(1, members.Length);
Assert.Equal("MyMethod", members[0].Name);
}
Type t = typeof(TestClass).Project();
MemberInfo[] members = t.GetMember("My*", MemberTypes.NestedType, BindingFlags.Public | BindingFlags.Instance);
- Assert.Equal(members.Length, 1);
+ Assert.Equal(1, members.Length);
Assert.Equal("MyNestedType", members[0].Name);
}
Type t = typeof(TestClass).Project();
MemberInfo[] members = t.GetMember("My*", MemberTypes.Property, BindingFlags.Public | BindingFlags.Instance);
- Assert.Equal(members.Length, 1);
+ Assert.Equal(1, members.Length);
Assert.Equal("MyProperty", members[0].Name);
}
// Fields return the most derived match.
FieldInfo f = t.GetField("myfield", bf);
- Assert.Equal(f.Name, "MyField");
+ Assert.Equal("MyField", f.Name);
// Unless two of them are both the most derived match...
Assert.Throws<AmbiguousMatchException>(() => t.GetField("myfield2", bf));
// Methods return the most derived match, provided all their signatures are the same.
MethodInfo m1 = t.GetMethod("mymethod1", bf);
- Assert.Equal(m1.Name, "MyMethod1");
+ Assert.Equal("MyMethod1", m1.Name);
MethodInfo m2 = t.GetMethod("mymethod2", bf);
- Assert.Equal(m2.Name, "MyMethod2");
+ Assert.Equal("MyMethod2", m2.Name);
// Unless two of them are both the most derived match...
Assert.Throws<AmbiguousMatchException>(() => t.GetMethod("mymethod3", bf));
Type t = typeof(long[]).Project();
TypeInfo ti = t.GetTypeInfo();
MethodInfo m = ti.GetDeclaredMethod("Get");
- Assert.Equal(m.Attributes, MethodAttributes.Public | MethodAttributes.PrivateScope);
- Assert.Equal(m.CallingConvention, CallingConventions.Standard | CallingConventions.HasThis);
- Assert.Equal(m.DeclaringType, t);
- Assert.Equal(m.ReturnType, et);
+ Assert.Equal(MethodAttributes.Public | MethodAttributes.PrivateScope, m.Attributes);
+ Assert.Equal(CallingConventions.Standard | CallingConventions.HasThis, m.CallingConvention);
+ Assert.Equal(t, m.DeclaringType);
+ Assert.Equal(et, m.ReturnType);
ParameterInfo[] p = m.GetParameters();
- Assert.Equal(p.Length, 1);
+ Assert.Equal(1, p.Length);
- Assert.Equal(p[0].Attributes, ParameterAttributes.None);
- Assert.Equal(p[0].ParameterType, typeof(int).Project());
- Assert.Equal(p[0].Member, m);
- Assert.Equal(p[0].Position, 0);
- Assert.Equal(p[0].Name, null);
- Assert.Equal(p[0].HasDefaultValue, expectedDefaultValue);
- Assert.Equal(p[0].RawDefaultValue, null); //Legacy: This makes no sense
+ Assert.Equal(ParameterAttributes.None, p[0].Attributes);
+ Assert.Equal(typeof(int).Project(), p[0].ParameterType);
+ Assert.Equal(m, p[0].Member);
+ Assert.Equal(0, p[0].Position);
+ Assert.Null(p[0].Name);
+ Assert.Equal(expectedDefaultValue, p[0].HasDefaultValue);
+ Assert.Null(p[0].RawDefaultValue); //Legacy: This makes no sense
return;
}
Type t = typeof(long[]).Project(); ;
TypeInfo ti = t.GetTypeInfo();
MethodInfo m = ti.GetDeclaredMethod("Set");
- Assert.Equal(m.Attributes, MethodAttributes.Public | MethodAttributes.PrivateScope);
- Assert.Equal(m.CallingConvention, CallingConventions.Standard | CallingConventions.HasThis);
+ Assert.Equal(MethodAttributes.Public | MethodAttributes.PrivateScope, m.Attributes);
+ Assert.Equal(CallingConventions.Standard | CallingConventions.HasThis, m.CallingConvention);
- Assert.Equal(m.DeclaringType, t);
- Assert.Equal(m.ReturnType, typeof(void).Project());
+ Assert.Equal(t, m.DeclaringType);
+ Assert.Equal(typeof(void).Project(), m.ReturnType);
ParameterInfo[] p = m.GetParameters();
- Assert.Equal(p.Length, 2);
-
- Assert.Equal(p[0].Attributes, ParameterAttributes.None);
- Assert.Equal(p[0].ParameterType, typeof(int).Project());
- Assert.Equal(p[0].Name, null);
- Assert.Equal(p[0].Member, m);
- Assert.Equal(p[0].Position, 0);
- Assert.Equal(p[0].HasDefaultValue, expectedDefaultValue); //Legacy: This makes no sense
- Assert.Equal(p[0].RawDefaultValue, null); //Legacy: This makes no sense
-
- Assert.Equal(p[1].Attributes, ParameterAttributes.None);
- Assert.Equal(p[1].ParameterType, et);
- Assert.Equal(p[1].Name, null);
- Assert.Equal(p[1].Member, m);
- Assert.Equal(p[1].Position, 1);
- Assert.Equal(p[1].HasDefaultValue, expectedDefaultValue); //Legacy: This makes no sense
- Assert.Equal(p[1].RawDefaultValue, null); //Legacy: This makes no sense
+ Assert.Equal(2, p.Length);
+
+ Assert.Equal(ParameterAttributes.None, p[0].Attributes);
+ Assert.Equal(typeof(int).Project(), p[0].ParameterType);
+ Assert.Null(p[0].Name);
+ Assert.Equal(m, p[0].Member);
+ Assert.Equal(0, p[0].Position);
+ Assert.Equal(expectedDefaultValue, p[0].HasDefaultValue); //Legacy: This makes no sense
+ Assert.Null(p[0].RawDefaultValue); //Legacy: This makes no sense
+
+ Assert.Equal(ParameterAttributes.None, p[1].Attributes);
+ Assert.Equal(et, p[1].ParameterType);
+ Assert.Null(p[1].Name);
+ Assert.Equal(m, p[1].Member);
+ Assert.Equal(1, p[1].Position);
+ Assert.Equal(expectedDefaultValue, p[1].HasDefaultValue); //Legacy: This makes no sense
+ Assert.Null(p[1].RawDefaultValue); //Legacy: This makes no sense
return;
}
Type t = typeof(long[]).Project(); ;
TypeInfo ti = t.GetTypeInfo();
MethodInfo m = ti.GetDeclaredMethod("Address");
- Assert.Equal(m.Attributes, MethodAttributes.Public | MethodAttributes.PrivateScope);
- Assert.Equal(m.CallingConvention, CallingConventions.Standard | CallingConventions.HasThis);
- Assert.Equal(m.DeclaringType, t);
- Assert.Equal(m.ReturnType, et.MakeByRefType());
+ Assert.Equal(MethodAttributes.Public | MethodAttributes.PrivateScope, m.Attributes);
+ Assert.Equal(CallingConventions.Standard | CallingConventions.HasThis, m.CallingConvention);
+ Assert.Equal(t, m.DeclaringType);
+ Assert.Equal(et.MakeByRefType(), m.ReturnType);
ParameterInfo[] p = m.GetParameters();
- Assert.Equal(p.Length, 1);
+ Assert.Equal(1, p.Length);
- Assert.Equal(p[0].Attributes, ParameterAttributes.None);
- Assert.Equal(p[0].ParameterType, typeof(int).Project());
- Assert.Equal(p[0].Name, null);
- Assert.Equal(p[0].Member, m);
- Assert.Equal(p[0].Position, 0);
- Assert.Equal(p[0].HasDefaultValue, expectedDefaultValue);
- Assert.Equal(p[0].RawDefaultValue, null); //Legacy: This makes no sense
+ Assert.Equal(ParameterAttributes.None, p[0].Attributes);
+ Assert.Equal(typeof(int).Project(), p[0].ParameterType);
+ Assert.Null(p[0].Name);
+ Assert.Equal(m, p[0].Member);
+ Assert.Equal(0, p[0].Position);
+ Assert.Equal(expectedDefaultValue, p[0].HasDefaultValue);
+ Assert.Null(p[0].RawDefaultValue); //Legacy: This makes no sense
return;
}
Type t = typeof(long[]).Project(); ;
TypeInfo ti = t.GetTypeInfo();
ConstructorInfo[] ctors = ti.DeclaredConstructors.ToArray();
- Assert.Equal(ctors.Length, 1);
+ Assert.Equal(1, ctors.Length);
ConstructorInfo m = ctors[0];
- Assert.Equal(m.Attributes, MethodAttributes.Public | MethodAttributes.PrivateScope | MethodAttributes.RTSpecialName);
- Assert.Equal(m.CallingConvention, CallingConventions.Standard | CallingConventions.HasThis);
- Assert.Equal(m.DeclaringType, t);
+ Assert.Equal(MethodAttributes.Public | MethodAttributes.PrivateScope | MethodAttributes.RTSpecialName, m.Attributes);
+ Assert.Equal(CallingConventions.Standard | CallingConventions.HasThis, m.CallingConvention);
+ Assert.Equal(t, m.DeclaringType);
ParameterInfo[] p = m.GetParameters();
- Assert.Equal(p.Length, 1);
-
- Assert.Equal(p[0].Attributes, ParameterAttributes.None);
- Assert.Equal(p[0].ParameterType, typeof(int).Project());
- Assert.Equal(p[0].Member, m);
- Assert.Equal(p[0].Position, 0);
- Assert.Equal(p[0].Name, null);
- Assert.Equal(p[0].HasDefaultValue, expectedDefaultValue);
- Assert.Equal(p[0].RawDefaultValue, null); //Legacy: This makes no sense
+ Assert.Equal(1, p.Length);
+
+ Assert.Equal(ParameterAttributes.None, p[0].Attributes);
+ Assert.Equal(typeof(int).Project(), p[0].ParameterType);
+ Assert.Equal(m, p[0].Member);
+ Assert.Equal(0, p[0].Position);
+ Assert.Null(p[0].Name);
+ Assert.Equal(expectedDefaultValue, p[0].HasDefaultValue);
+ Assert.Null(p[0].RawDefaultValue); //Legacy: This makes no sense
return;
}
Assert.NotNull(arraytype);
Assert.True(arraytype.IsArray);
- Assert.Equal(arraytype.GetArrayRank(), 3);
+ Assert.Equal(3, arraytype.GetArrayRank());
Assert.Equal(arraytype.GetElementType(), typeof(char*).Project());
}
Type type = typeof(string).Project();
TypeInfo typeInfo = type.GetTypeInfo();
- Assert.Equal(typeInfo.ToString(), "System.String");
+ Assert.Equal("System.String", typeInfo.ToString());
}
Type type = typeof(int).Project();
TypeInfo typeInfo = type.GetTypeInfo();
- Assert.Equal(typeInfo.ToString(), "System.Int32");
+ Assert.Equal("System.Int32", typeInfo.ToString());
}
TypeInfo ti = t.GetTypeInfo();
string fname = ti.FullName;
- Assert.Equal(fname, "System.Int32");
+ Assert.Equal("System.Int32", fname);
}
[Fact]
public static void TestNamespace()
{
- Assert.Equal(typeof(TypeInfoPropertyBase).Project().GetTypeInfo().Namespace, "System.Reflection.Tests");
- Assert.Equal(typeof(ITest).Project().GetTypeInfo().Namespace, "System.Reflection.Tests");
- Assert.Equal(typeof(MYENUM).Project().GetTypeInfo().Namespace, "System.Reflection.Tests");
- Assert.Equal(typeof(PublicClass).Project().GetTypeInfo().Namespace, "System.Reflection.Tests");
- Assert.Equal(typeof(PublicClass.publicNestedClass).Project().GetTypeInfo().Namespace, "System.Reflection.Tests");
- Assert.Equal(typeof(int).Project().GetTypeInfo().Namespace, "System");
+ Assert.Equal("System.Reflection.Tests", typeof(TypeInfoPropertyBase).Project().GetTypeInfo().Namespace);
+ Assert.Equal("System.Reflection.Tests", typeof(ITest).Project().GetTypeInfo().Namespace);
+ Assert.Equal("System.Reflection.Tests", typeof(MYENUM).Project().GetTypeInfo().Namespace);
+ Assert.Equal("System.Reflection.Tests", typeof(PublicClass).Project().GetTypeInfo().Namespace);
+ Assert.Equal("System.Reflection.Tests", typeof(PublicClass.publicNestedClass).Project().GetTypeInfo().Namespace);
+ Assert.Equal("System", typeof(int).Project().GetTypeInfo().Namespace);
}
// VerifyIsImport
if (validLengths1[j] == 0)
{
- Assert.Equal(arr.Length, 0);
+ Assert.Equal(0, arr.Length);
}
else
{
public void GetFiles()
{
Assert.NotNull(typeof(AssemblyTests).Assembly.GetFiles());
- Assert.Equal(typeof(AssemblyTests).Assembly.GetFiles().Length, 1);
+ Assert.Equal(1, typeof(AssemblyTests).Assembly.GetFiles().Length);
Assert.Equal(typeof(AssemblyTests).Assembly.GetFiles()[0].Name, typeof(AssemblyTests).Assembly.Location);
}
public void Invoke()
{
ConstructorInfo[] constructors = GetConstructors(typeof(ClassWith3Constructors));
- Assert.Equal(constructors.Length, 3);
+ Assert.Equal(3, constructors.Length);
ClassWith3Constructors obj = (ClassWith3Constructors)constructors[0].Invoke(null);
Assert.NotNull(obj);
}
{
ConstructorInfo[] constructors = GetConstructors(typeof(ClassWith3Constructors));
ClassWith3Constructors obj = (ClassWith3Constructors)constructors[1].Invoke(new object[] { 100 });
- Assert.Equal(obj.intValue, 100);
+ Assert.Equal(100, obj.intValue);
}
[Fact]
{
ConstructorInfo[] constructors = GetConstructors(typeof(ClassWith3Constructors));
ClassWith3Constructors obj = (ClassWith3Constructors)constructors[2].Invoke(new object[] { 101, "hello" });
- Assert.Equal(obj.intValue, 101);
- Assert.Equal(obj.stringValue, "hello");
+ Assert.Equal(101, obj.intValue);
+ Assert.Equal("hello", obj.stringValue);
}
[Fact]
ClassWith3Constructors obj1 = new ClassWith3Constructors(100, "hello");
ClassWith3Constructors obj2 = (ClassWith3Constructors)constructors[2].Invoke(obj1, new object[] { 999, "initialized" });
Assert.Null(obj2);
- Assert.Equal(obj1.intValue, 999);
- Assert.Equal(obj1.stringValue, "initialized");
+ Assert.Equal(999, obj1.intValue);
+ Assert.Equal("initialized", obj1.stringValue);
}
[Fact]
mc.Set("key", "value", cip);
mc.Dispose();
- Assert.Equal(reason, CacheEntryRemovedReason.CacheSpecificEviction);
+ Assert.Equal(CacheEntryRemovedReason.CacheSpecificEviction, reason);
}
}
}
{
AppDomain.CurrentDomain.ResourceResolve -= handler;
}
- Assert.Equal(s, "Happy Halloween");
+ Assert.Equal("Happy Halloween", s);
return RemoteExecutor.SuccessExitCode;
}).Dispose();
}
char[] carray = new char[352];
int length = Convert.ToBase64CharArray(barray, 0, barray.Length, carray, 0, Base64FormattingOptions.InsertLineBreaks);
int length2 = Convert.ToBase64CharArray(barray, 0, barray.Length, carray, 0, Base64FormattingOptions.None);
- Assert.Equal(length, 352);
- Assert.Equal(length, 352);
+ Assert.Equal(352, length);
+ Assert.Equal(352, length);
}
[Fact]
{
Environment.SetEnvironmentVariable(varName, value);
Environment.SetEnvironmentVariable(varName, null);
- Assert.Equal(Environment.GetEnvironmentVariable(varName), null);
- Assert.Equal(Environment.GetEnvironmentVariable(varNamePrefix), null);
+ Assert.Null(Environment.GetEnvironmentVariable(varName));
+ Assert.Null(Environment.GetEnvironmentVariable(varNamePrefix));
}
finally
{
{
string s = Path.GetRandomFileName();
Assert.Equal(s.Length, 8 + 1 + 3);
- Assert.Equal(s[8], '.');
+ Assert.Equal('.', s[8]);
Assert.Equal(-1, s.IndexOfAny(invalidChars));
Assert.True(fileNames.Add(s));
}
{
BigInteger junk;
BigInteger.TryParse("1", invalid, null, out junk);
- Assert.Equal(junk.ToString("d"), "1");
+ Assert.Equal("1", junk.ToString("d"));
});
//FormatProvider tests
if (x == 0)
{
- Assert.Equal(expected, "0");
+ Assert.Equal("0", expected);
}
else
{
}
catch (ArgumentException ex)
{
- Assert.Equal(ex.GetType().Name, "RegexParseException");
+ Assert.Equal("RegexParseException", ex.GetType().Name);
ArgumentException clone = BinaryFormatterHelpers.Clone(ex);
Assert.IsType<ArgumentException>(clone);
}
[Fact]
public static void DCJS_BoolAsRoot()
{
- Assert.StrictEqual(SerializeAndDeserialize<bool>(true, "true"), true);
- Assert.StrictEqual(SerializeAndDeserialize<bool>(false, "false"), false);
+ Assert.True(SerializeAndDeserialize<bool>(true, "true"));
+ Assert.False(SerializeAndDeserialize<bool>(false, "false"));
}
[Fact]
Assert.StrictEqual(SerializeAndDeserialize<char>((char)0x1f, @"""\u001f"""), (char)0x1f);
// Between #1 and #2
- Assert.StrictEqual(SerializeAndDeserialize<char>('a', @"""a"""), 'a'); // 0x0061
+ Assert.StrictEqual('a', SerializeAndDeserialize<char>('a', @"""a""")); // 0x0061
// #2. 0x0085
Assert.StrictEqual(SerializeAndDeserialize<char>((char)0x85, @"""\u0085"""), (char)0x85);
// Between #2 and #3
- Assert.StrictEqual(SerializeAndDeserialize<char>('ñ', @"""ñ"""), 'ñ'); // 0x00F1
+ Assert.StrictEqual('ñ', SerializeAndDeserialize<char>('ñ', @"""ñ""")); // 0x00F1
// #3. 0x2028 - 0x2029
Assert.StrictEqual(SerializeAndDeserialize<char>((char)0x2028, @"""\u2028"""), (char)0x2028);
Assert.StrictEqual(SerializeAndDeserialize<char>((char)0x2029, @"""\u2029"""), (char)0x2029);
// Between #3 and #4
- Assert.StrictEqual(SerializeAndDeserialize<char>('?', @"""?"""), '?'); // 0x6F22
+ Assert.StrictEqual('?', SerializeAndDeserialize<char>('?', @"""?""")); // 0x6F22
// #4. 0xD800 - 0xDFFF
Assert.StrictEqual(SerializeAndDeserialize<char>((char)0xd800, @"""\ud800"""), (char)0xd800);
[Fact]
public static void DCJS_ByteAsRoot()
{
- Assert.StrictEqual(SerializeAndDeserialize<byte>(10, "10"), 10);
+ Assert.StrictEqual(10, SerializeAndDeserialize<byte>(10, "10"));
Assert.StrictEqual(SerializeAndDeserialize<byte>(byte.MinValue, "0"), byte.MinValue);
Assert.StrictEqual(SerializeAndDeserialize<byte>(byte.MaxValue, "255"), byte.MaxValue);
}
public static void DCJS_DoubleAsRoot()
{
Assert.StrictEqual(SerializeAndDeserialize<double>(-1.2, "-1.2"), -1.2);
- Assert.StrictEqual(SerializeAndDeserialize<double>(0, "0"), 0);
- Assert.StrictEqual(SerializeAndDeserialize<double>(2.3, "2.3"), 2.3);
+ Assert.StrictEqual(0, SerializeAndDeserialize<double>(0, "0"));
+ Assert.StrictEqual(2.3, SerializeAndDeserialize<double>(2.3, "2.3"));
Assert.StrictEqual(SerializeAndDeserialize<double>(double.MinValue, "-1.7976931348623157E+308"), double.MinValue);
Assert.StrictEqual(SerializeAndDeserialize<double>(double.MaxValue, "1.7976931348623157E+308"), double.MaxValue);
}
[Fact]
public static void DCJS_ObjectAsRoot()
{
- Assert.StrictEqual(SerializeAndDeserialize<object>(1, "1"), 1);
- Assert.StrictEqual(SerializeAndDeserialize<object>(true, "true"), true);
- Assert.StrictEqual(SerializeAndDeserialize<object>(null, "null"), null);
- Assert.StrictEqual(SerializeAndDeserialize<object>("abc", @"""abc"""), "abc");
+ Assert.StrictEqual(1, SerializeAndDeserialize<object>(1, "1"));
+ Assert.StrictEqual(true, SerializeAndDeserialize<object>(true, "true"));
+ Assert.Null(SerializeAndDeserialize<object>(null, "null"));
+ Assert.StrictEqual("abc", SerializeAndDeserialize<object>("abc", @"""abc"""));
}
[Fact]
Dictionary<string, int> y = SerializeAndDeserialize<Dictionary<string, int>>(x, @"[{""Key"":""one"",""Value"":1},{""Key"":""two"",""Value"":2}]");
Assert.NotNull(y);
- Assert.Equal(y.Count, 2);
- Assert.Equal(y["one"], 1);
- Assert.Equal(y["two"], 2);
+ Assert.Equal(2, y.Count);
+ Assert.Equal(1, y["one"]);
+ Assert.Equal(2, y["two"]);
}
[Fact]
Assert.True(y.Count == 2);
string actual = string.Join("", y);
- Assert.StrictEqual(actual, "a1a2");
+ Assert.StrictEqual("a1a2", actual);
}
[Fact]
[Fact]
public static void DCJS_EnumAsRoot()
{
- Assert.StrictEqual(SerializeAndDeserialize<MyEnum>(MyEnum.Two, "1"), MyEnum.Two);
- Assert.StrictEqual(SerializeAndDeserialize<ByteEnum>(ByteEnum.Option1, "1"), ByteEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<SByteEnum>(SByteEnum.Option1, "1"), SByteEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<ShortEnum>(ShortEnum.Option1, "1"), ShortEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<IntEnum>(IntEnum.Option1, "1"), IntEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<UIntEnum>(UIntEnum.Option1, "1"), UIntEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<LongEnum>(LongEnum.Option1, "1"), LongEnum.Option1);
- Assert.StrictEqual(SerializeAndDeserialize<ULongEnum>(ULongEnum.Option1, "1"), ULongEnum.Option1);
+ Assert.StrictEqual(MyEnum.Two, SerializeAndDeserialize<MyEnum>(MyEnum.Two, "1"));
+ Assert.StrictEqual(ByteEnum.Option1, SerializeAndDeserialize<ByteEnum>(ByteEnum.Option1, "1"));
+ Assert.StrictEqual(SByteEnum.Option1, SerializeAndDeserialize<SByteEnum>(SByteEnum.Option1, "1"));
+ Assert.StrictEqual(ShortEnum.Option1, SerializeAndDeserialize<ShortEnum>(ShortEnum.Option1, "1"));
+ Assert.StrictEqual(IntEnum.Option1, SerializeAndDeserialize<IntEnum>(IntEnum.Option1, "1"));
+ Assert.StrictEqual(UIntEnum.Option1, SerializeAndDeserialize<UIntEnum>(UIntEnum.Option1, "1"));
+ Assert.StrictEqual(LongEnum.Option1, SerializeAndDeserialize<LongEnum>(LongEnum.Option1, "1"));
+ Assert.StrictEqual(ULongEnum.Option1, SerializeAndDeserialize<ULongEnum>(ULongEnum.Option1, "1"));
}
[Fact]
var y = SerializeAndDeserialize<Dictionary<string, object>>(dict0, @"[{""Key"":""Key0"",""Value"":[{""__type"":""KeyValuePairOfstringanyType:#System.Collections.Generic"",""key"":""Key1-0"",""value"":""Value1-0""},{""__type"":""KeyValuePairOfstringanyType:#System.Collections.Generic"",""key"":""Key1-1"",""value"":[{""__type"":""KeyValuePairOfstringanyType:#System.Collections.Generic"",""key"":""Key2-0"",""value"":""Value2-0""}]}]}]"
);
Assert.NotNull(y);
- Assert.StrictEqual(y.Count, 1);
+ Assert.StrictEqual(1, y.Count);
Assert.True(y["Key0"] is object[]);
- Assert.StrictEqual(((KeyValuePair<string, object>)((object[])y["Key0"])[0]).Key, "Key1-0");
- Assert.StrictEqual(((KeyValuePair<string, object>)((object[])y["Key0"])[0]).Value, "Value1-0");
+ Assert.StrictEqual("Key1-0", ((KeyValuePair<string, object>)((object[])y["Key0"])[0]).Key);
+ Assert.StrictEqual("Value1-0", ((KeyValuePair<string, object>)((object[])y["Key0"])[0]).Value);
Assert.True(((KeyValuePair<string, object>)((object[])y["Key0"])[1]).Value is object[]);
- Assert.StrictEqual(((KeyValuePair<string, object>)((object[])((KeyValuePair<string, object>)((object[])y["Key0"])[1]).Value)[0]).Value, "Value2-0");
+ Assert.StrictEqual("Value2-0", ((KeyValuePair<string, object>)((object[])((KeyValuePair<string, object>)((object[])y["Key0"])[1]).Value)[0]).Value);
}
[Fact]
var x = new KeyValuePair<string, object>("key1", "key1value");
var y = SerializeAndDeserialize<KeyValuePair<string, object>>(x, @"{""key"":""key1"",""value"":""key1value""}");
- Assert.StrictEqual(y.Key, "key1");
- Assert.StrictEqual(y.Value, "key1value");
+ Assert.StrictEqual("key1", y.Key);
+ Assert.StrictEqual("key1value", y.Value);
}
[Fact]
var x = new DictionaryWithVariousKeyValueTypes(true);
var y = SerializeAndDeserialize<DictionaryWithVariousKeyValueTypes>(x, @"{""WithEnums"":[{""Key"":1,""Value"":2},{""Key"":0,""Value"":0}],""WithNullables"":[{""Key"":-32768,""Value"":true},{""Key"":0,""Value"":false},{""Key"":32767,""Value"":null}],""WithStructs"":[{""Key"":{""value"":10},""Value"":{""value"":12}},{""Key"":{""value"":2147483647},""Value"":{""value"":-2147483648}}]}");
- Assert.StrictEqual(y.WithEnums[MyEnum.Two], MyEnum.Three);
- Assert.StrictEqual(y.WithEnums[MyEnum.One], MyEnum.One);
+ Assert.StrictEqual(MyEnum.Three, y.WithEnums[MyEnum.Two]);
+ Assert.StrictEqual(MyEnum.One, y.WithEnums[MyEnum.One]);
Assert.StrictEqual<StructNotSerializable>(y.WithStructs[new StructNotSerializable() { value = 10 }], new StructNotSerializable() { value = 12 });
Assert.StrictEqual<StructNotSerializable>(y.WithStructs[new StructNotSerializable() { value = int.MaxValue }], new StructNotSerializable() { value = int.MinValue });
- Assert.StrictEqual(y.WithNullables[short.MinValue], true);
- Assert.StrictEqual(y.WithNullables[0], false);
- Assert.StrictEqual(y.WithNullables[short.MaxValue], null);
+ Assert.StrictEqual(true, y.WithNullables[short.MinValue]);
+ Assert.StrictEqual(false, y.WithNullables[0]);
+ Assert.Null(y.WithNullables[short.MaxValue]);
}
[Fact]
Assert.StrictEqual((MyEnum)value.EnumValue, (MyEnum)actual.EnumValue);
Assert.True(actual.SimpleTypeValue is SimpleKnownTypeValue);
- Assert.StrictEqual(((SimpleKnownTypeValue)actual.SimpleTypeValue).StrProperty, "PropertyValue");
+ Assert.StrictEqual("PropertyValue", ((SimpleKnownTypeValue)actual.SimpleTypeValue).StrProperty);
}
#region private type has to be in with in the class
sw.Flush();
ms.Seek(0, SeekOrigin.Begin);
var result = (TypeWithDateTimeStringProperty)dcjs.ReadObject(ms);
- Assert.StrictEqual(result.DateTimeString, @"/Date(1411072352108-0700)/");
+ Assert.StrictEqual(@"/Date(1411072352108-0700)/", result.DateTimeString);
}
}
};
var actual4 = SerializeAndDeserialize(jsonTypes.ObjectKeyValue, "{\"1,2#45\":{\"__type\":\"TestClass:#\",\"floatNum\":90,\"intList\":[4,5]},\"6,7#10\":{\"__type\":\"TestStruct:#\",\"value1\":25}}", dcjsSettings);
Assert.NotNull(actual4);
- Assert.Equal(actual4.Count, 2);
+ Assert.Equal(2, actual4.Count);
}
[Fact]
[Fact]
public static void DCS_BoolAsRoot()
{
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<bool>(true, @"<boolean xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">true</boolean>"), true);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<bool>(false, @"<boolean xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">false</boolean>"), false);
+ Assert.True(DataContractSerializerHelper.SerializeAndDeserialize<bool>(true, @"<boolean xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">true</boolean>"));
+ Assert.False(DataContractSerializerHelper.SerializeAndDeserialize<bool>(false, @"<boolean xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">false</boolean>"));
}
[Fact]
{
Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<char>(char.MinValue, @"<char xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">0</char>"), char.MinValue);
Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<char>(char.MaxValue, @"<char xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">65535</char>"), char.MaxValue);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<char>('a', @"<char xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">97</char>"), 'a');
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<char>('ñ', @"<char xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">241</char>"), 'ñ');
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<char>('æ¼¢', @"<char xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">28450</char>"), 'æ¼¢');
+ Assert.StrictEqual('a', DataContractSerializerHelper.SerializeAndDeserialize<char>('a', @"<char xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">97</char>"));
+ Assert.StrictEqual('ñ', DataContractSerializerHelper.SerializeAndDeserialize<char>('ñ', @"<char xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">241</char>"));
+ Assert.StrictEqual('æ¼¢', DataContractSerializerHelper.SerializeAndDeserialize<char>('æ¼¢', @"<char xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">28450</char>"));
}
[Fact]
public static void DCS_ByteAsRoot()
{
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<byte>(10, @"<unsignedByte xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">10</unsignedByte>"), 10);
+ Assert.StrictEqual(10, DataContractSerializerHelper.SerializeAndDeserialize<byte>(10, @"<unsignedByte xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">10</unsignedByte>"));
Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<byte>(byte.MinValue, @"<unsignedByte xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">0</unsignedByte>"), byte.MinValue);
Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<byte>(byte.MaxValue, @"<unsignedByte xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">255</unsignedByte>"), byte.MaxValue);
}
public static void DCS_DoubleAsRoot()
{
Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<double>(-1.2, @"<double xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">-1.2</double>"), -1.2);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<double>(0, @"<double xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">0</double>"), 0);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<double>(2.3, @"<double xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">2.3</double>"), 2.3);
+ Assert.StrictEqual(0, DataContractSerializerHelper.SerializeAndDeserialize<double>(0, @"<double xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">0</double>"));
+ Assert.StrictEqual(2.3, DataContractSerializerHelper.SerializeAndDeserialize<double>(2.3, @"<double xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">2.3</double>"));
Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<double>(double.MinValue, @"<double xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">-1.7976931348623157E+308</double>"), double.MinValue);
Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<double>(double.MaxValue, @"<double xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">1.7976931348623157E+308</double>"), double.MaxValue);
}
[Fact]
public static void DCS_ObjectAsRoot()
{
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<object>(1, @"<z:anyType i:type=""a:int"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/"" xmlns:a=""http://www.w3.org/2001/XMLSchema"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">1</z:anyType>"), 1);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<object>(true, @"<z:anyType i:type=""a:boolean"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/"" xmlns:a=""http://www.w3.org/2001/XMLSchema"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">true</z:anyType>"), true);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<object>("abc", @"<z:anyType i:type=""a:string"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/"" xmlns:a=""http://www.w3.org/2001/XMLSchema"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">abc</z:anyType>"), "abc");
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<object>(null, @"<z:anyType i:nil=""true"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""/>"), null);
+ Assert.StrictEqual(1, DataContractSerializerHelper.SerializeAndDeserialize<object>(1, @"<z:anyType i:type=""a:int"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/"" xmlns:a=""http://www.w3.org/2001/XMLSchema"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">1</z:anyType>"));
+ Assert.StrictEqual(true, DataContractSerializerHelper.SerializeAndDeserialize<object>(true, @"<z:anyType i:type=""a:boolean"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/"" xmlns:a=""http://www.w3.org/2001/XMLSchema"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">true</z:anyType>"));
+ Assert.StrictEqual("abc", DataContractSerializerHelper.SerializeAndDeserialize<object>("abc", @"<z:anyType i:type=""a:string"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/"" xmlns:a=""http://www.w3.org/2001/XMLSchema"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">abc</z:anyType>"));
+ Assert.Null(DataContractSerializerHelper.SerializeAndDeserialize<object>(null, @"<z:anyType i:nil=""true"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""/>"));
}
[Fact]
[Fact]
public static void DCS_StringAsRoot()
{
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<string>("abc", @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">abc</string>"), "abc");
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<string>(" a b ", @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/""> a b </string>"), " a b ");
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<string>(null, @"<string i:nil=""true"" xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""/>"), null);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<string>("", @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/""/>"), "");
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<string>(" ", @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/""> </string>"), " ");
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<string>("Hello World! 漢 ñ", @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">Hello World! 漢 ñ</string>"), "Hello World! 漢 ñ");
+ Assert.StrictEqual("abc", DataContractSerializerHelper.SerializeAndDeserialize<string>("abc", @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">abc</string>"));
+ Assert.StrictEqual(" a b ", DataContractSerializerHelper.SerializeAndDeserialize<string>(" a b ", @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/""> a b </string>"));
+ Assert.Null(DataContractSerializerHelper.SerializeAndDeserialize<string>(null, @"<string i:nil=""true"" xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""/>"));
+ Assert.StrictEqual("", DataContractSerializerHelper.SerializeAndDeserialize<string>("", @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/""/>"));
+ Assert.StrictEqual(" ", DataContractSerializerHelper.SerializeAndDeserialize<string>(" ", @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/""> </string>"));
+ Assert.StrictEqual("Hello World! 漢 ñ", DataContractSerializerHelper.SerializeAndDeserialize<string>("Hello World! 漢 ñ", @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">Hello World! 漢 ñ</string>"));
}
[Fact]
Assert.True(y.Count == 2);
string actual = string.Join("", y);
- Assert.StrictEqual(actual, "a1a2");
+ Assert.StrictEqual("a1a2", actual);
}
[Fact]
public static void DCS_EnumAsRoot()
{
//The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<MyEnum>(MyEnum.Two, @"<MyEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Two</MyEnum>"), MyEnum.Two);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<ByteEnum>(ByteEnum.Option1, @"<ByteEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</ByteEnum>"), ByteEnum.Option1);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<SByteEnum>(SByteEnum.Option1, @"<SByteEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</SByteEnum>"), SByteEnum.Option1);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<ShortEnum>(ShortEnum.Option1, @"<ShortEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</ShortEnum>"), ShortEnum.Option1);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<IntEnum>(IntEnum.Option1, @"<IntEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</IntEnum>"), IntEnum.Option1);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<UIntEnum>(UIntEnum.Option1, @"<UIntEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</UIntEnum>"), UIntEnum.Option1);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<LongEnum>(LongEnum.Option1, @"<LongEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</LongEnum>"), LongEnum.Option1);
- Assert.StrictEqual(DataContractSerializerHelper.SerializeAndDeserialize<ULongEnum>(ULongEnum.Option1, @"<ULongEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</ULongEnum>"), ULongEnum.Option1);
+ Assert.StrictEqual(MyEnum.Two, DataContractSerializerHelper.SerializeAndDeserialize<MyEnum>(MyEnum.Two, @"<MyEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Two</MyEnum>"));
+ Assert.StrictEqual(ByteEnum.Option1, DataContractSerializerHelper.SerializeAndDeserialize<ByteEnum>(ByteEnum.Option1, @"<ByteEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</ByteEnum>"));
+ Assert.StrictEqual(SByteEnum.Option1, DataContractSerializerHelper.SerializeAndDeserialize<SByteEnum>(SByteEnum.Option1, @"<SByteEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</SByteEnum>"));
+ Assert.StrictEqual(ShortEnum.Option1, DataContractSerializerHelper.SerializeAndDeserialize<ShortEnum>(ShortEnum.Option1, @"<ShortEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</ShortEnum>"));
+ Assert.StrictEqual(IntEnum.Option1, DataContractSerializerHelper.SerializeAndDeserialize(IntEnum.Option1, @"<IntEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</IntEnum>"));
+ Assert.StrictEqual(UIntEnum.Option1, DataContractSerializerHelper.SerializeAndDeserialize<UIntEnum>(UIntEnum.Option1, @"<UIntEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</UIntEnum>"));
+ Assert.StrictEqual(LongEnum.Option1, DataContractSerializerHelper.SerializeAndDeserialize(LongEnum.Option1, @"<LongEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</LongEnum>"));
+ Assert.StrictEqual(ULongEnum.Option1, DataContractSerializerHelper.SerializeAndDeserialize<ULongEnum>(ULongEnum.Option1, @"<ULongEnum xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"">Option1</ULongEnum>"));
}
[Fact]
Dictionary<string, object> y = DataContractSerializerHelper.SerializeAndDeserialize<Dictionary<string, object>>(x, @"<ArrayOfKeyValueOfstringanyType xmlns=""http://schemas.microsoft.com/2003/10/Serialization/Arrays"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""><KeyValueOfstringanyType><Key>Key1</Key><Value i:type=""ArrayOfKeyValueOfstringanyType""><KeyValueOfstringanyType><Key>subkey1</Key><Value i:type=""a:string"" xmlns:a=""http://www.w3.org/2001/XMLSchema"">subkey1value</Value></KeyValueOfstringanyType></Value></KeyValueOfstringanyType></ArrayOfKeyValueOfstringanyType>");
Assert.NotNull(y);
- Assert.StrictEqual(y.Count, 1);
+ Assert.StrictEqual(1, y.Count);
Assert.True(y["Key1"] is Dictionary<string, object>);
- Assert.StrictEqual(((y["Key1"] as Dictionary<string, object>)["subkey1"]) as string, "subkey1value");
+ Assert.StrictEqual("subkey1value", ((y["Key1"] as Dictionary<string, object>)["subkey1"]) as string);
}
[Fact]
var y = DataContractSerializerHelper.SerializeAndDeserialize<DictionaryWithVariousKeyValueTypes>(x, @"<DictionaryWithVariousKeyValueTypes xmlns=""http://schemas.datacontract.org/2004/07/SerializationTypes"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""><WithEnums xmlns:a=""http://schemas.microsoft.com/2003/10/Serialization/Arrays""><a:KeyValueOfMyEnumMyEnumzbP0weY4><a:Key>Two</a:Key><a:Value>Three</a:Value></a:KeyValueOfMyEnumMyEnumzbP0weY4><a:KeyValueOfMyEnumMyEnumzbP0weY4><a:Key>One</a:Key><a:Value>One</a:Value></a:KeyValueOfMyEnumMyEnumzbP0weY4></WithEnums><WithNullables xmlns:a=""http://schemas.microsoft.com/2003/10/Serialization/Arrays""><a:KeyValueOfNullableOfshortNullableOfboolean_ShTDFhl_P><a:Key>-32768</a:Key><a:Value>true</a:Value></a:KeyValueOfNullableOfshortNullableOfboolean_ShTDFhl_P><a:KeyValueOfNullableOfshortNullableOfboolean_ShTDFhl_P><a:Key>0</a:Key><a:Value>false</a:Value></a:KeyValueOfNullableOfshortNullableOfboolean_ShTDFhl_P><a:KeyValueOfNullableOfshortNullableOfboolean_ShTDFhl_P><a:Key>32767</a:Key><a:Value i:nil=""true""/></a:KeyValueOfNullableOfshortNullableOfboolean_ShTDFhl_P></WithNullables><WithStructs xmlns:a=""http://schemas.microsoft.com/2003/10/Serialization/Arrays""><a:KeyValueOfStructNotSerializableStructNotSerializablezbP0weY4><a:Key><value>10</value></a:Key><a:Value><value>12</value></a:Value></a:KeyValueOfStructNotSerializableStructNotSerializablezbP0weY4><a:KeyValueOfStructNotSerializableStructNotSerializablezbP0weY4><a:Key><value>2147483647</value></a:Key><a:Value><value>-2147483648</value></a:Value></a:KeyValueOfStructNotSerializableStructNotSerializablezbP0weY4></WithStructs></DictionaryWithVariousKeyValueTypes>");
- Assert.StrictEqual(y.WithEnums[MyEnum.Two], MyEnum.Three);
- Assert.StrictEqual(y.WithEnums[MyEnum.One], MyEnum.One);
- Assert.StrictEqual(y.WithStructs[new StructNotSerializable() { value = 10 }], new StructNotSerializable() { value = 12 });
- Assert.StrictEqual(y.WithStructs[new StructNotSerializable() { value = int.MaxValue }], new StructNotSerializable() { value = int.MinValue });
- Assert.StrictEqual(y.WithNullables[short.MinValue], true);
- Assert.StrictEqual(y.WithNullables[0], false);
- Assert.StrictEqual(y.WithNullables[short.MaxValue], null);
+ Assert.StrictEqual(MyEnum.Three, y.WithEnums[MyEnum.Two]);
+ Assert.StrictEqual(MyEnum.One, y.WithEnums[MyEnum.One]);
+ Assert.StrictEqual(new StructNotSerializable() { value = 12 }, y.WithStructs[new StructNotSerializable() { value = 10 }]);
+ Assert.StrictEqual(new StructNotSerializable() { value = int.MinValue }, y.WithStructs[new StructNotSerializable() { value = int.MaxValue }]);
+ Assert.StrictEqual(true, y.WithNullables[short.MinValue]);
+ Assert.StrictEqual(false, y.WithNullables[0]);
+ Assert.Null(y.WithNullables[short.MaxValue]);
}
[Fact]
Func<DataContractSerializer> serializerFactory = () => new DataContractSerializer(typeof(MyOtherType), "ChangedRoot", "http://changedNamespace");
string baselineXml = @"<ChangedRoot xmlns=""http://changedNamespace"" xmlns:a=""http://schemas.datacontract.org/2004/07/SerializationTypes"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""><a:Str>Hello</a:Str></ChangedRoot>";
var result = DataContractSerializerHelper.SerializeAndDeserialize(obj, baselineXml, serializerFactory: serializerFactory);
- Assert.StrictEqual(result.Str, "Hello");
+ Assert.StrictEqual("Hello", result.Str);
}
[Fact]
Func<DataContractSerializer> serializerFactory = () => new DataContractSerializer(typeof(MyOtherType), xmlDictionary.Add("ChangedRoot"), xmlDictionary.Add("http://changedNamespace"));
string baselineXml = @"<ChangedRoot xmlns=""http://changedNamespace"" xmlns:a=""http://schemas.datacontract.org/2004/07/SerializationTypes"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance""><a:Str>Hello</a:Str></ChangedRoot>";
var result = DataContractSerializerHelper.SerializeAndDeserialize(obj, baselineXml, serializerFactory: serializerFactory);
- Assert.StrictEqual(result.Str, "Hello");
+ Assert.StrictEqual("Hello", result.Str);
}
[Fact]
Assert.StrictEqual((MyEnum)value.EnumValue, (MyEnum)actual.EnumValue);
Assert.True(actual.SimpleTypeValue is SimpleKnownTypeValue);
- Assert.StrictEqual(((SimpleKnownTypeValue)actual.SimpleTypeValue).StrProperty, "PropertyValue");
+ Assert.StrictEqual("PropertyValue", ((SimpleKnownTypeValue)actual.SimpleTypeValue).StrProperty);
}
[Fact]
Assert.StrictEqual((MyEnum)value.EnumValue, (MyEnum)actual.EnumValue);
Assert.True(actual.SimpleTypeValue is SimpleKnownTypeValue);
- Assert.StrictEqual(((SimpleKnownTypeValue)actual.SimpleTypeValue).StrProperty, "PropertyValue");
+ Assert.StrictEqual("PropertyValue", ((SimpleKnownTypeValue)actual.SimpleTypeValue).StrProperty);
}
[Fact]
Assert.StrictEqual((MyEnum)value.EnumValue, (MyEnum)actual.EnumValue);
Assert.True(actual.SimpleTypeValue is SimpleKnownTypeValue);
- Assert.StrictEqual(((SimpleKnownTypeValue)actual.SimpleTypeValue).StrProperty, "PropertyValue");
+ Assert.StrictEqual("PropertyValue", ((SimpleKnownTypeValue)actual.SimpleTypeValue).StrProperty);
}
[Fact]
Assert.StrictEqual((MyEnum)value.EnumValue, (MyEnum)actual.EnumValue);
Assert.True(actual.SimpleTypeValue is SimpleKnownTypeValue);
- Assert.StrictEqual(((SimpleKnownTypeValue)actual.SimpleTypeValue).StrProperty, "PropertyValue");
+ Assert.StrictEqual("PropertyValue", ((SimpleKnownTypeValue)actual.SimpleTypeValue).StrProperty);
}
[Fact]
// Initializations of this form are handled specially on Desktop and in .NET Native by UTC.
var array = new int[,,,] { { { { 1, 2, 3 }, { 1, 2, 3 } }, { { 1, 2, 3 }, { 1, 2, 3 } } }, { { { 1, 2, 3 }, { 1, 2, 3 } }, { { 1, 2, 3 }, { 1, 2, 3 } } } };
Assert.NotNull(array);
- Assert.Equal(array.GetValue(0, 0, 0, 0), 1);
- Assert.Equal(array.GetValue(0, 0, 0, 1), 2);
- Assert.Equal(array.GetValue(0, 0, 0, 2), 3);
+ Assert.Equal(1, array.GetValue(0, 0, 0, 0));
+ Assert.Equal(2, array.GetValue(0, 0, 0, 1));
+ Assert.Equal(3, array.GetValue(0, 0, 0, 2));
}
[Fact]
Assert.False(Array.Exists(intArray, i => i == -1));
int[] results = Array.FindAll(intArray, i => (i % 2) != 0);
- Assert.Equal(results.Length, 2);
+ Assert.Equal(2, results.Length);
Assert.True(Array.Exists(results, i => i == 7));
Assert.True(Array.Exists(results, i => i == 9));
var f2 = new ChildAttributeWithField { Prop = 42 };
var f3 = new ChildAttributeWithField { Prop = 1 };
- Assert.NotEqual(a1.GetHashCode(), 0);
- Assert.NotEqual(a2.GetHashCode(), 0);
- Assert.NotEqual(a3.GetHashCode(), 0);
- Assert.NotEqual(d1.GetHashCode(), 0);
- Assert.NotEqual(d2.GetHashCode(), 0);
- Assert.NotEqual(d3.GetHashCode(), 0);
- Assert.NotEqual(s1.GetHashCode(), 0);
- Assert.NotEqual(s2.GetHashCode(), 0);
- Assert.NotEqual(s3.GetHashCode(), 0);
- Assert.Equal(f1.GetHashCode(), 0);
- Assert.Equal(f2.GetHashCode(), 0);
- Assert.Equal(f3.GetHashCode(), 0);
+ Assert.NotEqual(0, a1.GetHashCode());
+ Assert.NotEqual(0, a2.GetHashCode());
+ Assert.NotEqual(0, a3.GetHashCode());
+ Assert.NotEqual(0, d1.GetHashCode());
+ Assert.NotEqual(0, d2.GetHashCode());
+ Assert.NotEqual(0, d3.GetHashCode());
+ Assert.NotEqual(0, s1.GetHashCode());
+ Assert.NotEqual(0, s2.GetHashCode());
+ Assert.NotEqual(0, s3.GetHashCode());
+ Assert.Equal(0, f1.GetHashCode());
+ Assert.Equal(0, f2.GetHashCode());
+ Assert.Equal(0, f3.GetHashCode());
Assert.NotEqual(a1.GetHashCode(), a2.GetHashCode());
Assert.NotEqual(a2.GetHashCode(), a3.GetHashCode());
object[] args = new object[] { null };
d.DynamicInvoke(args);
MyStruct s = (MyStruct)(args[0]);
- Assert.Equal(s.X, 7);
- Assert.Equal(s.Y, 8);
+ Assert.Equal(7, s.X);
+ Assert.Equal(8, s.Y);
}
[Fact]
private static void ValueTypeMethod(MyStruct s)
{
- Assert.Equal(s.X, 0);
- Assert.Equal(s.Y, 0);
+ Assert.Equal(0, s.X);
+ Assert.Equal(0, s.Y);
}
private delegate void ValueTypeDelegate(MyStruct s);
private static void NullableMethod(int? n)
{
Assert.True(n.HasValue);
- Assert.Equal(n.Value, 7);
+ Assert.Equal(7, n.Value);
}
private delegate void NullableDelegate(int? s);
var exception = new EntryPointNotFoundException(message, innerException);
Assert.Equal(message, exception.Message);
- Assert.Equal(exception.GetBaseException().Message, "Created inner exception");
+ Assert.Equal("Created inner exception", exception.GetBaseException().Message);
Assert.Equal(COR_E_ENTRYPOINTNOTFOUND, exception.HResult);
Assert.Equal(innerException, exception.InnerException);
Assert.Equal(innerException.HResult, exception.InnerException.HResult);
}
}
-}
\ No newline at end of file
+}
//
// In addition to this, the Assert.Throws xunit combinator tends to also allocate a lot.
Assert.True(GC.TryStartNoGCRegion(4000 * 1024, true));
- Assert.Equal(GCSettings.LatencyMode, GCLatencyMode.NoGCRegion);
+ Assert.Equal(GCLatencyMode.NoGCRegion, GCSettings.LatencyMode);
Assert.Throws<InvalidOperationException>(() => GCSettings.LatencyMode = GCLatencyMode.LowLatency);
GC.EndNoGCRegion();
{
Assert.True(GC.TryStartNoGCRegion(NoGCRequestedBudget));
- Assert.Equal(GCSettings.LatencyMode, GCLatencyMode.NoGCRegion);
+ Assert.Equal(GCLatencyMode.NoGCRegion, GCSettings.LatencyMode);
GC.EndNoGCRegion();
return RemoteExecutor.SuccessExitCode;
RemoteExecutor.Invoke(() =>
{
Assert.True(GC.TryStartNoGCRegion(NoGCRequestedBudget, true));
- Assert.Equal(GCSettings.LatencyMode, GCLatencyMode.NoGCRegion);
+ Assert.Equal(GCLatencyMode.NoGCRegion, GCSettings.LatencyMode);
GC.EndNoGCRegion();
return RemoteExecutor.SuccessExitCode;
RemoteExecutor.Invoke(() =>
{
Assert.True(GC.TryStartNoGCRegion(NoGCRequestedBudget, NoGCRequestedBudget));
- Assert.Equal(GCSettings.LatencyMode, GCLatencyMode.NoGCRegion);
+ Assert.Equal(GCLatencyMode.NoGCRegion, GCSettings.LatencyMode);
GC.EndNoGCRegion();
return RemoteExecutor.SuccessExitCode;
RemoteExecutor.Invoke(() =>
{
Assert.True(GC.TryStartNoGCRegion(NoGCRequestedBudget, NoGCRequestedBudget, true));
- Assert.Equal(GCSettings.LatencyMode, GCLatencyMode.NoGCRegion);
+ Assert.Equal(GCLatencyMode.NoGCRegion, GCSettings.LatencyMode);
GC.EndNoGCRegion();
return RemoteExecutor.SuccessExitCode;
DFoo dfoo = new C().Foo;
Delegate[] delegates = dfoo.GetInvocationList();
Assert.NotNull(delegates);
- Assert.Equal(delegates.Length, 1);
+ Assert.Equal(1, delegates.Length);
Assert.True(dfoo.Equals(delegates[0]));
}
DRet dret2 = new DRet(t.BRet);
DRet dret12 = (DRet)Delegate.Combine(dret1, dret2);
string s = dret12(4);
- Assert.Equal(s, "BRet4");
- Assert.Equal(t.S, "ARet4BRet4");
+ Assert.Equal("BRet4", s);
+ Assert.Equal("ARet4BRet4", t.S);
}
[Fact]
D one = (D)(Delegate.Combine(a));
t1.Clear();
one(5);
- Assert.Equal(t1.S, "A5");
+ Assert.Equal("A5", t1.S);
CheckInvokeList(new D[] { a }, one, t1);
D ab = (D)(Delegate.Combine(a, b));
t1.Clear();
ab(5);
- Assert.Equal(t1.S, "A5B5");
+ Assert.Equal("A5B5", t1.S);
CheckInvokeList(new D[] { a, b }, ab, t1);
D abc = (D)(Delegate.Combine(a, b, c));
t1.Clear();
abc(5);
- Assert.Equal(t1.S, "A5B5C5");
+ Assert.Equal("A5B5C5", t1.S);
CheckInvokeList(new D[] { a, b, c }, abc, t1);
D abcdabc = (D)(Delegate.Combine(abc, d, abc));
t1.Clear();
abcdabc(9);
- Assert.Equal(t1.S, "A9B9C9D9A9B9C9");
+ Assert.Equal("A9B9C9D9A9B9C9", t1.S);
CheckInvokeList(new D[] { a, b, c, d, a, b, c }, abcdabc, t1);
}
t1.Clear();
abcc(9);
string s = t1.S;
- Assert.Equal(s, "A9B9C9C9");
+ Assert.Equal("A9B9C9C9", s);
CheckInvokeList(new D[] { a, b, c, c }, abcc, t1);
// Pattern-match is based on structural equivalence, not reference equality.
D bbb = (D)(Delegate.Remove(bbba, a));
t1.Clear();
bbb(9);
- Assert.Equal(t1.S, "B9B9B9");
+ Assert.Equal("B9B9B9", t1.S);
CheckInvokeList(new D[] { b, b, b }, bbb, t1);
// In the case of multiple occurrences, Remove() must remove the last one.
D abcd = (D)(Delegate.Remove(abcdabc, abc));
t1.Clear();
abcd(9);
- Assert.Equal(t1.S, "A9B9C9D9");
+ Assert.Equal("A9B9C9D9", t1.S);
CheckInvokeList(new D[] { a, b, c, d }, abcd, t1);
D d1 = (D)(Delegate.RemoveAll(abcdabc, abc));
t1.Clear();
d1(9);
s = t1.S;
- Assert.Equal(t1.S, "D9");
+ Assert.Equal("D9", t1.S);
CheckInvokeList(new D[] { d }, d1, t1);
D nothing = (D)(Delegate.Remove(d1, d1));
D abcd1 = (D)(Delegate.Remove(abcd, null));
t1.Clear();
abcd1(9);
- Assert.Equal(t1.S, "A9B9C9D9");
+ Assert.Equal("A9B9C9D9", t1.S);
CheckInvokeList(new D[] { a, b, c, d }, abcd1, t1);
// The pattern-not-found case.
D abcd2 = (D)(Delegate.Remove(abcd, e));
t1.Clear();
abcd2(9);
- Assert.Equal(t1.S, "A9B9C9D9");
+ Assert.Equal("A9B9C9D9", t1.S);
CheckInvokeList(new D[] { a, b, c, d }, abcd2, t1);
// The pattern-not-found case.
D abcd3 = (D)(Delegate.RemoveAll(abcd, null));
t1.Clear();
abcd3(9);
- Assert.Equal(t1.S, "A9B9C9D9");
+ Assert.Equal("A9B9C9D9", t1.S);
CheckInvokeList(new D[] { a, b, c, d }, abcd3, t1);
// The pattern-not-found case.
D abcd4 = (D)(Delegate.RemoveAll(abcd, e));
t1.Clear();
abcd4(9);
- Assert.Equal(t1.S, "A9B9C9D9");
+ Assert.Equal("A9B9C9D9", t1.S);
CheckInvokeList(new D[] { a, b, c, d }, abcd4, t1);
}
{
Assert.True(expected.Equals(actual));
Delegate[] invokeList = actual.GetInvocationList();
- Assert.Equal(invokeList.Length, 1);
+ Assert.Equal(1, invokeList.Length);
bool b = actual.Equals(invokeList[0]);
Assert.True(b);
Type t = typeof(TestClass);
MemberInfo[] members = t.GetMember("My*", MemberTypes.Event, BindingFlags.Public | BindingFlags.Instance);
- Assert.Equal(members.Length, 1);
+ Assert.Equal(1, members.Length);
Assert.Equal("MyEvent", members[0].Name);
}
Type t = typeof(TestClass);
MemberInfo[] members = t.GetMember("My*", MemberTypes.Field, BindingFlags.Public | BindingFlags.Instance);
- Assert.Equal(members.Length, 1);
+ Assert.Equal(1, members.Length);
Assert.Equal("MyField", members[0].Name);
}
Type t = typeof(TestClass);
MemberInfo[] members = t.GetMember("My*", MemberTypes.Method, BindingFlags.Public | BindingFlags.Instance);
- Assert.Equal(members.Length, 1);
+ Assert.Equal(1, members.Length);
Assert.Equal("MyMethod", members[0].Name);
}
Type t = typeof(TestClass);
MemberInfo[] members = t.GetMember("My*", MemberTypes.NestedType, BindingFlags.Public | BindingFlags.Instance);
- Assert.Equal(members.Length, 1);
+ Assert.Equal(1, members.Length);
Assert.Equal("MyNestedType", members[0].Name);
}
Type t = typeof(TestClass);
MemberInfo[] members = t.GetMember("My*", MemberTypes.Property, BindingFlags.Public | BindingFlags.Instance);
- Assert.Equal(members.Length, 1);
+ Assert.Equal(1, members.Length);
Assert.Equal("MyProperty", members[0].Name);
}
// Fields return the most derived match.
FieldInfo f = t.GetField("myfield", bf);
- Assert.Equal(f.Name, "MyField");
+ Assert.Equal("MyField", f.Name);
// Unless two of them are both the most derived match...
Assert.Throws<AmbiguousMatchException>(() => t.GetField("myfield2", bf));
// Methods return the most derived match, provided all their signatures are the same.
MethodInfo m1 = t.GetMethod("mymethod1", bf);
- Assert.Equal(m1.Name, "MyMethod1");
+ Assert.Equal("MyMethod1", m1.Name);
MethodInfo m2 = t.GetMethod("mymethod2", bf);
- Assert.Equal(m2.Name, "MyMethod2");
+ Assert.Equal("MyMethod2", m2.Name);
// Unless two of them are both the most derived match...
Assert.Throws<AmbiguousMatchException>(() => t.GetMethod("mymethod3", bf));
string value;
Assert.True(cwt.TryGetValue(key, out value));
- Assert.Equal(value, "value1");
+ Assert.Equal("value1", value);
Assert.Equal(value, cwt.GetOrCreateValue(key));
Assert.Equal(value, cwt.GetValue(key, k => "value1"));
cwt.AddOrUpdate(key, "value2");
Assert.True(cwt.TryGetValue(key, out value));
- Assert.Equal(value, "value2");
+ Assert.Equal("value2", value);
Assert.Equal(value, cwt.GetOrCreateValue(key));
Assert.Equal(value, cwt.GetValue(key, k => "value1"));
}
Assert.NotEqual(i123.GetHashCode(), h4);
int h5 = RuntimeHelpers.GetHashCode(null);
- Assert.Equal(h5, 0);
+ Assert.Equal(0, h5);
}
public struct TestStruct
{
RuntimeTypeHandle t = typeof(HasCctor).TypeHandle;
RuntimeHelpers.RunClassConstructor(t);
- Assert.Equal(HasCctorReceiver.S, "Hello");
+ Assert.Equal("Hello", HasCctorReceiver.S);
return;
}
DateTimeKind expectedKind = (TimeZoneInfo.Local == TimeZoneInfo.Utc) ? DateTimeKind.Utc : DateTimeKind.Local;
Assert.Equal(expectedKind, converted.Kind);
back = TimeZoneInfo.ConvertTimeToUtc(converted, TimeZoneInfo.Local);
- Assert.Equal(back.Kind, DateTimeKind.Utc);
+ Assert.Equal(DateTimeKind.Utc, back.Kind);
Assert.Equal(utc, back);
}
}
// 0x1f = b11111, number of ones = 5
- Assert.Equal(pathsCovered, 0x1f);
+ Assert.Equal(0x1f, pathsCovered);
Assert.Equal(5, i);
}
Assert.Null(data.IssuerSerials);
Assert.Null(data.SubjectKeyIds);
Assert.Null(data.SubjectNames);
- Assert.Equal(data.GetXml().OuterXml, "<X509Data xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />");
+ Assert.Equal("<X509Data xmlns=\"http://www.w3.org/2000/09/xmldsig#\" />", data.GetXml().OuterXml);
}
[Fact]
XmlDsigC14NTransform t = new XmlDsigC14NTransform();
t.LoadInput(doc);
Stream s = t.GetOutput() as Stream;
- Assert.Equal(new StreamReader(s, Encoding.UTF8).ReadToEnd(), "<foo xmlns=\"urn:foo\"><bar xmlns=\"urn:bar\"></bar></foo>");
+ Assert.Equal("<foo xmlns=\"urn:foo\"><bar xmlns=\"urn:bar\"></bar></foo>", new StreamReader(s, Encoding.UTF8).ReadToEnd());
Assert.Equal("urn:foo", doc.DocumentElement.GetAttribute("xmlns"));
}
|| encryptionMethod.KeyAlgorithm == EncryptedXml.XmlEncAES192Url
|| encryptionMethod.KeyAlgorithm == EncryptedXml.XmlEncAES256Url);
- Assert.Equal(keyInfo.Count, 1);
+ Assert.Equal(1, keyInfo.Count);
byte[] decryptedKey = null;
EncryptedKey encryptedKey = encryptedKeyInfo.EncryptedKey;
Assert.Equal(encryptedKey.EncryptionMethod.KeyAlgorithm, EncryptedXml.XmlEncRSAOAEPUrl);
- Assert.Equal(encryptedKey.KeyInfo.Count, 1);
- Assert.NotEqual(_asymmetricKeys.Count, 0);
+ Assert.Equal(1, encryptedKey.KeyInfo.Count);
+ Assert.NotEqual(0, _asymmetricKeys.Count);
RSAParameters rsaParams = new RSAParameters();
RSAParameters rsaInputParams = new RSAParameters();
nsMgr.AddNamespace("r", LicenseTransformNsUrl);
XmlElement currentIssuerContext = context.SelectSingleNode("ancestor-or-self::r:issuer[1]", nsMgr) as XmlElement;
- Assert.NotEqual(currentIssuerContext, null);
+ Assert.NotNull(currentIssuerContext);
XmlElement signatureNode = currentIssuerContext.SelectSingleNode("descendant-or-self::dsig:Signature[1]", nsMgr) as XmlElement;
if (signatureNode != null)
}
XmlElement currentLicenseContext = currentIssuerContext.SelectSingleNode("ancestor-or-self::r:license[1]", nsMgr) as XmlElement;
- Assert.NotEqual(currentLicenseContext, null);
+ Assert.NotNull(currentLicenseContext);
XmlNodeList issuerList = currentLicenseContext.SelectNodes("descendant-or-self::r:license[1]/r:issuer", nsMgr);
for (int i = 0; i < issuerList.Count; i++)
new byte[] {0x28, 0x75, 0x6E, 0x6B, 0x6E, 0x6F, 0x77, 0x6E, 0x29, 0x58, 0x28, 0x75, 0x6E, 0x6B, 0x6E, 0x6F, 0x77, 0x6E, 0x29 });
string decodedString = asciiEncoding.GetString(encodedBytes);
- Assert.Equal(decodedString, "(unknown)X(unknown)");
+ Assert.Equal("(unknown)X(unknown)", decodedString);
// Test when the fallback will not occur
encodedBytes = new byte[asciiEncoding.GetByteCount(s_asciiInputStringWinNoFallback)];
public static void TestDecoderReplacementFallback()
{
Encoding asciiEncoding = Encoding.GetEncoding("us-ascii", new EncoderReplacementFallback("(unknown)"), new DecoderReplacementFallback("Error"));
- Assert.Equal(asciiEncoding.GetString(new byte [] { 0xAA, (byte)'x', 0xAB }), "ErrorxError");
+ Assert.Equal("ErrorxError", asciiEncoding.GetString(new byte [] { 0xAA, (byte)'x', 0xAB }));
}
[Fact]
new byte[] {(byte) 'a', 0x58, (byte) 'b'});
string decodedString = asciiEncoding.GetString(encodedBytes);
- Assert.Equal(decodedString, "aXb");
+ Assert.Equal("aXb", decodedString);
}
}
public static void TestValidIntegerValue()
{
StoreColor c = JsonSerializer.Deserialize<StoreColor>("1");
- Assert.Equal(c, StoreColor.Black);
+ Assert.Equal(StoreColor.Black, c);
}
[Fact]
{
InvalidOperationException e = Assert.Throws<InvalidOperationException>(
() => JsonSerializer.Serialize(default(ImmutableArray<int>), s_indentedOption));
- Assert.Equal(e.Message, "This operation cannot be performed on a default instance of ImmutableArray<T>. Consider initializing the array, or checking the ImmutableArray<T>.IsDefault property.");
+ Assert.Equal("This operation cannot be performed on a default instance of ImmutableArray<T>. Consider initializing the array, or checking the ImmutableArray<T>.IsDefault property.", e.Message);
}
#endregion
public void IncompleteContainers()
{
JsonException e = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IList<object>>("[1,"));
- Assert.Equal(e.Message, "Expected start of a property name or value, but instead reached end of data. Path: $[1] | LineNumber: 0 | BytePositionInLine: 2.");
+ Assert.Equal("Expected start of a property name or value, but instead reached end of data. Path: $[1] | LineNumber: 0 | BytePositionInLine: 2.", e.Message);
e = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IList<int>>("[1,"));
- Assert.Equal(e.Message, "Expected start of a property name or value, but instead reached end of data. Path: $[1] | LineNumber: 0 | BytePositionInLine: 2.");
+ Assert.Equal("Expected start of a property name or value, but instead reached end of data. Path: $[1] | LineNumber: 0 | BytePositionInLine: 2.", e.Message);
e = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IList<int>>("[1"));
- Assert.Equal(e.Message, "'1' is an invalid end of a number. Expected a delimiter. Path: $[0] | LineNumber: 0 | BytePositionInLine: 2.");
+ Assert.Equal("'1' is an invalid end of a number. Expected a delimiter. Path: $[0] | LineNumber: 0 | BytePositionInLine: 2.", e.Message);
e = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IDictionary<string, int>>("{\"key\":1,"));
- Assert.Equal(e.Message, "Expected start of a property name or value, but instead reached end of data. Path: $.key | LineNumber: 0 | BytePositionInLine: 8.");
+ Assert.Equal("Expected start of a property name or value, but instead reached end of data. Path: $.key | LineNumber: 0 | BytePositionInLine: 8.", e.Message);
e = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IDictionary<string, int>>("{\"key\":1"));
- Assert.Equal(e.Message, "'1' is an invalid end of a number. Expected a delimiter. Path: $.key | LineNumber: 0 | BytePositionInLine: 8.");
+ Assert.Equal("'1' is an invalid end of a number. Expected a delimiter. Path: $.key | LineNumber: 0 | BytePositionInLine: 8.", e.Message);
e = Assert.Throws<JsonException>(() => JsonSerializer.Deserialize<IncompleteTestClass>("{\"key\":1,"));
- Assert.Equal(e.Message, "Expected start of a property name or value, but instead reached end of data. Path: $ | LineNumber: 0 | BytePositionInLine: 8.");
+ Assert.Equal("Expected start of a property name or value, but instead reached end of data. Path: $ | LineNumber: 0 | BytePositionInLine: 8.", e.Message);
}
[Fact]
catch (JsonException ex)
{
Assert.Contains("$.Level2.Level3s[1]", ex.ToString());
- Assert.Equal(ex.Path, "$.Level2.Level3s[1]");
+ Assert.Equal("$.Level2.Level3s[1]", ex.Path);
}
}
catch (JsonException ex)
{
Assert.Contains("$.Level2.Level3s[1]", ex.ToString());
- Assert.Equal(ex.Path, "$.Level2.Level3s[1]");
+ Assert.Equal("$.Level2.Level3s[1]", ex.Path);
}
}
catch (JsonException ex)
{
Assert.Contains("$.Level2.Level3s", ex.ToString());
- Assert.Equal(ex.Path, "$.Level2.Level3s");
+ Assert.Equal("$.Level2.Level3s", ex.Path);
}
}
public static void PocoWithDictionaryObject()
{
PocoDictionary dict = JsonSerializer.Deserialize<PocoDictionary>("{\n\t\"key\" : {\"a\" : \"b\", \"c\" : \"d\"}}");
- Assert.Equal(dict.key["a"], "b");
- Assert.Equal(dict.key["c"], "d");
+ Assert.Equal("b", dict.key["a"]);
+ Assert.Equal("d", dict.key["c"]);
}
public class PocoDictionary
public void Verify()
{
Assert.Equal(MyInt16, (short)1);
- Assert.Equal(MyInt32, (int)2);
- Assert.Equal(MyInt64, (long)3);
- Assert.Equal(MyUInt16, (ushort)4);
- Assert.Equal(MyUInt32, (uint)5);
- Assert.Equal(MyUInt64, (ulong)6);
- Assert.Equal(MyByte, (byte)7);
- Assert.Equal(MySByte, (sbyte)8);
- Assert.Equal(MyChar, 'a');
- Assert.Equal(MyDecimal, 3.3m);
- Assert.Equal(MyBooleanFalse, false);
- Assert.Equal(MyBooleanTrue, true);
- Assert.Equal(MySingle, 1.1f);
- Assert.Equal(MyDouble, 2.2d);
- Assert.Equal(MyDateTime, new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc));
- Assert.Equal(MyDateTimeOffset, new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0)));
- Assert.Equal(MyGuid, new Guid("1B33498A-7B7D-4DDA-9C13-F6AA4AB449A6"));
- Assert.Equal(MyEnum, SampleEnum.Two);
+ Assert.Equal((int)2, MyInt32);
+ Assert.Equal((long)3, MyInt64);
+ Assert.Equal((ushort)4, MyUInt16);
+ Assert.Equal((uint)5, MyUInt32);
+ Assert.Equal((ulong)6, MyUInt64);
+ Assert.Equal((byte)7, MyByte);
+ Assert.Equal((sbyte)8, MySByte);
+ Assert.Equal('a', MyChar);
+ Assert.Equal(3.3m, MyDecimal);
+ Assert.False(MyBooleanFalse);
+ Assert.True(MyBooleanTrue);
+ Assert.Equal(1.1f, MySingle);
+ Assert.Equal(2.2d, MyDouble);
+ Assert.Equal(new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc), MyDateTime);
+ Assert.Equal(new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0)), MyDateTimeOffset);
+ Assert.Equal(new Guid("1B33498A-7B7D-4DDA-9C13-F6AA4AB449A6"), MyGuid);
+ Assert.Equal(SampleEnum.Two, MyEnum);
Assert.Equal((short)1, MyInt16Array[0]);
Assert.Equal((int)2, MyInt32Array[0]);
public void Verify()
{
- Assert.Equal(MyString, null);
+ Assert.Null(MyString);
}
}
}
catch (InvalidOperationException ex)
{
- Assert.Equal(ex.InnerException.GetType(), typeof(DecoderFallbackException));
+ Assert.Equal(typeof(DecoderFallbackException), ex.InnerException.GetType());
}
}
}
};
foreach (var block in blocks)
{
- Assert.Equal(block.InputCount, 0);
+ Assert.Equal(0, block.InputCount);
Assert.NotNull(block.Completion);
}
}
IList<int> items;
Assert.True(((IReceivableSourceBlock<int>)bb).TryReceiveAll(out items));
- Assert.Equal(expected: items.Count, actual: 1);
+ Assert.Equal(expected: 1, actual: items.Count);
Assert.Equal(expected: -data, actual: items[0]);
}
IList<int> items;
Assert.True(((IReceivableSourceBlock<int>)wob).TryReceiveAll(out items));
- Assert.Equal(expected: items.Count, actual: 1);
+ Assert.Equal(expected: 1, actual: items.Count);
Assert.Equal(expected: -data, actual: items[0]);
}
IEnumerator<KeyValuePair<long, int>> enumerator = partitioner.GetOrderableDynamicPartitions().GetEnumerator();
while (enumerator.MoveNext())
{
- Assert.Equal(dataSourceMoveNextCalls, 1);
+ Assert.Equal(1, dataSourceMoveNextCalls);
//reset the count - for the next moveNext call
dataSourceMoveNextCalls = 0;
}
while (enumerator.MoveNext())
{
- Assert.Equal(dataSourceMoveNextCalls, 1);
+ Assert.Equal(1, dataSourceMoveNextCalls);
//reset the count - for the next moveNext call
dataSourceMoveNextCalls = 0;
}
private static void VerifyAggregateException(AggregateException aggregatEx, Exception userException)
{
Assert.True(aggregatEx.InnerExceptions.Contains(userException));
- Assert.Equal(aggregatEx.Flatten().InnerExceptions.Count, 1);
+ Assert.Equal(1, aggregatEx.Flatten().InnerExceptions.Count);
}
#endregion
public static void ConstructorBasic()
{
AggregateException ex = new AggregateException();
- Assert.Equal(ex.InnerExceptions.Count, 0);
+ Assert.Equal(0, ex.InnerExceptions.Count);
Assert.True(ex.Message != null, "RunAggregateException_Constructor: FAILED. Message property is null when the default constructor is used, expected a default message");
ex = new AggregateException("message");
- Assert.Equal(ex.InnerExceptions.Count, 0);
+ Assert.Equal(0, ex.InnerExceptions.Count);
Assert.True(ex.Message != null, "RunAggregateException_Constructor: FAILED. Message property is null when the default constructor(string) is used");
ex = new AggregateException("message", new Exception());
- Assert.Equal(ex.InnerExceptions.Count, 1);
+ Assert.Equal(1, ex.InnerExceptions.Count);
Assert.True(ex.Message != null, "RunAggregateException_Constructor: FAILED. Message property is null when the default constructor(string, Exception) is used");
}
CancellationTokenSource cts = new CancellationTokenSource();
TaskCompletionSource<int> tcs = new TaskCompletionSource<int>(cts.Token);
tcs.SetResult(5);
- Assert.Equal(tcs.Task.Status, TaskStatus.RanToCompletion);
+ Assert.Equal(TaskStatus.RanToCompletion, tcs.Task.Status);
cts.Cancel();
- Assert.Equal(tcs.Task.Status, TaskStatus.RanToCompletion);
+ Assert.Equal(TaskStatus.RanToCompletion, tcs.Task.Status);
Assert.False(tcs.TrySetException(new Exception("some exception")), "RunTaskCompletionSourceTests: > Error! Set result, Canceled, tcs.TrySetException succeeded");
Assert.False(tcs.TrySetResult(10), "RunTaskCompletionSourceTests: > Error! Set result, Canceled, tcs.TrySetResult succeeded");
Assert.False(tcs.TrySetCanceled(), "RunTaskCompletionSourceTests: > Error! Set result, Canceled, tcs.TrySetCanceled succeeded");
- Assert.Equal(tcs.Task.Result, 5);
+ Assert.Equal(5, tcs.Task.Result);
Exception fake = new Exception("blah!");
try
public static async Task ValueProperty()
{
AsyncLocal<int> local = new AsyncLocal<int>();
- Assert.Equal(local.Value, 0);
+ Assert.Equal(0, local.Value);
local.Value = 1;
- Assert.Equal(local.Value, 1);
+ Assert.Equal(1, local.Value);
local.Value = 0;
- Assert.Equal(local.Value, 0);
+ Assert.Equal(0, local.Value);
}
[Fact]
ec,
_ =>
{
- Assert.Equal(local.Value, 42);
+ Assert.Equal(42, local.Value);
local.Value = 56;
},
null);
- Assert.Equal(local.Value, 12);
+ Assert.Equal(12, local.Value);
}
[Fact]
ec,
_ =>
{
- Assert.Equal(local.Value, 0);
+ Assert.Equal(0, local.Value);
local.Value = 56;
},
null);
- Assert.Equal(local.Value, 12);
+ Assert.Equal(12, local.Value);
}
[Theory]
Assert.True(gotNotification);
gotNotification = false;
- Assert.Equal(local.Value, 1);
+ Assert.Equal(1, local.Value);
expectNotification = true;
expectedPreviousValue = 1;
Assert.True(gotNotification);
gotNotification = false;
- Assert.Equal(local.Value, 2);
+ Assert.Equal(2, local.Value);
expectNotification = true;
expectThreadContextChange = true;
Assert.True(gotNotification);
gotNotification = false;
- Assert.Equal(local.Value, 0);
+ Assert.Equal(0, local.Value);
expectNotification = true;
expectedPreviousValue = 0;
Assert.True(gotNotification);
gotNotification = false;
- Assert.Equal(local.Value, 1);
+ Assert.Equal(1, local.Value);
expectNotification = true;
expectThreadContextChange = true;
await Run(async () =>
{
Assert.Equal(tls.Value, als.Value);
- Assert.Equal(als.Value, 2);
+ Assert.Equal(2, als.Value);
als.Value = 3;
Assert.Equal(tls.Value, als.Value);
Task t = Run(async () =>
{
Assert.Equal(tls.Value, als.Value);
- Assert.Equal(als.Value, 3);
+ Assert.Equal(3, als.Value);
als.Value = 4;
Assert.Equal(tls.Value, als.Value);
- Assert.Equal(als.Value, 4);
+ Assert.Equal(4, als.Value);
await Task.Run(() =>
{
Assert.Equal(tls.Value, als.Value);
- Assert.Equal(als.Value, 4);
+ Assert.Equal(4, als.Value);
als.Value = 5;
Assert.Equal(tls.Value, als.Value);
- Assert.Equal(als.Value, 5);
+ Assert.Equal(5, als.Value);
});
Assert.Equal(tls.Value, als.Value);
- Assert.Equal(als.Value, 4);
+ Assert.Equal(4, als.Value);
als.Value = 6;
Assert.Equal(tls.Value, als.Value);
- Assert.Equal(als.Value, 6);
+ Assert.Equal(6, als.Value);
});
Assert.Equal(tls.Value, als.Value);
- Assert.Equal(als.Value, 3);
+ Assert.Equal(3, als.Value);
await Task.Yield();
Assert.Equal(tls.Value, als.Value);
- Assert.Equal(als.Value, 3);
+ Assert.Equal(3, als.Value);
await t;
Assert.Equal(tls.Value, als.Value);
- Assert.Equal(als.Value, 3);
+ Assert.Equal(3, als.Value);
});
Assert.Equal(tls.Value, als.Value);
- Assert.Equal(als.Value, 2);
+ Assert.Equal(2, als.Value);
}
[Fact]
valueToSet = 2;
local.Value = 1;
- Assert.Equal(local.Value, 1);
+ Assert.Equal(1, local.Value);
await Run(async () =>
{
valueToSet = 4;
});
- Assert.Equal(local.Value, 4);
+ Assert.Equal(4, local.Value);
}
[Fact]
local.Value = 12;
});
- Assert.Equal(local.Value, 42);
+ Assert.Equal(42, local.Value);
}
[Theory]
}
AssertTransactionNull();
- Assert.Equal<bool>(hasException, true);
+ Assert.True(hasException);
ResetExceptionInjection();
}
}
}
catch (TransactionAbortedException ex)
{
- Assert.Equal(expectedStatus, TransactionStatus.Aborted);
+ Assert.Equal(TransactionStatus.Aborted, expectedStatus);
switch (cloneType)
{
case CloneType.Normal:
}
catch (TransactionInDoubtException)
{
- Assert.Equal(expectedTxStatus, TransactionStatus.InDoubt);
+ Assert.Equal(TransactionStatus.InDoubt, expectedTxStatus);
}
catch (TransactionAbortedException)
{
- Assert.Equal(expectedTxStatus, TransactionStatus.Aborted);
+ Assert.Equal(TransactionStatus.Aborted, expectedTxStatus);
}
}
catch (TransactionInDoubtException)
{
- Assert.Equal(expectedTxStatus, TransactionStatus.InDoubt);
+ Assert.Equal(TransactionStatus.InDoubt, expectedTxStatus);
}
catch (TransactionAbortedException)
{
- Assert.Equal(expectedTxStatus, TransactionStatus.Aborted);
+ Assert.Equal(TransactionStatus.Aborted, expectedTxStatus);
}
Assert.NotNull(tx);
}
catch (TransactionInDoubtException)
{
- Assert.Equal(expectedTxStatus, TransactionStatus.InDoubt);
+ Assert.Equal(TransactionStatus.InDoubt, expectedTxStatus);
}
catch (TransactionAbortedException)
{
- Assert.Equal(expectedTxStatus, TransactionStatus.Aborted);
+ Assert.Equal(TransactionStatus.Aborted, expectedTxStatus);
}
Assert.True(outcomeEvent.WaitOne(TimeSpan.FromSeconds(MaxTransactionCommitTimeoutInSeconds)));
}
catch (TransactionInDoubtException)
{
- Assert.Equal(expectedTxStatus, TransactionStatus.InDoubt);
+ Assert.Equal(TransactionStatus.InDoubt, expectedTxStatus);
}
catch (TransactionAbortedException)
{
- Assert.Equal(expectedTxStatus, TransactionStatus.Aborted);
+ Assert.Equal(TransactionStatus.Aborted, expectedTxStatus);
}
Task.Run(() => // in case current thread is STA thread, where WaitHandle.WaitAll isn't supported
TransactionAbortedException abortedEx = ex as TransactionAbortedException;
if ((abortedEx != null) && (spcResponse != TransactionStatus.Aborted))
{
- Assert.Equal(spcResponse, TransactionStatus.Aborted);
+ Assert.Equal(TransactionStatus.Aborted, spcResponse);
}
TransactionInDoubtException indoubtEx = ex as TransactionInDoubtException;
if ((indoubtEx != null) && (spcResponse != TransactionStatus.InDoubt))
{
- Assert.Equal(spcResponse, TransactionStatus.InDoubt);
+ Assert.Equal(TransactionStatus.InDoubt, spcResponse);
}
if (spcResponse == TransactionStatus.Committed)
TransactionAbortedException abortedEx = ex as TransactionAbortedException;
if ((abortedEx != null) && (spcResponse != TransactionStatus.Aborted))
{
- Assert.Equal(spcResponse, TransactionStatus.Aborted);
+ Assert.Equal(TransactionStatus.Aborted, spcResponse);
}
TransactionInDoubtException indoubtEx = ex as TransactionInDoubtException;
if ((indoubtEx != null) && (spcResponse != TransactionStatus.InDoubt))
{
- Assert.Equal(spcResponse, TransactionStatus.InDoubt);
+ Assert.Equal(TransactionStatus.InDoubt, spcResponse);
}
- Assert.NotEqual(spcResponse, TransactionStatus.Committed);
+ Assert.NotEqual(TransactionStatus.Committed, spcResponse);
}
TestPassed();
public void Commit(Enlistment enlistment)
{
- Assert.Equal(_expectedOutcome, EnlistmentOutcome.Committed);
+ Assert.Equal(EnlistmentOutcome.Committed, _expectedOutcome);
enlistment.Done();
}
public void Rollback(Enlistment enlistment)
{
- Assert.Equal(_expectedOutcome, EnlistmentOutcome.Aborted);
+ Assert.Equal(EnlistmentOutcome.Aborted, _expectedOutcome);
enlistment.Done();
}
public void InDoubt(Enlistment enlistment)
{
- Assert.Equal(_expectedOutcome, EnlistmentOutcome.InDoubt);
+ Assert.Equal(EnlistmentOutcome.InDoubt, _expectedOutcome);
enlistment.Done();
}
}
try
{
_txToEnlist.EnlistVolatile(newVol, EnlistmentOptions.None);
- Assert.Equal(_expectEnlistToSucceed, true);
+ Assert.True(_expectEnlistToSucceed);
}
catch (Exception)
{
- Assert.Equal(_expectEnlistToSucceed, false);
+ Assert.False(_expectEnlistToSucceed);
}
}
preparingEnlistment.Prepared();
public void Commit(Enlistment enlistment)
{
- Assert.Equal(_expectedOutcome, EnlistmentOutcome.Committed);
+ Assert.Equal(EnlistmentOutcome.Committed, _expectedOutcome);
if (_outcomeReceived != null)
{
_outcomeReceived.Set();
public void Rollback(Enlistment enlistment)
{
- Assert.Equal(_expectedOutcome, EnlistmentOutcome.Aborted);
+ Assert.Equal(EnlistmentOutcome.Aborted, _expectedOutcome);
if (_outcomeReceived != null)
{
_outcomeReceived.Set();
public void InDoubt(Enlistment enlistment)
{
- Assert.Equal(_expectedOutcome, EnlistmentOutcome.InDoubt);
+ Assert.Equal(EnlistmentOutcome.InDoubt, _expectedOutcome);
if (_outcomeReceived != null)
{
_outcomeReceived.Set();
enlistment.Done();
}
}
-}
\ No newline at end of file
+}
Assert.Null(Transaction.Current);
/* Value = 2, got committed */
- Assert.Equal(irm.Value, 2);
+ Assert.Equal(2, irm.Value);
irm.Check(1, 1, 0, 0, "irm");
}
Assert.Null(Transaction.Current);
/* Value = 2, got rolledback */
- Assert.Equal(irm.Value, 1);
+ Assert.Equal(1, irm.Value);
irm.Check(0, 0, 1, 0, "irm");
}
Assert.Null(Transaction.Current);
/* Both got committed */
- Assert.Equal(irm.Value, 2);
- Assert.Equal(irm2.Value, 20);
+ Assert.Equal(2, irm.Value);
+ Assert.Equal(20, irm2.Value);
irm.Check(1, 1, 0, 0, "irm");
irm2.Check(1, 1, 0, 0, "irm2");
}
Assert.Null(Transaction.Current);
- Assert.Equal(irm.Value, 1);
- Assert.Equal(irm2.Value, 10);
+ Assert.Equal(1, irm.Value);
+ Assert.Equal(10, irm2.Value);
irm.Check(0, 0, 1, 0, "irm");
}
Assert.Null(Transaction.Current);
- Assert.Equal(irm.Value, 1);
- Assert.Equal(irm2.Value, 10);
+ Assert.Equal(1, irm.Value);
+ Assert.Equal(10, irm2.Value);
irm.Check(0, 0, 1, 0, "irm");
irm2.Check(0, 0, 1, 0, "irm2");
}
}
/* vr2, committed */
irm2.Check(1, 1, 0, 0, "irm2");
- Assert.Equal(irm2.Value, 20);
+ Assert.Equal(20, irm2.Value);
Assert.Equal(TransactionStatus.Active, Transaction.Current.TransactionInformation.Status);
}
Assert.Null(Transaction.Current);
- Assert.Equal(irm.Value, 2);
+ Assert.Equal(2, irm.Value);
irm.Check(1, 1, 0, 0, "irm");
}
/* irm2, rolled back*/
irm2.Check(0, 0, 1, 0, "irm2");
- Assert.Equal(irm2.Value, 10);
+ Assert.Equal(10, irm2.Value);
Assert.Equal(TransactionStatus.Active, Transaction.Current.TransactionInformation.Status);
Assert.Null(Transaction.Current);
/* ..But irm got committed */
- Assert.Equal(irm.Value, 2);
+ Assert.Equal(2, irm.Value);
irm.Check(1, 1, 0, 0, "irm");
}
}
Assert.Null(Transaction.Current);
- Assert.Equal(irm.Value, 2);
+ Assert.Equal(2, irm.Value);
irm.Check(1, 1, 0, 0, "irm");
}
/* vr's value has changed as the inner scope committed = 6 */
irm.Check(1, 1, 0, 0, "irm");
- Assert.Equal(irm.Value, 6);
- Assert.Equal(irm.Actual, 6);
+ Assert.Equal(6, irm.Value);
+ Assert.Equal(6, irm.Actual);
Assert.Equal(TransactionStatus.Active, Transaction.Current.TransactionInformation.Status);
scope.Complete();
}
Assert.Null(Transaction.Current);
- Assert.Equal(irm.Value, 6);
+ Assert.Equal(6, irm.Value);
irm.Check(2, 2, 0, 0, "irm");
}
projects / platform / upstream / dotnet / runtime.git / commitdiff