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");
}
