public void Take() { var ints = new[] { 8, 3, 5, 1 }.Take(3).ToArray(); QUnit.AreEqual(ints.Length, 3); QUnit.AreEqual(ints[0], 8); QUnit.AreEqual(ints[1], 3); QUnit.AreEqual(ints[2], 5); }
public void TakeWhileWithIndex() { var ints = new[] { 1, 2, 3, 4, 5 }.TakeWhile((x, i) => i < 3).ToArray(); QUnit.AreEqual(ints.Length, 3); QUnit.AreEqual(ints[0], 1); QUnit.AreEqual(ints[1], 2); QUnit.AreEqual(ints[2], 3); }
public void SelectWithIndex() { var array = new[] { "1", "2", "3" }; var two = array.Select((x, i) => x + "a" + i).ToArray(); QUnit.AreEqual(two[0], "1a0"); QUnit.AreEqual(two[1], "2a1"); QUnit.AreEqual(two[2], "3a2"); }
public void DupsDontChangeCount() { var dictionary = new Dictionary <string, int>(); dictionary["one"] = 1; dictionary["one"] = 2; QUnit.AreEqual(dictionary["one"], 2); QUnit.AreEqual(dictionary.Count, 1); }
public void Set() { var dictionary = new Dictionary <string, int>(); dictionary["one"] = 1; dictionary["two"] = 2; QUnit.AreEqual(dictionary["one"], 1); QUnit.AreEqual(dictionary["two"], 2); }
public void SkipWhile() { var ints = new[] { 1, 2, 3, 4, 5 }.SkipWhile(x => x < 3).ToArray(); QUnit.AreEqual(ints.Length, 3); QUnit.AreEqual(ints[0], 3); QUnit.AreEqual(ints[1], 4); QUnit.AreEqual(ints[2], 5); }
public void NameForOverload() { var method = typeof(MethodClass).GetMethod("Overload", new[] { typeof(int) }); QUnit.AreEqual(method.GetParameters()[0].ParameterType, typeof(int)); method = typeof(MethodClass).GetMethod("Overload", new[] { typeof(string) }); QUnit.AreEqual(method.GetParameters()[0].ParameterType, typeof(string)); }
public void WhereWithIndex() { var array = new[] { "1", "2", "3" }; var result = array.Where((x, i) => x == "2" || i == 2).ToArray(); QUnit.AreEqual(result.Length, 2); QUnit.AreEqual(result[0], "2"); QUnit.AreEqual(result[1], "3"); }
public void InvokeInstanceMethod() { var methods = typeof(MethodClass).GetMethods(); var method = methods.Single(x => x.Name == "InstanceMethod"); var instance = new MethodClass(); var result = (string)method.Invoke(instance, new object[0]); QUnit.AreEqual(result, "InstanceMethod"); }
public void Property() { Expression <Func <ClassWithMembers, string> > lambda = x => x.StringProperty; var memberExpression = (MemberExpression)lambda.Body; QUnit.AreEqual(memberExpression.Expression, lambda.Parameters[0]); QUnit.IsTrue(memberExpression.Member is PropertyInfo); QUnit.AreEqual(memberExpression.Member.Name, "StringProperty"); }
public void Select() { var array = new[] { "1", "2", "3" }; var two = array.Select(x => x + "a").ToArray(); QUnit.AreEqual(two[0], "1a"); QUnit.AreEqual(two[1], "2a"); QUnit.AreEqual(two[2], "3a"); }
public void ElementAtOrDefault() { var items = new[] { 0, 1, 2 }; QUnit.AreEqual(items.ElementAtOrDefault(0), 0); QUnit.AreEqual(items.ElementAtOrDefault(1), 1); QUnit.AreEqual(items.ElementAtOrDefault(2), 2); QUnit.AreEqual(items.ElementAtOrDefault(3), 0); }
public void Union() { var union = new[] { 1, 1, 2 }.Union(new[] { 1, 2, 2, 3 }).ToArray(); QUnit.AreEqual(union.Length, 3); QUnit.AreEqual(union[0], 1); QUnit.AreEqual(union[1], 2); QUnit.AreEqual(union[2], 3); }
public static void Run() { ModuleInfo module = new ModuleInfo(); module.BeforeEach = SetUp; module.AfterEach = Teardown; QUnit.Module("Unit Tests", module); QUnit.Test("Test1", Test1); }
public void Except() { var ints1 = new[] { 1, 2, 3, 4 }; var ints2 = new[] { 3, 4, 5, 6 }; var join = ints1.Except(ints2).ToArray(); QUnit.AreEqual(join.Length, 2); QUnit.AreEqual(join[0], 1); QUnit.AreEqual(join[1], 2); }
public void CallOneParameterStaticMethod() { Expression <Action> lambda = () => ClassWithMethods.OneParameterStaticMethod("foo"); var methodCallExpression = (MethodCallExpression)lambda.Body; QUnit.AreEqual(methodCallExpression.Method.Name, "OneParameterStaticMethod"); var argument = (ConstantExpression)methodCallExpression.Arguments[0]; QUnit.AreEqual(argument.Value, "foo"); }
public void NotBoolean() { Expression <Func <bool> > lambda = () => !true; var unaryExpression = (UnaryExpression)lambda.Body; var operand = (ConstantExpression)unaryExpression.Operand; QUnit.AreEqual(unaryExpression.NodeType, ExpressionType.Not); QUnit.AreEqual(unaryExpression.Type, typeof(bool)); QUnit.AreEqual(operand.Value, true); }
public static void Register() { QUnit.Test(nameof(RandomValueTest) + "->" + nameof(If_Property_Has_Already_Value_Do_Not_Change_It), If_Property_Has_Already_Value_Do_Not_Change_It); QUnit.Test(nameof(RandomValueTest) + "->" + nameof(Must_Support_Circular_Referenced_Types), Must_Support_Circular_Referenced_Types); QUnit.Test(nameof(RandomValueTest) + "->" + nameof(Must_Support_Primitive_Types), Must_Support_Primitive_Types); QUnit.Test(nameof(RandomValueTest) + "->" + nameof(String_With_Length_Parameter), String_With_Length_Parameter); }
public void Join() { var ints1 = new[] { 1, 2, 3, 4 }; var ints2 = new[] { 3, 4, 5, 6 }; var join = ints1.Join(ints2, x => x, x => x, (x, y) => x + y).ToArray(); QUnit.AreEqual(join.Length, 2); QUnit.AreEqual(join[0], 6); QUnit.AreEqual(join[1], 8); }
public void NewArrayOneDimensionNoInitializer() { Expression <Func <int[]> > lambda = () => new int[5]; var newArrayExpression = (NewArrayExpression)lambda.Body; QUnit.AreEqual(newArrayExpression.NodeType, ExpressionType.NewArrayBounds); var value = (ConstantExpression)newArrayExpression.Expressions[0]; QUnit.AreEqual(value.Value, 5); }
public void Reverse() { var ints = new[] { 1, 2, 3 }; var reverse = ints.Reverse().ToArray(); QUnit.AreEqual(reverse.Length, 3); QUnit.AreEqual(reverse[0], 3); QUnit.AreEqual(reverse[1], 2); QUnit.AreEqual(reverse[2], 1); }
public void LocalClosedVariable() { var s = "foo"; // This variable is being closed and should result in a // ConstantExpression when constructing the expression // tree since it's value is known at that time. Expression <Func <string, string> > lambda = x => s; var constantExpression = (ConstantExpression)lambda.Body; QUnit.AreEqual(constantExpression.Value, "foo"); }
public void DefaultIfEmpty() { var s = new string[0].DefaultIfEmpty().Single(); QUnit.AreEqual(s, null); var i = new int[0].DefaultIfEmpty().Single(); QUnit.AreEqual(i, 0); }
public void AsOperator() { Expression <Func <object> > lambda = () => "foo" as object; var unaryExpression = (UnaryExpression)lambda.Body; var operand = (ConstantExpression)unaryExpression.Operand; QUnit.AreEqual(unaryExpression.NodeType, ExpressionType.TypeAs); QUnit.AreEqual(operand.Value, "foo"); QUnit.AreEqual(unaryExpression.Type.FullName, typeof(object).FullName); }
public void DefaultIfEmptyExplicitDefault() { var s = new string[0].DefaultIfEmpty("default").Single(); QUnit.AreEqual(s, "default"); var i = new int[0].DefaultIfEmpty(5).Single(); QUnit.AreEqual(i, 5); }
public static void Run() { QUnit.Module("Inheritance Tests"); QUnit.Test("Inherited class from abstract class is converted correctly", assert => { var sample = new Derived { Id = 5, Long = 10L, Decimal = 10m, DateTime = DateTime.Now }; var serialized = Json.Serialize(sample); var deserialized = Json.Deserialize <Derived>(serialized); assert.Equal(deserialized.Id, sample.Id); assert.Equal(deserialized.DateTime == sample.DateTime, true); assert.Equal(deserialized.Decimal == sample.Decimal, true); assert.Equal(deserialized.Long == sample.Long, true); }); QUnit.Test("Inherited class from generic abstract class is converted correctly", assert => { var sample = new DerivedFromGeneric { Value = 20 }; var serialized = Json.Serialize(sample); var deserialized = Json.Deserialize <DerivedFromGeneric>(serialized); assert.Equal(deserialized.Value, 20); }); QUnit.Test("Inherited generic class from generic abstract class is converted correctly", assert => { var sample = new GenericDerived <int, string> { Value = "MyValue", OtherValue = 10 }; var serialized = Json.Serialize(sample); var deserialized = Json.Deserialize <GenericDerived <int, string> >(serialized); assert.Equal(deserialized.Value, sample.Value); assert.Equal(deserialized.OtherValue, sample.OtherValue); }); }
public static void Run() { ModuleInfo module = new ModuleInfo(); module.BeforeEach = SetUp; module.AfterEach = Teardown; QUnit.Module("Connection View Model Tests", module); QUnit.Test("Test Create Connection", TestCreateConnection); QUnit.Test("Test Create Connection Validation", TestCreateConnectionValidation); QUnit.Test("Check Connections Collection", CheckConnectionsCollection); }
public void EnqueueTwo() { var queue = new Queue <string>(); queue.Enqueue("one"); queue.Enqueue("two"); var items = queue.ToArray(); QUnit.AreEqual(items[0], "one"); QUnit.AreEqual(items[1], "two"); }
public void CallZeroParameterInstanceMethod() { var instance = new ClassWithMethods(); Expression <Action> lambda = () => instance.ZeroParameterInstanceMethod(); var methodCallExpression = (MethodCallExpression)lambda.Body; QUnit.AreEqual(methodCallExpression.Method.Name, "ZeroParameterInstanceMethod"); var target = (ConstantExpression)methodCallExpression.Object; QUnit.AreEqual(target.Value, instance); }
public void Append() { var builder = new StringBuilder(); builder.Append('a'); builder.Append("b"); builder.AppendLine(); builder.AppendLine('c'); builder.AppendLine("d"); QUnit.AreEqual(builder.ToString(), "ab\nc\nd\n"); }