private static void CtorSetTests() { QUnit.Module("CtorSetTests"); QUnit.Test("Simple string property CtorSet initialisation", assert => { var x = new SomethingWithStringId("abc"); assert.Equal(x.Id, "abc"); }); QUnit.Test("Simple string property CtorSet initialisation on 'Plain' autoProperty", assert => { var x = new SomethingWithPlainAutoPropertyStringId("abc"); assert.Equal(x.Id, "abc"); }); QUnit.Test("CtorSet may not be called outside of the constructor (only works if CtorSet is set consistently within the constructor)", assert => { #pragma warning disable CtorSet // CtorSet should only be used in specific circumstances - suppress this, we're testing the runtime error handling var x = new SomethingWithStringId("abc"); assert.Throws( () => x.CtorSet(_ => _.Id, "abc"), "CtorSet should throw if called outside of the constructor (since it should only be called once per property and the constructor should call it for all properties)" ); }); #pragma warning restore CtorSet // CtorSet should only be used in specific circumstances }
private static void CtorSetTests() { QUnit.Module("CtorSetTests"); QUnit.Test("Simple string property CtorSet initialisation", assert => { var x = new SomethingWithStringId("abc"); assert.Equal(x.Id, "abc"); }); QUnit.Test("Simple string property CtorSet initialisation on 'Plain' autoProperty", assert => { var x = new SomethingWithPlainAutoPropertyStringId("abc"); assert.Equal(x.Id, "abc"); }); QUnit.Test("CtorSet may not be called outside of the constructor (only works if CtorSet is set consistently within the constructor)", assert => { var x = new SomethingWithStringId("abc"); assert.Throws( () => x.CtorSet(_ => _.Id, "abc"), "CtorSet should throw if called outside of the constructor (since it should only be called once per property and the constructor should call it for all properties)" ); }); }
public static void RunTests() { QUnit.Module(nameof(InteractiveTranslationSessionTests)); QUnit.Test(nameof(CurrentSuggestion_EmptyPrefix), CurrentSuggestion_EmptyPrefix); QUnit.Test(nameof(UpdatePrefix_AddOneCompleteWord), UpdatePrefix_AddOneCompleteWord); QUnit.Test(nameof(UpdatePrefix_AddOnePartialWord), UpdatePrefix_AddOnePartialWord); QUnit.Test(nameof(UpdatePrefix_RemoveOneWord), UpdatePrefix_RemoveOneWord); QUnit.Test(nameof(UpdatePrefix_RemoveEntirePrefix), UpdatePrefix_RemoveEntirePrefix); QUnit.Test(nameof(Approve_Success), Approve_Success); QUnit.Test(nameof(Approve_Error), Approve_Error); QUnit.Test(nameof(Approve_SegmentInvalid), Approve_SegmentInvalid); QUnit.Test(nameof(GetSuggestionText_LastWordComplete), GetSuggestionText_LastWordComplete); QUnit.Test(nameof(GetSuggestionText_LastWordCompleteSuggestionIndexZero), GetSuggestionText_LastWordCompleteSuggestionIndexZero); QUnit.Test(nameof(GetSuggestionText_LastWordCompleteSuggestionIndexOne), GetSuggestionText_LastWordCompleteSuggestionIndexOne); QUnit.Test(nameof(GetSuggestionText_LastWordIncomplete), GetSuggestionText_LastWordIncomplete); QUnit.Test(nameof(GetSuggestionText_LastWordIncompleteSuggestionIndexZero), GetSuggestionText_LastWordIncompleteSuggestionIndexZero); QUnit.Test(nameof(GetSuggestionText_LastWordIncompleteSuggestionIndexOne), GetSuggestionText_LastWordIncompleteSuggestionIndexOne); QUnit.Test(nameof(IsSourceSegmentValid_SegmentValid), IsSourceSegmentValid_SegmentValid); QUnit.Test(nameof(IsSourceSegmentValid_SegmentInvalid), IsSourceSegmentValid_SegmentInvalid); }
public static void Go() { QUnit.Module("Navigator"); QUnit.Test("Single level: Static root plus dynamic 'item' id routes [static navigation methods]", TestHotelRouterWithStaticNavigationCalls); QUnit.Test("Single level: Static root plus dynamic 'item' id routes [via historyHandler NavigateTo changes]", TestHotelRouterWithDynamicNavigationCalls); QUnit.Test("Nested Navigators: Root plus static-root-plus-dynamic-'item'-id-routes for 'hotel' and 'restaurant' [static navigation methods]", TestNestedRouterWithStaticNavigationCalls); QUnit.Test("Nested Navigators: Root plus static-root-plus-dynamic-'item'-id-routes for 'hotel' and 'restaurant' [via historyHandler NavigateTo changes]", TestNestedRouterWithDynamiccNavigationCalls); }
public static void Run() { ModuleInfo module = new ModuleInfo(); module.BeforeEach = SetUp; module.AfterEach = Teardown; QUnit.Module("Unit Tests", module); QUnit.Test("Test1", Test1); }
public NeuralNetworkTest() { QUnit.Test("inputTest", InputTest); QUnit.Test("hiddenLayerTest", HiddenLayerTest); QUnit.Test("OutputTest", OutputTest); QUnit.Test("WeightTest", WeightTest); QUnit.Test("NeuroEvolutionTest", NeuroEvolution); QUnit.Test("EvolutionTest", EvolutionTest); }
public static void Run() { ModuleInfo module = new ModuleInfo(); module.BeforeEach = SetUp; module.AfterEach = Teardown; QUnit.Module("Contact View Model Tests", module); QUnit.Test("Test Create Contact", TestCreateContact); }
public static void Run() { QUnit.Module("Property"); var time = new DateTime(2016, 12, 10, 20, 30, 0, 100); var instance = new PropDataExample { Time = time, Long = 10, Decimal = 10m, Double = 2.5, Int32 = 20 }; var propData = Converters.ExtactExistingProps(instance); var timeProp = propData.FirstOrDefault(prop => prop.Name == "Time"); var longProp = propData.FirstOrDefault(prop => prop.Name == "Long"); var decimalProp = propData.FirstOrDefault(prop => prop.Name == "Decimal"); var doubleProp = propData.FirstOrDefault(prop => prop.Name == "Double"); var intProp = propData.FirstOrDefault(prop => prop.Name == "Int32"); QUnit.Test("Number of properties extracted is correct", assert => { assert.Equal(propData.Length, 5); }); QUnit.Test("Properties extracted are not null", assert => { assert.Equal(timeProp == null, false); assert.Equal(longProp == null, false); assert.Equal(decimalProp == null, false); assert.Equal(doubleProp == null, false); assert.Equal(intProp == null, false); }); QUnit.Test("Property types are extracted correctly", assert => { assert.Equal(timeProp.Type, typeof(DateTime)); assert.Equal(longProp.Type, typeof(long)); assert.Equal(decimalProp.Type, typeof(decimal)); assert.Equal(doubleProp.Type, typeof(double)); assert.Equal(intProp.Type, typeof(int)); }); QUnit.Test("Property values are extracted correctly", assert => { assert.Equal(timeProp.Value, time); assert.Equal((long)longProp.Value == (long)10, true); assert.Equal((decimal)decimalProp.Value == 10m, true); assert.Equal(doubleProp.Value, 2.5); assert.Equal(intProp.Value, 20); }); }
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 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 static void RunTests() { QUnit.Module(nameof(LatinWordTokenizerTests)); QUnit.Test(nameof(Tokenize_Empty_ReturnsEmpty), Tokenize_Empty_ReturnsEmpty); QUnit.Test(nameof(Tokenize_Whitespace_ReturnsEmpty), Tokenize_Whitespace_ReturnsEmpty); QUnit.Test(nameof(Tokenize_PunctuationAtEndOfWord_ReturnsTokens), Tokenize_PunctuationAtEndOfWord_ReturnsTokens); QUnit.Test(nameof(Tokenize_PunctuationAtStartOfWord_ReturnsTokens), Tokenize_PunctuationAtStartOfWord_ReturnsTokens); QUnit.Test(nameof(Tokenize_PunctuationInsideWord_ReturnsTokens), Tokenize_PunctuationInsideWord_ReturnsTokens); QUnit.Test(nameof(Tokenize_Abbreviation_ReturnsTokens), Tokenize_Abbreviation_ReturnsTokens); QUnit.Test(nameof(Tokenize_NonAsciiCharacter_DoesNotThrow), Tokenize_NonAsciiCharacter_DoesNotThrow); }
public static void RunTests() { QUnit.Module(nameof(TranslationEngineTests)); QUnit.Test(nameof(TranslateInteractively_Success), TranslateInteractively_Success); QUnit.Test(nameof(TranslateInteractively_Error), TranslateInteractively_Error); QUnit.Test(nameof(TranslateInteractively_NoRuleResult), TranslateInteractively_NoRuleResult); QUnit.Test(nameof(Train_NoErrors), Train_NoErrors); QUnit.Test(nameof(Train_ErrorCreatingBuild), Train_ErrorCreatingBuild); QUnit.Test(nameof(ListenForTrainingStatus_NoErrors), ListenForTrainingStatus_NoErrors); QUnit.Test(nameof(ListenForTrainingStatus_Close), ListenForTrainingStatus_Close); }
private static void ToStringTests() { QUnit.Module("ToString()"); QUnit.Test("NonBlankTrimmedString ToString() call works as expected", assert => assert.Equal(new NonBlankTrimmedString("xyz").ToString(), "xyz")); QUnit.Test("NonBlankTrimmedString in string interpolation works as expected", assert => assert.Equal($"{new NonBlankTrimmedString("xyz")}", "xyz")); QUnit.Test("NonBlankTrimmedString in string concatenation works as expected", assert => assert.Equal("" + new NonBlankTrimmedString("xyz"), "xyz")); QUnit.Test("[ObjectLiteral]-as-generic-type-param's ToString() call works as expected", assert => { // This is part of the second reproduce case in https://forums.bridge.net/forum/community/help/6001 var x = new MultiLanguageTextBoxModel(new LangKey(1)); assert.Equal(x.TestValue, "1"); }); }
private static void DictionaryTests() { QUnit.Module("Dictionary lookups"); QUnit.Test("Two instances of NonBlankTrimmedString with the same value are found to be equal when used as a Dictionary key", assert => { // This will test both the bridge.getHashCode AND the bridge.equals hacks var d = new Dictionary <NonBlankTrimmedString, int> { { new NonBlankTrimmedString("xyz"), 123 } }; assert.Ok(d.ContainsKey(new NonBlankTrimmedString("xyz"))); }); }
public static void Run() { QUnit.Module("TimeSpan Tests"); QUnit.Test("TimeSpan is converted correctly", assert => { var timeSpan = TimeSpan.FromHours(5); var serialized = Json.Serialize(timeSpan); var deserialized = Json.Deserialize(serialized, typeof(TimeSpan)).As <TimeSpan>(); assert.Equal(true, timeSpan.Ticks == deserialized.Ticks); }); }
public static void Run() { QUnit.Module("String tests"); var sample = "my string"; QUnit.Test("Strings is serialized and deserialized correctly", assert => { var serialized = Json.Serialize(sample); var deserialized = Json.Deserialize(serialized, typeof(string)).As <string>(); assert.Equal(deserialized, sample); }); }
public static void RunTests() { QUnit.Module(nameof(LineSegmentTokenizerTests)); QUnit.Test(nameof(Tokenize_Empty_ReturnsEmpty), Tokenize_Empty_ReturnsEmpty); QUnit.Test(nameof(Tokenize_SingleLine_ReturnsTokens), Tokenize_SingleLine_ReturnsTokens); QUnit.Test(nameof(Tokenize_MultipleLines_ReturnsTokens), Tokenize_MultipleLines_ReturnsTokens); QUnit.Test(nameof(Tokenize_EndsWithNewLine_ReturnsTokens), Tokenize_EndsWithNewLine_ReturnsTokens); QUnit.Test(nameof(Tokenize_EndsWithNewLineAndSpace_ReturnsTokens), Tokenize_EndsWithNewLineAndSpace_ReturnsTokens); QUnit.Test(nameof(Tokenize_EndsWithTextAndSpace_ReturnsTokens), Tokenize_EndsWithTextAndSpace_ReturnsTokens); QUnit.Test(nameof(Tokenize_EmptyLine_ReturnsTokens), Tokenize_EmptyLine_ReturnsTokens); QUnit.Test(nameof(Tokenize_LineEndsWithSpace_ReturnsTokens), Tokenize_LineEndsWithSpace_ReturnsTokens); }
public static void Run() { QUnit.Module("Service Registration Tests"); //QUnit.Test("Cable.Resolve throws exception if interface not reflectable", assert => //{ // try // { // var service = Client.Resolve<INonReflectable>(); // } // catch (ArgumentException ex) // { // assert.Equal(ex.Message, "The interface does not have any methods, if there are any methods then annotate the interface with the [Reflectable] attribute"); // } //}); //QUnit.Test("Cable.Resolve throws an exception if type is not an interface", assert => //{ // try // { // var service = Client.Resolve<int>(); // } // catch (ArgumentException ex) // { // var msg = ex.Message; // assert.Equal(msg, "Type Int32 must be an interface"); // } //}); //QUnit.Test("Cable.Resolve throws exception if reflectable interface does not have methods", assert => //{ // try // { // var service = Client.Resolve<IReflectable>(); // } // catch (ArgumentException ex) // { // var msg = ex.Message; // assert.Equal(msg, "The interface does not have any methods, if there are any methods then annotate the interface with the [Reflectable] attribute"); // } //}); QUnit.Test("Cable.Resolve doesn't throw exception on reflectable interface where all methods have return type of Task", assert => { var service = BridgeClient.Resolve <IService>(); assert.Equal(true, Script.IsDefined(service)); }); }
public static void RunTests() { QUnit.Module(nameof(LatinSentenceTokenizerTests)); QUnit.Test(nameof(Tokenize_Empty_ReturnsEmpty), Tokenize_Empty_ReturnsEmpty); QUnit.Test(nameof(Tokenize_SingleLine_ReturnsTokens), Tokenize_SingleLine_ReturnsTokens); QUnit.Test(nameof(Tokenize_MultipleLines_ReturnsTokens), Tokenize_MultipleLines_ReturnsTokens); QUnit.Test(nameof(Tokenize_TwoSentences_ReturnsTokens), Tokenize_TwoSentences_ReturnsTokens); QUnit.Test(nameof(Tokenize_Quotes_ReturnsTokens), Tokenize_Quotes_ReturnsTokens); QUnit.Test(nameof(Tokenize_QuotationInSentence_ReturnsTokens), Tokenize_QuotationInSentence_ReturnsTokens); QUnit.Test(nameof(Tokenize_Parens_ReturnsTokens), Tokenize_Parens_ReturnsTokens); QUnit.Test(nameof(Tokenize_Abbreviation_ReturnsTokens), Tokenize_Abbreviation_ReturnsTokens); QUnit.Test(nameof(Tokenize_IncompleteSentence_ReturnsTokens), Tokenize_IncompleteSentence_ReturnsTokens); QUnit.Test(nameof(Tokenize_CompleteSentenceWithSpaceAtEnd_ReturnsTokens), Tokenize_CompleteSentenceWithSpaceAtEnd_ReturnsTokens); }
static void EnumerableIsConvertedCorrectly() { var sample = GetNumber(10); var encoded = Converters.EncodeObject(sample); QUnit.Test("IEnumerable with yield return is converted corretly to array", assert => { assert.Equal(encoded == null, false); assert.Equal(encoded["Type"], "Array"); assert.Equal(encoded["Value"]["length"], 1); var number = Script.Write <object>("encoded.Value[0]"); assert.Equal(number["Type"], "Int32"); assert.Equal(number["Value"], 10); }); QUnit.Test("IEnumerable from range is converted correctly", assert => { var range = System.Linq.Enumerable.Range(1, 1); var converted = Converters.EncodeObject(range); assert.Equal(converted == null, false); assert.Equal(converted["Type"], "Array"); assert.Equal(converted["Value"]["length"], 1); var number = Script.Write <object>("converted.Value[0]"); assert.Equal(number["Type"], "Int32"); assert.Equal(number["Value"], 1); }); QUnit.Test("IEnumerable of int is serialized and deserialized correctly", assert => { IEnumerable <int> enu = Enumerable.Range(1, 10); var serialized = Json.Serialize(enu); var deserialized = Json.Deserialize <IEnumerable <int> >(serialized); assert.Equal(deserialized.Count(), enu.Count()); var enuArr = enu.ToArray(); var deserializedArr = deserialized.ToArray(); for (int i = 0; i < enuArr.Length; i++) { assert.Equal(enuArr[i], deserializedArr[i]); } }); }
private static void OptionalTests() { QUnit.Module("OptionalTests"); QUnit.Test("Optional.Map from one string to another", assert => { var x = Optional.For("abc"); x = x.Map(_ => _ + _); assert.Equal(x.IsDefined, true); assert.Equal(x.Value, "abcabc"); }); // I don't expect this to be a common thing to do but it makes more sense to allow a null result from a mapper to result in a Missing // response than for it to throw its toys out the pram QUnit.Test("Optional.Map from one string to null (should return Missing)", assert => { var x = Optional.For("abc"); x = x.Map <string>(_ => null); assert.Equal(x.IsDefined, false); }); QUnit.Test("Optional.Map from one string to itself (should return same instance back)", assert => { var x = Optional.For("abc"); var updatedX = x.Map(_ => _); assert.StrictEqual(updatedX, x); }); QUnit.Test("Optional Equality works with type that has with custom Equality override", assert => { var x0 = Optional.For(new StandardObjectWithCustomEquality("abc")); var x1 = Optional.For(new StandardObjectWithCustomEquality("abc")); assert.Ok(x0.Equals(x1)); }); QUnit.Test("Optional Equality works with type that is [ObjectLiteral] with custom Equality override", assert => { // Use NonBlankTrimmedString from ProductiveRage.Immutable.Extensions because that is an [ObjectLiteral] with a custom Equals method and referencing // that assembly pulls through the [ObjectLiteral] hacks that are required until the Bridge Team (hopefully) improve the support for them var x0 = Optional.For(new NonBlankTrimmedString("abc")); var x1 = Optional.For(new NonBlankTrimmedString("abc")); assert.Ok(x0.Equals(x1)); }); }
public override void Execute() { base.Execute(); MockGoogleTracerView mockView = new MockGoogleTracerView(); Container.RegisterInstance(typeof(IGoogleTracerView), mockView); GoogleTracerController controller = new GoogleTracerController(); QUnit.Test("Test get View", delegate { QUnit.Equals(mockView, controller.View); }); QUnit.Test("Test Execute() & ShowMoreResults()", delegate { GoogleSearchResponse data = new GoogleSearchResponse(); Mock mockAddShowMoreResults = new Mock(mockView, "add_showMoreResults"); mockAddShowMoreResults.Modify().Args(Is.Anything).ReturnValue(); Mock mockRenderSearchResult = new Mock(mockView, "renderSearchResult"); mockRenderSearchResult.Modify().Args(data).ReturnValue(); mockRenderSearchResult.Modify().Args(data).ReturnValue(); Mock mockGetScript = new Mock(Script.Eval("jQuery"), "getScript"); mockGetScript.Modify().Args(Is.Anything, Is.Anything).Callback(1, null).ReturnValue(); mockGetScript.Modify().Args(Is.Anything, Is.Anything).Callback(1, null).ReturnValue(); QUnit.Equals(0, mockView.SearchStart); ((Dictionary)(object)Window.Self)["_googlewebsearchresults"] = data; controller.Execute(); ((Dictionary)(object)Window.Self)["_googlewebsearchresults"] = data; controller.ShowMoreResults(); QUnit.Equals(4, mockView.SearchStart); mockAddShowMoreResults.Verify(); mockAddShowMoreResults.Restore(); mockRenderSearchResult.Verify(); mockRenderSearchResult.Restore(); mockGetScript.Verify(); mockGetScript.Restore(); }); }
static void ArrayIsEncodedCorrectly() { var arr = new int[] { 1, 2, 3 }; var encoded = Converters.EncodeObject(arr); QUnit.Test("Array of ints is encoded correctly", assert => { assert.Equal(encoded["Type"], "Array"); assert.Equal(encoded["Value"]["length"], arr.Length); var values = encoded["Value"].As <object[]>(); for (int i = 0; i < values.Length; i++) { var intJson = values[i]; assert.Equal(intJson["Type"], "Int32"); assert.Equal(intJson["Value"], i + 1); } }); }
private static void ClassKeyMapTests() { QUnit.Module("Class-Key Map Tests"); QUnit.Test("Get returns {Missing} for key not found", assert => { var map = Map <MyCompositeId, string> .Empty; assert.Equal(map.GetIfPresent(new MyCompositeId(123, "test")), Optional <string> .Missing); }); QUnit.Test("Get returns value for key just added", assert => { var map = Map <MyCompositeId, string> .Empty .AddOrUpdate(new MyCompositeId(123, "test"), "abc"); assert.Equal(map.GetIfPresent(new MyCompositeId(123, "test")), "abc"); }); QUnit.Test("Get returns {Missing} for key added and then removed", assert => { var map = Map <MyCompositeId, string> .Empty .AddOrUpdate(new MyCompositeId(123, "test"), "abc") .RemoveIfPresent(new MyCompositeId(123, "test")); assert.Equal(map.GetIfPresent(new MyCompositeId(123, "test")), Optional <string> .Missing); }); QUnit.Test("Nothing happens if key removed that does not exist", assert => { var map = Map <MyCompositeId, string> .Empty .RemoveIfPresent(new MyCompositeId(123, "test")); assert.Ok(true); }); QUnit.Test("Setting key that already exists overwrites existing data", assert => { var map = Map <MyCompositeId, string> .Empty .AddOrUpdate(new MyCompositeId(123, "test"), "abc") .AddOrUpdate(new MyCompositeId(123, "test"), "xyz"); assert.Equal(map.GetIfPresent(new MyCompositeId(123, "test")), "xyz"); assert.Equal(map.Count, 1); }); }
public static void Run() { QUnit.Module("List Tests"); QUnit.Test("List is encoded correctly", assert => { var list = new List <int>(); list.Add(1); list.Add(2); list.Add(3); var encoded = Converters.EncodeObject(list); assert.Equal(encoded["Type"], "List"); assert.Equal(encoded["Value"]["length"], list.Count); }); QUnit.Test("Serilization and deserialization of List<int> works", assert => { var sample = new List <int>(); sample.Add(10); sample.Add(20); var serialized = Json.Serialize(sample); var deserialized = Json.Deserialize <List <int> >(serialized); assert.Equal(deserialized == null, false); assert.Equal(sample.Count, deserialized.Count); for (int i = 0; i < sample.Count; i++) { assert.Equal(sample[i], deserialized[i]); } deserialized.Add(30); assert.Equal(deserialized.Sum(), 60); }); }
private static void IntKeyMapSerialisationTests() { QUnit.Module("Int-Key Map Serialisation Tests"); QUnit.Test("Single item serialised", assert => { var map = Map <int, string> .Empty.AddOrUpdate(123, "abc"); assert.Equal( JsonConvert.SerializeObject(map), "[{\"Key\":123,\"Value\":\"abc\"}]" ); }); QUnit.Test("Single item deserialised", assert => { var json = "[{\"Key\":123,\"Value\":\"abc\"}]"; var map = JsonConvert.DeserializeObject <Map <int, string> >(json); assert.Equal(map.Count, 1); assert.Equal(map.GetIfPresent(123), "abc"); }); }
public static void RunTests() { QUnit.Module("PersonService"); QUnit.Test("Method GetPerson()", (assert) => { var service = Test.GetService(); var person = service.GetPerson(55); assert.Expect(3); assert.Ok(person != null, "Person created"); assert.DeepEqual(person.Id, 55, "person.Id = 55"); assert.DeepEqual(person.Name, "Frank", "person.Name = 'Frank'"); }); QUnit.Module("PersonView"); QUnit.Test("Method CreateLabelElement", Test.TestCreateLabel); QUnit.Module("PersonApplication"); QUnit.Test("RenderPerson", Test.TestCreatePersonUIElements); }
static void DateTimeIsEncodedCorrectly() { var time = new DateTime(2016, 12, 10, 20, 30, 0, 235); var encoded = Converters.EncodeDateTime(time); QUnit.Test("Encoding DateTime works", assert => { assert.Equal(encoded["Type"], "DateTime"); assert.Equal(encoded["Value"], time.ToString("dd/MM/yyyy HH:mm:ss.fff")); }); QUnit.Test("Encoding boxed DateTime works", assert => { object boxed = time; var boxedEncoded = Converters.EncodeDateTime(boxed.As <DateTime>()); assert.DeepEqual(encoded, boxedEncoded); }); QUnit.Test("Encode -> Decode DateTime works", assert => { var now = DateTime.Now; var serialized = Json.Serialize(now); var deserialized = Json.Deserialize <DateTime>(serialized); assert.Equal(now.Year, deserialized.Year); assert.Equal(now.Month, deserialized.Month); assert.Equal(now.Day, deserialized.Day); assert.Equal(now.Hour, deserialized.Hour); assert.Equal(now.Minute, deserialized.Minute); assert.Equal(now.Second, deserialized.Second); assert.Equal(now.Millisecond, deserialized.Millisecond); }); }
public static void Go() { QUnit.Module("Static Matches"); QUnit.Test("Match '/'", assert => { var routeInfo = RouteBuilder.Empty; var url = UrlDetailsCreator.New(); assert.RouteMatched(routeInfo, url); }); QUnit.Test("Match '/home'", assert => { var routeInfo = RouteBuilder.Empty.Fixed("home"); var url = UrlDetailsCreator.New("home"); assert.RouteMatched(routeInfo, url); }); QUnit.Test("Match '/home/info'", assert => { var routeInfo = RouteBuilder.Empty.Fixed("home", "info"); var url = UrlDetailsCreator.New("home", "info"); assert.RouteMatched(routeInfo, url); }); QUnit.Test("NotFound '/home' if only '/other' route specified", assert => { var routeInfo = RouteBuilder.Empty.Fixed("other"); var url = UrlDetailsCreator.New("home"); assert.RouteNotMatched(routeInfo, url); }); QUnit.Test("NotFound '/home' if only '/home/info' route specified", assert => { var routeInfo = RouteBuilder.Empty.Fixed("home", "info"); var url = UrlDetailsCreator.New("home"); assert.RouteNotMatched(routeInfo, url); }); }