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 TesForeach(Assert assert)
{
assert.Expect(2);
string[] keys = new[] { "1", "2", "3" };
Action[] handlers = new Action[3];
int i = 0;
string result = "";
foreach (var itm in keys)
handlers[i++] = () => result += itm;
foreach (var handler in handlers)
{
handler();
}
assert.Equal(result, "123", "Bridge563 No block foreach loop");
i = 0;
result = "";
foreach (var itm in keys)
{
handlers[i++] = () => result += itm;
}
foreach (var handler in handlers)
{
handler();
}
assert.Equal(result, "123", "Bridge563 block foreach loop");
}
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(6);
// TEST
int[] numbers = new int[] { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
int i = 0;
var aQuery = from n in numbers select ++i;
assert.Equal(i, 0, "Query is not executed until you enumerate over them");
// TEST
aQuery.ToList();
assert.Equal(i, 10, "Query is executed after you enumerate over them");
i = 0;
// TEST
var bQuery = (from n in numbers select ++i).Max();
assert.Equal(i, 10, "Max() executes immediately");
// TEST
var smallNumbers = from n in numbers where n <= 3 select n;
var smallerEvenNumbers = from n in smallNumbers where n % 2 == 0 select n;
assert.DeepEqual(smallerEvenNumbers.ToArray(), new[] { 2, 0 }, "Query in a query");
// TEST
numbers.ForEach((x, index) => numbers[index] = -numbers[index]);
assert.DeepEqual(numbers.ToArray(), new int[] { -5, -4, -1, -3, -9, -8, -6, -7, -2, 0 }, "ForEach()");
// TEST
assert.DeepEqual(smallerEvenNumbers.ToArray(), new[] { -4, -8, -6, -2, 0 }, "Second query run on a modified source");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(2);
assert.Equal(Bridge537B.TestB1(), 2, "Bridge537 TestB1");
assert.Equal(Bridge537B.TestB2(), 1, "Bridge537 TestB2");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(2);
var inst = new Bridge597A();
assert.Equal(inst.Get(), "0:a", "Bridge597 Without instance member access");
assert.Equal(inst.GetWithMember(), "HI!:0:a", "Bridge597 With instance member access");
}
public static void Test(Assert assert)
{
assert.Expect(3);
assert.Equal(TestMethodParametersClass.MethodDefault(), 5, "Default parameter - 5");
assert.Equal(TestMethodParametersClass.MethodDefault(10), 10, "Default parameter - 10");
assert.Equal(TestMethodParametersClass.MethodParams(new[] { 1, 2, 3 }), 6, "params int[]");
}
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");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(3);
var pair = new KeyValuePair<int, string>(1, "value");
assert.Equal(pair.Key, 1, "Bridge479 Key");
assert.Equal(pair.Value, "value", "Bridge479 Value");
assert.Equal(pair.ToString(), "[1, value]", "Bridge479 ToString");
}
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 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 TestUseCase(Assert assert)
{
assert.Expect(2);
double d1 = 5.43;
assert.Equal(Math.Sign(d1), 1, "Bridge514 Sign(double 5.43)");
double d2 = -7.1;
assert.Equal(Math.Sign(d2), -1, "Bridge514 Sign(double -7.1)");
}
public static void TestRelated(Assert assert)
{
assert.Expect(2);
decimal d1 = 5.43M;
assert.Equal(Math.Sign(d1), 1, "Bridge514 Sign(decimal 5.43)");
decimal d2 = -7.1M;
assert.Equal(Math.Sign(d2), -1, "Bridge514 Sign(decimal -7.1)");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(2);
int i = 0;
object o = null;
assert.Equal(o.Method1(), "object", "Bridge615 object");
assert.Equal(i.Method1(), "int", "Bridge615 int");
}
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 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 TestUseCase(Assert assert)
{
assert.Expect(4);
var s = "0123456789";
assert.Equal(s.Remove(5), "01234", "Remove(5)");
assert.Equal(s.Remove(10), "0123456789", "Remove(10)");
assert.Equal(s.Remove(1, 2), "03456789", "Remove(1, 2)");
assert.Equal(s.Remove(1, 10), "0", "Remove(1, 10)");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(3);
var a = new Bridge647A { foo = 1 };
assert.Equal(a["bar"], 1, "Bridge647 A");
var b = new Bridge647B { foo = 1 };
assert.Equal(b["bar"], 1, "Bridge647 B bar");
assert.Equal(b["bar1"], 12, "Bridge647 B bar1");
}
public static void TestUseCase2(Assert assert)
{
assert.Expect(2);
var dc1 = new DerivedClass2();
dc1.AddValue(5);
assert.Equal(dc1.GetValues().Count, 1, "Bridge522 dc1.Count = 1");
var dc2 = new DerivedClass2();
assert.Equal(dc2.GetValues().Count, 0, "Bridge522 dc2.Count = 0");
}
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'");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(4);
var a = new Bridge635A();
var b = new Bridge635B();
assert.Equal(Script.TypeOf(a["internalFunc1"]), "function", "Bridge635 A.internalFunc1");
assert.Equal(Script.Get<Func<string>>(a, "internalFunc1")(), "A.Test1", "Bridge635 A.internalFunc1 Invoke");
assert.Equal(Script.TypeOf(b["internalFunc1"]), "function", "Bridge635 B.internalFunc1");
assert.Equal(Script.Get<Func<string>>(b, "internalFunc1")(), "B.Test1", "Bridge635 B.internalFunc1 Invoke");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(3);
var me = Global.ToDynamic().ClientTestLibrary.Bridge675;
me.id = "str1";
me.i1 = 1;
me.i2 = 2;
assert.Equal(me.dynMethod(me.id), "str1", "Bridge675 DynMethod");
assert.Equal(Method1(me.id), "str1", "Bridge675 Method1 id");
assert.Equal(Method1(me.i1, me.i2), 3, "Bridge675 Method1 i1 i2");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(4);
var a = new Bridge558A();
var b = new Bridge558B();
assert.Equal(a.zz(1), 1, "Bridge558 a.zz int");
assert.Equal(a.zz(""), 2, "Bridge558 a.zz string");
assert.Equal(b.zz(1), 1, "Bridge558 b.zz int");
assert.Equal(b.zz(""), 2, "Bridge558 b.zz string");
}
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 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 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 TestUseCase(Assert assert)
{
assert.Expect(1);
var ted = new Bridge566B();
assert.Equal(ted.Data, "Ted", "#566 Ted");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(1);
int[] numbers = { 1, 2, 3 };
int sum = 0;
foreach (int a in numbers)
{
sum = sum + a;
}
foreach (int a in numbers)
{
sum = sum + a;
}
foreach (int a in numbers)
{
sum = sum + a;
}
foreach (int a in numbers)
{
sum = sum + a;
}
assert.Equal(sum, 24, "Bridge502 sum");
}
public static void TestUseCase(Assert assert)
{
assert.Expect(1);
var o = JSON.Parse<bool>("true");
assert.Equal(o, true, "Bridge544 bool");
}
public static void TestRelated(Assert assert)
{
assert.Expect(5);
var i = JSON.Parse<int>("25");
assert.Equal(i, 25, "Bridge544 int");
var dbl = JSON.Parse<double>("26.1");
assert.Equal(dbl, 26.1d, "Bridge544 double");
var d = JSON.Parse<decimal>("27.2");
DecimalHelper.AssertIsDecimalAndEqualTo(assert, d, 27.2, "Bridge544 decimal");
var s = JSON.Parse<string>("\"Some string\"");
assert.Equal(s, "Some string", "Bridge544 string");
}
