public static void Test(Assert assert)
{
assert.Expect(4);
// TEST
int[] numbersA = { 4, 1, 3 };
int[] numbersB = { 2, 3, 5 };
var concatNumbers = numbersA.Concat(numbersB);
assert.DeepEqual(concatNumbers, new[] { 4, 1, 3, 2, 3, 5 }, "Concat() numbers");
// TEST
var names = from p in Person.GetPersons()
select p.Name;
var cities = from p in Person.GetPersons()
select p.City;
var concatNames = names.Concat(cities).ToArray();
assert.DeepEqual(concatNames,
new[] { "Frank", "Zeppa", "John", "Billy", "Dora", "Ian", "Mary", "Nemo",
"Edmonton", "Tokyo", "Lisbon", "Paris", "Budapest", "Rome", "Dortmund", "Ocean"},
"Concat() two sequences");
// TEST
var a = new[] { "a", "b", "z" };
var b = new[] { "a", "b", "z" };
assert.Ok(a.SequenceEqual(b), "SequenceEqual() for equal sequences");
// TEST
var c = new[] { "a", "b", "z" };
var d = new[] { "a", "z", "b" };
assert.Ok(!c.SequenceEqual(d), "SequenceEqual() for not equal sequences");
}
public static void Bridge349(Assert assert)
{
assert.Expect(5);
DateTime date;
var culture = new CultureInfo("ru-RU");
assert.Ok(culture != null, "Created CultureInfo(\"ru-RU\")");
var parsed = DateTime.TryParse("22.08.2015", culture, out date);
assert.Ok(parsed, "Parsed \"22.08.2015\"");
assert.Equal(date.Year, 2015, "TryParse works Year");
assert.Equal(date.Month, 8, "TryParse works Month");
assert.Equal(date.Day, 22, "TryParse works Day");
}
public static void TestCloneCompare(Assert assert)
{
assert.Expect(13);
var v1 = new Version(1, 2, 3, (4 << 16) + 5);
var o = v1.Clone();
assert.Ok(o != null, "v1 Cloned");
var v2 = o as Version;
assert.Ok(v2 != null, "v1 Cloned as Version");
assert.Equal(v2.Major, 1, "v2.Major 1");
assert.Equal(v2.Minor, 2, "v2.Minor 2");
assert.Equal(v2.Build, 3, "v2.Build 3");
assert.Equal(v2.Revision, 262149, "v2.Revision (4 << 16) + 5 = 262149");
assert.Equal(v2.MajorRevision, 4, "v2.MajorRevision 4");
assert.Equal(v2.MinorRevision, 5, "v2.MinorRevision 5");
var v3 = new Version(1, 2, 2, (4 << 16) + 5);
assert.Equal(v1.CompareTo(v3), 1, "v1.CompareTo(v3)");
var v4 = new Version(1, 3, 3, (4 << 16) + 5);
assert.Equal(v1.CompareTo(v4), -1, "v1.CompareTo(v4)");
assert.Equal(v1.CompareTo(o), 0, "v1.CompareTo(o)");
assert.Equal(v1.CompareTo(v2), 0, "v1.CompareTo(v2)");
assert.NotEqual(v1.CompareTo(null), 0, "v1.CompareTo(null)");
}
public static void Test(Assert assert)
{
assert.Expect(4);
// TEST
string[] words = { "count", "tree", "mount", "five", "doubt" };
bool anyOu = words.Any(w => w.Contains("ou"));
assert.Ok(anyOu, "Any() to return words containing 'ou'");
// TEST
int[] oddNumbers = { 3, 7, 9, 5, 247, 1000001 };
bool onlyOdd = oddNumbers.All(n => n % 2 == 1);
assert.Ok(onlyOdd, "All() is odd");
// TEST
int[] someNumbers = { 2, 3, 7, 9, 5, 247, 1000001 };
bool notOnlyOdd = !someNumbers.All(n => n % 2 == 1);
assert.Ok(notOnlyOdd, "All() is not only odd");
// TEST
var productGroups =
(from p in Person.GetPersons()
group p by p.Group into pGroup
where pGroup.Any(p => p.Count >= 500)
select new { Group = pGroup.Key, Names = pGroup.Select(x => x.Name).ToArray() }).ToArray();
object[] productGroupsExpected = { new {Group = "C", Names = new[]{"Zeppa", "Billy"}},
new {Group = "B", Names = new[]{"John", "Dora", "Ian", "Mary"}},
new {Group = (string)null, Names = new[]{"Nemo"}}
};
assert.DeepEqual(productGroups, productGroupsExpected, "Any() to return a grouped array of names only for groups having any item with Count > 500");
}
public static void TestConstructors(Assert assert)
{
assert.Expect(42);
var v1 = new Version();
assert.Ok(v1 != null, "v1 created");
assert.Equal(v1.Major, 0, "v1.Major 0");
assert.Equal(v1.Minor, 0, "v1.Minor 0");
assert.Equal(v1.Build, -1, "v1.Build -1");
assert.Equal(v1.Revision, -1, "v1.Revision -1");
assert.Equal(v1.MajorRevision, -1, "v1.MajorRevision -1");
assert.Equal(v1.MinorRevision, -1, "v1.MinorRevision -1");
var v2 = new Version("2.4.1128.2");
assert.Ok(v2 != null, "v2 created");
assert.Equal(v2.Major, 2, "v2.Major 2");
assert.Equal(v2.Minor, 4, "v2.Minor 4");
assert.Equal(v2.Build, 1128, "v2.Build 1128");
assert.Equal(v2.Revision, 2, "v2.Revision 2");
assert.Equal(v2.MajorRevision, 0, "v2.MajorRevision 0");
assert.Equal(v2.MinorRevision, 2, "v2.MinorRevision 2");
var v3 = new Version("2.4.1128.65537");
assert.Ok(v3 != null, "v3 created");
assert.Equal(v3.Major, 2, "v3.Major 2");
assert.Equal(v3.Minor, 4, "v3.Minor 4");
assert.Equal(v3.Build, 1128, "v3.Build 1128");
assert.Equal(v3.Revision, 65537, "v3.Revision 65537");
assert.Equal(v3.MajorRevision, 1, "v3.MajorRevision 1");
assert.Equal(v3.MinorRevision, 1, "v3.MinorRevision 1");
var v4 = new Version(20, 10);
assert.Ok(v4 != null, "v4 created");
assert.Equal(v4.Major, 20, "v4.Major 20");
assert.Equal(v4.Minor, 10, "v4.Minor 10");
assert.Equal(v4.Build, -1, "v4.Build -1");
assert.Equal(v4.Revision, -1, "v4.Revision -1");
assert.Equal(v4.MajorRevision, -1, "v4.MajorRevision -1");
assert.Equal(v4.MinorRevision, -1, "v4.MinorRevision -1");
var v5 = new Version(200, 100, 300);
assert.Ok(v5 != null, "v5 created");
assert.Equal(v5.Major, 200, "v5.Major 200");
assert.Equal(v5.Minor, 100, "v5.Minor 100");
assert.Equal(v5.Build, 300, "v5.Build 300");
assert.Equal(v5.Revision, -1, "v5.Revision -1");
assert.Equal(v5.MajorRevision, -1, "v5.MajorRevision -1");
assert.Equal(v5.MinorRevision, -1, "v5.MinorRevision -1");
var v6 = new Version(2000, 1000, 3000, (345 << 16) + 4000);
assert.Ok(v6 != null, "v6 created");
assert.Equal(v6.Major, 2000, "v6.Major 2000");
assert.Equal(v6.Minor, 1000, "v6.Minor 1000");
assert.Equal(v6.Build, 3000, "v6.Build 3000");
assert.Equal(v6.Revision, 22613920, "v6.Revision (345 << 16) + 4000 = 22613920");
assert.Equal(v6.MajorRevision, 345, "v6.MajorRevision 345");
assert.Equal(v6.MinorRevision, 4000, "v6.MinorRevision 4");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(2);
var s = new Bridge608A("test");
object o = "test";
assert.Ok(s.Equals(o), "Bridge608 Object");
assert.Ok(s.Equals("test"), "Bridge608 String");
}
public static void CaughtExceptions(Assert assert)
{
assert.Expect(3);
TryCatchWithCaughtException();
assert.Ok(true, "Exception catch");
TryCatchWithCaughtTypedException();
assert.Ok(true, "Typed exception catch");
var exceptionMessage = TryCatchWithCaughtArgumentException();
assert.DeepEqual(exceptionMessage, "catch me", "Typed exception catch with exception message");
}
public static void ThrownExceptions(Assert assert)
{
assert.Expect(12);
// #230
assert.Throws(TryCatchWithNotCaughtTypedException, "catch me", "A.Typed exception is not Caught");
assert.Ok(IsATry, "A. exception not caught - try section called");
assert.Ok(!IsACatch, "A. exception not caught - catch section not called");
// #229
assert.Throws(TryCatchWithNotCaughtTypedExceptionAndArgument, "catch me", "[#229] B. Typed exception is not Caught; and argument");
assert.Ok(IsBTry, "[#229] B. exception not caught - try section called");
assert.Ok(!IsBCatch, "B. exception not caught - catch section not called");
// #231
assert.Throws(TryCatchWithRethrow, "catch me", "[#231] C. Rethrow");
assert.Ok(IsCTry, "C. exception caught and re-thrown - try section called");
assert.Ok(IsCCatch, "C. exception caught and re-thrown - catch section called");
assert.Throws(TryCatchWithRethrowEx, new Func<object, bool>((error) =>
{
return error.ToString() == "catch me";
}), "D. Rethrow with parameter");
assert.Ok(IsDTry, "D. exception caught and re-thrown - try section called");
assert.Ok(IsDCatch, "D. exception caught and re-thrown - catch section called");
}
public static void TestBC(Assert assert)
{
assert.Expect(6);
A b = new B();
assert.Ok(b != null, "Instance of B created as instance of A");
assert.Equal(b.GetString(), "B", "b.GetString() = 'B'");
assert.Equal(b.Data, 1, "b.Data = 1");
A c = new C();
assert.Ok(c != null, "Instance of C created as instance of A");
assert.Equal(c.GetString(), "C", "c.GetString() = 'C'");
assert.Equal(c.Data, -1, "c.Data = -1");
}
public static void TestInterfaceMethodAndProperty(Assert assert)
{
assert.Expect(6);
ISimple a = new A();
assert.Ok(a != null, "Instance of A created through ISimple interface");
assert.Equal(a.GetString(), "A.ISimple", "a.GetString() = A.ISimple through interface");
assert.Equal(a.Data, 1, "a.Data = 1 through interface");
var b = a as A;
assert.Ok(b != null, "Instance of ISimple as A");
assert.Equal(a.GetString(), "A.ISimple", "a.GetString() = A.ISimple through instance");
assert.Equal(a.Data, 1, "a.Data = 1 through instance");
}
public static void TestInstance(Assert assert)
{
assert.Expect(17);
var i = new Instance();
assert.Ok(i != null, "i created");
assert.Equal(i.Foo(1), "Foo(int x)", "Instance Foo(int x)");
assert.Equal(i.Foo("string"), "Foo(string s)", "Instance Foo(string s)");
assert.Equal(i.Foo(1.1), "Foo(double d)", "Instance Foo(double d)");
assert.Equal(i.Foo(1, 2), "Foo(int x, int y)", "Instance Foo(int x, int y)");
assert.Equal(i.Foo(1, 1.1), "Foo(int x, double y)", "Instance Foo(int x, double y)");
assert.Equal(i.Foo(1.1, 1), "Foo(double x, int y)", "Instance Foo(double x, int y)");
assert.Equal(i.FooReturnType(1), 'C', "Instance char FooReturnType(int y)");
assert.Equal(i.FooReturnType(1.1), "string FooReturnType(double d)", "Instance string FooReturnType(double d)");
assert.Equal(i.FooOptionalParameters(1), "FooOptionalParameters(int x)", "Instance FooOptionalParameters(int x)");
assert.Equal(i.FooOptionalParameters(1, 2), "FooOptionalParameters(int x, int y = 5)", "Instance FooOptionalParameters(int x, int y = 5)");
assert.Equal(i.FooMultipleOptionalParameters(1, 2), "FooMultipleOptionalParameters(int x, int y = 5)", "Instance FooMultipleOptionalParameters(int x, int y = 5)");
assert.Equal(i.FooMultipleOptionalParameters(1, z: 2), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Instance FooMultipleOptionalParameters(int x, int y = 5, int z = 10)");
assert.Equal(i.FooMultipleOptionalParameters(1, 2, 3), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Instance FooMultipleOptionalParameters(int x, int y = 5, int z = 10)");
assert.Equal(i.FooMultipleOptionalParameters(1, z: 2, y: 3), "FooMultipleOptionalParameters(int x, int y = 5, int z = 10)", "Instance FooMultipleOptionalParameters(int x, int y = 5, int z = 10)");
assert.Equal(i.FooNamedArgument(x: 1), "FooNamedArgument(int x)", "Static FooNamedArgument(int x)");
assert.Equal(i.FooNamedArgument(d: 1), "FooNamedArgument(double d)", "Static FooNamedArgument(double d)");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(7);
var t1 = new Type();
assert.Ok(t1 != null, "#565 t1");
var t2 = new ValueType();
assert.Ok(t2 != null, "#565 t2");
var t3 = new IntPtr();
assert.Ok(t3.GetType() == typeof(IntPtr) , "#565 t3");
var t4 = new UIntPtr();
assert.Ok(t4.GetType() == typeof(UIntPtr), "#565 t4");
var t5 = new ParamArrayAttribute();
assert.Ok(t5 != null, "#565 t5");
var t6 = new RuntimeTypeHandle();
assert.Ok(t6.GetType() == typeof(RuntimeTypeHandle), "#565 t6");
var t7 = new RuntimeFieldHandle();
assert.Ok(t7.GetType() == typeof(RuntimeFieldHandle), "#565 t7");
}
public static void TestExplicitInterfaceMethodAndProperty(Assert assert)
{
assert.Expect(3);
ISimple b = new B();
assert.Ok(b != null, "Instance of B created through ISimple interface explicitly");
assert.Equal(b.GetString(), "explicit B.ISimple", "b.GetString() = explicit B.ISimple");
assert.Equal(b.Data, 2, "a.Data = 2");
}
private static void TestCreateLabel(Assert assert)
{
assert.Expect(6);
var view = Test.GetView();
var label = view.CreateLabelElement("someLabel", "Title", "10px", true, HTMLColor.Blue);
assert.Ok(label != null, "label created");
view.Root.AppendChild(label);
var foundLabel = Document.GetElementById<LabelElement>("someLabel");
assert.Ok(foundLabel != null, "foundLabel");
assert.DeepEqual(foundLabel.InnerHTML, "Title", "foundLabel.innerHtml = 'Title'");
assert.DeepEqual(foundLabel.Style.Color, HTMLColor.Blue, "foundLabel.Style.Color = Blue");
assert.DeepEqual(foundLabel.Style.Margin, "10px", "foundLabel.Style.Margin = '10px'");
assert.DeepEqual(foundLabel.Style.FontWeight, "bold", "foundLabel.Style.FontWeight = 'bold'");
}
public static void TestC(Assert assert)
{
assert.Expect(3);
var c = new C();
assert.Ok(c != null, "Instance of C created");
assert.Equal(c.GetString(), "C", "c.GetString() = 'C'");
assert.Equal(c.Data, -1, "c.Data = -1");
}
public static void TestB(Assert assert)
{
assert.Expect(3);
var b = new B();
assert.Ok(b != null, "Instance of B created");
assert.Equal(b.GetString(), "B", "b.GetString() = 'B'");
assert.Equal(b.Data, 1, "b.Data = 1");
}
public static void TestA(Assert assert)
{
assert.Expect(4);
var a = new A(10);
assert.Ok(a != null, "Instance of A created");
assert.Equal(a.X, 10, "a.X = 10");
assert.Equal(a.HandleNumber(100), 100, "a.HandleNumber(100) = 100");
assert.Equal(a.HandleString("Hundred"), "Hundred", "a.HandleString('Hundred') = 'Hundred'");
}
public static void TestB(Assert assert)
{
assert.Expect(7);
var a = new A();
assert.Ok(a != null, "Instance of A created");
assert.Equal(a.Test(), "A", "a.Test() = 'A'");
var b = new B();
assert.Ok(b != null, "Instance of B created");
assert.Equal(b.Test(), "B", "b.Test() = 'B'");
assert.Equal(b.TestA(), "A", "b.TestA() = 'A'");
A c = new B();
assert.Ok(c != null, "Instance of C created");
assert.Equal(c.Test(), "B", "c.Test() = 'B'");
}
public static void TestSubtractTimeSpan(Assert assert)
{
assert.Expect(4);
DateTime date1 = new DateTime(DateTime.Utc(1996, 6, 3, 22, 15, 0));
DateTime date2 = new DateTime(DateTime.Utc(1996, 12, 6, 13, 2, 0));
DateTime date3 = new DateTime(DateTime.Utc(1996, 10, 12, 8, 42, 0));
TimeSpan diff1 = date2.Subtract(date1);
assert.Ok(diff1.Equals(new TimeSpan(185, 14, 47, 0)), "Bridge582 TestSubtractTimeSpan diff1");
DateTime date4 = date3.Subtract(diff1);
assert.Ok(date4.Equals(new DateTime(DateTime.Utc(1996, 4, 9, 17, 55, 0))), "Bridge582 TestSubtractTimeSpan date4");
TimeSpan diff2 = date2 - date3;
assert.Ok(diff2.Equals(new TimeSpan(55, 4, 20, 0)), "Bridge582 TestSubtractTimeSpan diff2");
DateTime date5 = date1 - diff2;
assert.Ok(date5.Equals(new DateTime(DateTime.Utc(1996, 4, 9, 17, 55, 0))), "Bridge582 TestSubtractTimeSpan date5");
}
public static void TestAB(Assert assert)
{
assert.Expect(4);
A b = new B(10, 20);
assert.Ok(b != null, "Instance of B created as A type");
assert.Equal(b.X, 10, "b.X = 10");
assert.Equal(b.HandleNumber(10), 10, "b.HandleNumber(10) = 10");
assert.Equal(b.HandleString("Hundred"), "Hundred", "b.HandleString('Hundred') = 'Hundred'");
}
public static void TestB(Assert assert)
{
assert.Expect(5);
var b = new B(10, 20);
assert.Ok(b != null, "Instance of B created");
assert.Equal(b.X, 10, "b.X = 10");
assert.Equal(b.Y, 20, "b.Y = 20");
assert.Equal(b.HandleNumber(1), 100, "b.HandleNumber(1) = 100");
assert.Equal(b.HandleString("Hundred"), "Hundred", "b.HandleString('Hundred') = 'Hundred'");
}
private static void TestCreatePersonUIElements(Assert assert)
{
assert.Expect(2);
var application = Test.GetApplication();
application.RenderPerson();
var lblPersonName = Document.GetElementById<LabelElement>("lblPersonName");
assert.Ok(lblPersonName != null, "lblPersonName created");
assert.DeepEqual(lblPersonName.InnerHTML, "Frank", "lblPersonName = 'Frank'");
}
public static void Bridge329(Assert assert)
{
assert.Expect(5);
DateTime d1;
var b1 = DateTime.TryParse("2001-01-01", out d1, true);
assert.Ok(b1, "TryParse parsed '2001 - 01 - 01'");
assert.Equal(d1.GetUtcFullYear(), 2001, "TryParse works Year");
assert.Equal(d1.GetUtcMonth(), 1, "TryParse works Month");
assert.Equal(d1.GetUtcDay(), 1, "TryParse works Day");
var d2 = DateTime.Parse("2001-01-01", true);
assert.DeepEqual(d2.ToString(), d1.ToString(), "TryParse And Parse give the same result");
}
public static void IssueBridge393(Assert assert)
{
assert.Expect(2);
string a = "testa";
string b = "testa";
bool result = a.Equals(b, StringComparison.InvariantCultureIgnoreCase);
assert.Ok(result, "testa testa StringComparison.InvariantCultureIgnoreCase");
string a1 = "testa";
string b1 = "testb";
bool result1 = a1.Equals(b1, StringComparison.InvariantCultureIgnoreCase);
assert.NotOk(result1, "testa testb StringComparison.InvariantCultureIgnoreCase");
}
public static void TestTwoInterfaces(Assert assert)
{
assert.Expect(9);
var c = new C();
assert.Ok(c != null, "Instance of C created through ISimpleAsWell interface");
assert.Equal(c.GetStringAsWell(), "C.ISimpleAsWell", "a.GetStringAsWell() = A.ISimple through instance");
assert.Equal(c.DataAsWell, 4, "c.DataAsWell = 4 through instance");
var a = c as ISimple;
assert.Ok(a != null, "Instance of ISimple as C");
assert.Equal(a.GetString(), "C.ISimple", "a.GetString() = C.ISimple through interface");
assert.Equal(a.Data, 3, "a.Data = 3 through interface");
var b = c as ISimpleAsWell;
assert.Ok(b != null, "Instance of ISimpleAsWell as C");
assert.Equal(b.GetStringAsWell(), "C.ISimpleAsWell", "b.GetStringAsWell() = C.ISimpleAsWell through interface");
assert.Equal(b.DataAsWell, 4, "b.DataAsWell = 4 through interface");
}
public static void Bridge320(Assert assert)
{
assert.Expect(1);
string exceptionMessage = string.Empty;
try
{
Script.Write("\"someString\".SomeNotExistingMethod();");
}
catch (Exception ex)
{
exceptionMessage = ex.Message;
}
// var expectedMessage = Utilities.BrowserHelper.IsPhantomJs()
// ? "undefined is not a constructor (evaluating '\"someString\".SomeNotExistingMethod()')"
// : "\"someString\".SomeNotExistingMethod is not a function";
assert.Ok(exceptionMessage.Contains("SomeNotExistingMethod"), "ex.Message works on built-in JavaScript type");
}
// Bridge[#588]
public static void TestUseCase(Assert assert)
{
assert.Expect(9);
var c2 = new C2("C2 value");
assert.Ok(c2 != null, "Bridge588 C2");
assert.Equal(c2.Name, "C2 value", "Bridge588 C2.Name");
var c1 = new C1(c2);
assert.Ok(c1 != null, "Bridge588 C1");
assert.Equal(c1.Value.Name, "C2 value", "Bridge588 C1.Value.Name");
assert.Ok(C1.Default != null, "Bridge588 C1.Default");
assert.Ok(C1.Default.Value != null, "Bridge588 C1.Default.Value");
assert.Equal(C1.Default.Value.Name, "default", "Bridge588 C1.Default.Value.Name");
assert.Ok(C2.Default != null, "Bridge588 C2.Default");
assert.Ok(C2.Default.Name != null, "Bridge588 C2.Default.Name");
}
public static void TestEqualsGetHashCode(Assert assert)
{
assert.Expect(9);
var v1 = new Version(100, 200, 300, (400 << 16) + 500);
var v2 = new Version(100, 200, 300, (400 << 16) + 500);
var v3 = new Version(101, 200, 300, (400 << 16) + 500);
var o = new object();
object o2 = v2;
assert.Ok(v1.Equals(v2), "v1.Equals(v2)");
assert.NotOk(v1.Equals(v3), "v1.Equals(v3)");
assert.NotOk(v1.Equals(o), "v1.Equals(o)");
assert.NotOk(v1.Equals(null), "v1.Equals(null)");
assert.NotOk(v1.Equals(100), "v1.Equals(100)");
assert.Ok(v1.Equals(o2), "v1.Equals(o2)");
assert.Equal(v1.GetHashCode(), 1283637748, "v1.GetHashCode()");
assert.Equal(v2.GetHashCode(), 1283637748, "v2.GetHashCode()");
assert.Equal(v3.GetHashCode(), 1552073204, "v3.GetHashCode()");
}
public static void Bridge343(Assert assert)
{
assert.Expect(1);
string exceptionMessage = string.Empty;
var i = 0;
try
{
var r = 10 / i;
}
catch (ArgumentException)
{
}
catch (Exception ex)
{
exceptionMessage = ex.Message;
}
assert.Ok(!string.IsNullOrEmpty(exceptionMessage), "Double catch block with general Exception works");
}
public static void TestOperators(Assert assert)
{
assert.Expect(30);
var v1 = new Version(1, 2, 3, (4 << 16) + 5);
var v2 = new Version(1, 2, 3, (4 << 16) + 5);
var v3 = new Version(1, 3, 3, (4 << 16) + 5);
assert.Ok(v1 == v2, "v1 == v2");
assert.NotOk(v1 != v2, "v1 != v2");
assert.NotOk(v1 > v2, "v1 > v2");
assert.Ok(v1 >= v2, "v1 >= v2");
assert.NotOk(v1 < v2, "v1 < v2");
assert.Ok(v1 <= v2, "v1 <= v2");
assert.NotOk(v1 == v3, "v1 == v3");
assert.Ok(v1 != v3, "v1 != v3");
assert.NotOk(v1 > v3, "v1 > v3");
assert.NotOk(v1 >= v3, "v1 >= v3");
assert.Ok(v1 < v3, "v1 < v3");
assert.Ok(v1 <= v3, "v1 <= v3");
assert.NotOk(v1 == null, "v1 == null");
assert.Ok(v1 != null, "v1 != null");
assert.Ok(v1 > null, "v1 > null");
assert.Ok(v1 >= null, "v1 >= null");
assert.NotOk(v1 < null, "v1 < null");
assert.NotOk(v1 <= null, "v1 <= null");
assert.NotOk(null == v3, "null == v3");
assert.Ok(null != v3, "null != v3");
assert.NotOk(null > v3, "null > v3");
assert.NotOk(null >= v3, "null >= v3");
assert.Ok(null < v3, "null < v3");
assert.Ok(null <= v3, "null <= v3");
Version v4 = null;
Version v5 = null;
assert.Ok(v4 == v5, "v4 == v5");
assert.NotOk(v4 != v5, "v4 != v5");
assert.NotOk(v4 > v5, "v4 > v5");
assert.NotOk(v4 >= v5, "v4 >= v5");
assert.NotOk(v4 < v5, "v4 < v5");
assert.NotOk(v4 <= v5, "v4 <= v5");
}
