public void TestIsTypeOf_DictionaryNull_IsTypeOfMessagePackObjectDictionary_Null()
{
Assert.AreEqual(null, new MessagePackObject(default(MessagePackObjectDictionary)).IsTypeOf(typeof(MessagePackObjectDictionary)));
}
public void TestOpExplicitDouble_Int64MinValue()
{
var result = ( System.Double )( new MessagePackObject( Int64.MinValue ) );
Assert.AreEqual( ( System.Double )( Int64.MinValue ), result, ( System.Double )0 );
}
public void TestOpExplicitSByte_DoubleMinusOne()
{
var result = ( System.SByte )( new MessagePackObject( ( System.Double )( -1 ) ) );
Assert.AreEqual( ( System.SByte )( -1 ), result );
}
public void TestOpExplicitUInt64_DoublePlusOne()
{
var result = ( System.UInt64 )( new MessagePackObject( ( System.Double )1 ) );
Assert.AreEqual( ( System.UInt64 )( 1 ), result );
}
public void TestOpExplicitUInt64_UInt64MaxValue_Success()
{
var result = ( System.UInt64 )( new MessagePackObject( UInt64.MaxValue ) );
Assert.AreEqual( ( System.UInt64 )( UInt64.MaxValue ), result );
}
public void Create_TextReader()
{
var div = CQ.Create(new StringReader(divDom));
Assert.AreEqual(divDom, div.Render());
}
// This test is excluded for now because we don't support namespaces in data
//[Test,TestMethod]
public void DataStringAndObject()
{
var parent = jQuery("<div><div></div></div>");
var div = parent.Children();
//parent
// .bind("getData", function(){ ok( false, "getData bubbled." ) })
// .bind("setData", function(){ ok( false, "setData bubbled." ) })
// .bind("changeData", function(){ ok( false, "changeData bubbled." ) });
Assert.IsTrue(div.Data("test") == null, "Check for no data exists");
div.Data("test", "success");
Assert.AreEqual(div.Data("test"), "success", "Check for added data");
div.Data("test", "overwritten");
Assert.AreEqual(div.Data("test"), "overwritten", "Check for overwritten data");
// [CsQuery] N/a - no such thing as undefined
//equal( div.data("test", undefined).data("test"), "overwritten", "Check that .data('key',undefined) does nothing but is chainable (#5571)");
div.Data("test", null);
Assert.IsTrue(div.Data("test") == null, "Check for null data");
Assert.IsTrue(div.Data("notexist") == null, "Check for no data exists");
div.Data("test", "overwritten");
var hits = new { test = 0 };
//object nullValue = null;
var gets = new { test = 0 };
//dynamic changes = new JsObject();
//changes.test = 0;
//changes.value = null;
//function logChangeData(e,key,value) {
// var dataKey = key;
// if ( e.namespace ) {
// dataKey = dataKey + "." + e.namespace;
// }
// changes[key] += value;
// changes.value = jQuery.Data(e.target, dataKey);
//}
//div
// .bind("setData",function(e,key,value){ hits[key] += value; })
// .bind("setData.foo",function(e,key,value){ hits[key] += value; })
// .bind("changeData",logChangeData)
// .bind("changeData.foo",logChangeData)
// .bind("getData",function(e,key){ gets[key] += 1; })
// .bind("getData.foo",function(e,key){ gets[key] += 3; });
div.Data("test.foo", 2);
Assert.AreEqual(div.Data("test"), "overwritten", "Check for original data");
Assert.AreEqual(div.Data("test.foo"), 2, "Check for namespaced data");
Assert.AreEqual(div.Data("test.bar"), "overwritten", "Check for unmatched namespace");
// NO EVENTS
//Assert.AreEqual( hits.test, 2, "Check triggered setter functions" );
//Assert.AreEqual( gets.test, 5, "Check triggered getter functions" );
//Assert.AreEqual( changes.test, 2, "Check sets raise changeData");
//Assert.AreEqual( changes.value, 2, "Check changeData after data has been set" );
//hits.test = 0;
//gets.test = 0;
//changes.test = 0;
//changes.value = null;
div.Data("test", 1);
Assert.AreEqual(div.Data("test"), 1, "Check for original data");
Assert.AreEqual(div.Data("test.foo"), 2, "Check for namespaced data");
Assert.AreEqual(div.Data("test.bar"), 1, "Check for unmatched namespace");
//Assert.AreEqual( hits.test, 1, "Check triggered setter functions" );
//Assert.AreEqual( gets.test, 5, "Check triggered getter functions" );
//Assert.AreEqual( changes.test, 1, "Check sets raise changeData" );
//Assert.AreEqual( changes.value, 1, "Check changeData after data has been set" );
//div
// .bind("getData",function(e,key){ return key + "root"; })
// .bind("getData.foo",function(e,key){ return key + "foo"; });
Assert.AreEqual(div.Data("test"), "testroot", "Check for original data");
Assert.AreEqual(div.Data("test.foo"), "testfoo", "Check for namespaced data");
Assert.AreEqual(div.Data("test.bar"), "testroot", "Check for unmatched namespace");
// [CsQuery] we don't do data on objects
//// #3748
//var elem = jQuery(new {exists=true});
//Assert.AreEqual( elem.Data("nothing"), null, "Non-existent data returns undefined");
//Assert.AreEqual( elem.Data("null", null).Data("null"), null, "null's are preserved");
//Assert.AreEqual( elem.Data("emptyString", "").Data("emptyString"), "", "Empty strings are preserved");
//Assert.AreEqual( elem.Data("false", false).Data("false"), false, "false's are preserved");
//Assert.AreEqual( elem.Data("exists"), null, "Existing data is not returned" );
// Clean up
//elem.RemoveData();
//Assert.AreEqual( elem[0], new {exists=true}, "removeData does not clear the object" );
// manually clean up detached elements
parent.Remove();
}
public void TestMethod1(int a, int b, double expectedResult)
{
double result = new SimpleCalculator().Plus(a, b);
Assert.AreEqual(expectedResult, result);
}
public void ComplexSelectors()
{
var res = Dom.Select("input:checkbox,li");
Assert.AreEqual(7, res.Length, "Multiple select (two queries appended)");
}
public void TestMethod1()
{
Assert.AreEqual(1, 1);
}
public void ListVM_Contains_Empty_BusinessList()
{
var dl = new List <TestItemDM>();
var bl = new ListBM <TestItemBM> {
Metadata = { DataProvider = { Data = dl } }
};
var vl = new ListVM <TestItemVM> {
Metadata = { DataProvider = { Data = bl } }
};
var di = (TestItemDM)null;
var vi = (TestItemVM)null;
Assert.AreEqual(false, vl.IsReadOnly);
Assert.AreEqual(false, ((IList)vl).IsFixedSize);
vl.Add(vi = new TestItemVM {
Metadata = { DataProvider = { Data = new TestItemBM {
Metadata = { DataProvider= { Data= di = new TestItemDM(0) } }
} } }
});
Assert.AreEqual(1, bl.Count);
Assert.AreEqual(1, dl.Count);
Assert.AreEqual(0, vl.IndexOf(vi));
Assert.AreEqual(0, ((IList)vl).IndexOf(vi));
Assert.AreEqual(true, ((IList)vl).Contains(vi));
Assert.AreEqual(vi, vl[0]);
Assert.AreEqual(vi, ((IList)vl)[0]);
vl.Add(new TestItemVM {
Metadata = { DataProvider = { Data = new TestItemBM {
Metadata = { DataProvider= { Data= new TestItemDM(1) } }
} } }
});
Assert.AreEqual(2, dl.Count);
vl.Add(new TestItemVM {
Metadata = { DataProvider = { Data = new TestItemBM {
Metadata = { DataProvider= { Data= new TestItemDM(2) } }
} } }
});
Assert.AreEqual(3, dl.Count);
vl.RemoveAt(1);
Assert.AreEqual(2, dl.Count);
vl.Remove(vi);
Assert.AreEqual(1, dl.Count);
vl.Clear();
Assert.AreEqual(0, dl.Count);
vl.Insert(0, new TestItemVM {
Metadata = { DataProvider = { Data = new TestItemBM {
Metadata = { DataProvider= { Data= new TestItemDM(0) } }
} } }
});
vl.Insert(0, new TestItemVM {
Metadata = { DataProvider = { Data = new TestItemBM {
Metadata = { DataProvider= { Data= new TestItemDM(1) } }
} } }
});
vl.Insert(2, new TestItemVM {
Metadata = { DataProvider = { Data = new TestItemBM {
Metadata = { DataProvider= { Data= new TestItemDM(2) } }
} } }
});
Assert.AreEqual(3, dl.Count);
foreach (var item in vl)
{
Assert.IsTrue(vl.Contains(item));
}
foreach (var item in (IEnumerable)vl)
{
Assert.IsTrue(vl.Contains(item));
}
vl.CopyTo(new TestItemVM[3], 0);
vl[0] = TestItemVM.New();
((IList)vl)[0] = TestItemVM.New();
vl.Move(0, 2);
vl.Dispose();
}
public void InferConformanceLevel()
{
XmlReader xr = XmlReader.Create(new StringReader("<foo/><bar/>"));
AssertType.AreEqual(ConformanceLevel.Document, xr.Settings.ConformanceLevel);
}
// [TestCase("SimilarAssets", typeof(IEnumerable<>))]
public void ValidateGarmentModels(string propertyName, object type)
{
var property = _Garmentstype.GetProperty(propertyName);
Assert.AreEqual(property.PropertyType, type);
}
public void PrependBug()
{
var result = CQ.CreateFragment("<b>1</b><b>2</b><b>3</b>").Select("b").Prepend("__").Append("__").Text();
Assert.AreEqual("__1____2____3__", result);
}
public void VerifyAdminToken_Test3()
{
Assert.AreEqual(false, _authLogic.VerifyAdminToken("-500"));
}
public void Test6()
{
var exception = Assert.Throws <ArgumentException>(() => Service.Evaluate(""));
Assert.AreEqual(null, null);
}
public void TestHeteroArray()
{
var heteroList = new List <MessagePackObject>()
{
true,
false,
MessagePackObject.Nil,
0,
"",
123456,
-123456,
new String('a', 40000),
new String('a', 80000),
new MessagePackObject(
new MessagePackObjectDictionary()
{
{ "1", "foo" },
{ 2, MessagePackObject.Nil },
{ 3333333, -1 }
}
),
new MessagePackObject(new MessagePackObject[] { 1, 2, 3 })
};
var output = new MemoryStream();
Packer.Create(output).PackCollection(heteroList);
MessagePackObject obj = UnpackOne(output);
bool isSuccess = false;
try
{
var list = obj.AsList();
Assert.AreEqual(heteroList[0], list[0]);
Assert.AreEqual(heteroList[1], list[1]);
Assert.AreEqual(heteroList[2], list[2]);
Assert.AreEqual(heteroList[3], list[3]);
Assert.AreEqual(heteroList[4], list[4]);
Assert.AreEqual(heteroList[5], list[5]);
Assert.AreEqual(heteroList[6], list[6]);
Assert.AreEqual(heteroList[7], list[7]);
Assert.AreEqual(heteroList[8], list[8]);
Assert.AreEqual(
heteroList[9].AsDictionary()["1"],
list[9].AsDictionary()["1"]
);
Assert.IsTrue(list[9].AsDictionary()[2].IsNil);
Assert.AreEqual(
heteroList[9].AsDictionary()[3333333],
list[9].AsDictionary()[3333333]
);
Assert.AreEqual(heteroList[10].AsList()[0], list[10].AsList()[0]);
Assert.AreEqual(heteroList[10].AsList()[1], list[10].AsList()[1]);
Assert.AreEqual(heteroList[10].AsList()[2], list[10].AsList()[2]);
isSuccess = true;
}
finally
{
if (!isSuccess)
{
Console.WriteLine(Dump(obj));
}
}
}
public void Test7()
{
var exception = Assert.Throws <System.Data.SyntaxErrorException>(() => Service.Evaluate("*"));
Assert.AreEqual(null, null);
}
public void Create_String_Document()
{
var div = CQ.Create(divDom, HtmlParsingMode.Document);
Assert.AreEqual(divDomFull, div.Render());
}
public void Test2()
{
var result = Service.Evaluate("IV+II*V");
Assert.AreEqual(14, result);
}
public void TestOpExplicitUInt32_UInt32MinValue_Success()
{
var result = ( System.UInt32 )( new MessagePackObject( UInt32.MinValue ) );
Assert.AreEqual( ( System.UInt32 )( UInt32.MinValue ), result );
}
public void Test3()
{
var result = Service.Evaluate("MD+X-IX");
Assert.AreEqual(1501, result);
}
public void TestOpExplicitUInt64_ByteMinValue_Success()
{
var result = ( System.UInt64 )( new MessagePackObject( Byte.MinValue ) );
Assert.AreEqual( ( System.UInt64 )( Byte.MinValue ), result );
}
public void Test4()
{
var result = Service.Evaluate("I+II-I");
Assert.AreEqual(2, result);
}
public void TestOpExplicitSingle_UInt64MaxValue()
{
var result = ( System.Single )( new MessagePackObject( UInt64.MaxValue ) );
Assert.AreEqual( ( System.Single )( UInt64.MaxValue ), result, ( System.Single )0 );
}
public void Test5()
{
var result = Service.Evaluate("X-V");
Assert.AreEqual(5, result);
}
public void TestOpExplicitSByte_SinglePlusOne()
{
var result = ( System.SByte )( new MessagePackObject( ( System.Single )1 ) );
Assert.AreEqual( ( System.SByte )( 1 ), result );
}
public void VerifyAdminToken_Test()
{
Assert.AreEqual(true, _authLogic.VerifyAdminToken("1"));
}
public void TestOpExplicitSByte_SByteMinValue_Success()
{
var result = ( System.SByte )( new MessagePackObject( SByte.MinValue ) );
Assert.AreEqual( ( System.SByte )( SByte.MinValue ), result );
}
public void TestIsTypeOf_DictionaryNull_IsTypeOfListOfMessagePackObject_Null()
{
Assert.AreEqual(null, new MessagePackObject(default(MessagePackObjectDictionary)).IsTypeOf(typeof(List <KeyValuePair <MessagePackObject, MessagePackObject> >)));
}
