func main() { QUnit.ModuleLifecycle("A", Scenario{}) QUnit.Test("just a test", func(assert QUnit.QUnitAssert) { QUnit.Expect(1) assert.Ok(true, "") }) QUnit.Module("B") QUnit.Test("test 1", func(assert QUnit.QUnitAssert) { square := func(x int) int { return x * x } result := square(2) assert.DeepEqual(strconv.Itoa(result), strconv.Itoa(4), "square(2) equals 4") }) QUnit.Test("test 2", func(assert QUnit.QUnitAssert) { assert.Ok(true, "true succeeds") }) QUnit.Module("C") QUnit.Test("test 3", func(assert QUnit.QUnitAssert) { assert.Ok(true, "0 means false") }) QUnit.AsyncTest("Async Test", func() *js.Object { QUnit.Expect(1) return js.Global.Call("setTimeout", func() { QUnit.Ok(true, "async test failure") QUnit.Start() }, 500) }) }
func main() { wsBaseURL := getWSBaseURL() qunit.Module("websocket.WebSocket") qunit.Test("Invalid URL", func(assert qunit.QUnitAssert) { qunit.Expect(1) ws, err := websocket.New("blah://blah.example/invalid") if err == nil { ws.Close() assert.Ok(false, "Got no error, but expected an invalid URL error") return } assert.Ok(true, fmt.Sprintf("Received an error: %s", err)) }) qunit.AsyncTest("Immediate close", func() interface{} { qunit.Expect(2) ws, err := websocket.New(wsBaseURL + "immediate-close") if err != nil { qunit.Ok(false, fmt.Sprintf("Error opening WebSocket: %s", err)) qunit.Start() return nil } ws.AddEventListener("open", false, func(ev *js.Object) { qunit.Ok(true, "WebSocket opened") }) ws.AddEventListener("close", false, func(ev *js.Object) { const ( CloseNormal = 1000 CloseNoReasonSpecified = 1005 // IE10 hates it when the server closes without sending a close reason ) closeEvent := dom.WrapEvent(ev).(*dom.CloseEvent) if closeEvent.Code != CloseNormal && closeEvent.Code != CloseNoReasonSpecified { qunit.Ok(false, fmt.Sprintf("WebSocket close was not clean (code %d)", closeEvent.Code)) qunit.Start() return } qunit.Ok(true, "WebSocket closed") qunit.Start() }) return nil }) qunit.Module("websocket.Conn") qunit.AsyncTest("Immediate close", func() interface{} { go func() { defer qunit.Start() ws, err := websocket.Dial(wsBaseURL + "immediate-close") if err != nil { qunit.Ok(false, fmt.Sprintf("Error opening WebSocket: %s", err)) return } qunit.Ok(true, "WebSocket opened") _, err = ws.Read(nil) if err == io.EOF { qunit.Ok(true, "Received EOF") } else if err != nil { qunit.Ok(false, fmt.Sprintf("Unexpected error in second read: %s", err)) } else { qunit.Ok(false, "Expected EOF in second read, got no error") } }() return nil }) qunit.AsyncTest("Failed open", func() interface{} { go func() { defer qunit.Start() ws, err := websocket.Dial(wsBaseURL + "404-not-found") if err == nil { ws.Close() qunit.Ok(false, "Got no error, but expected an error in opening the WebSocket.") return } qunit.Ok(true, fmt.Sprintf("WebSocket failed to open: %s", err)) }() return nil }) qunit.AsyncTest("Binary read", func() interface{} { qunit.Expect(3) go func() { defer qunit.Start() ws, err := websocket.Dial(wsBaseURL + "binary-static") if err != nil { qunit.Ok(false, fmt.Sprintf("Error opening WebSocket: %s", err)) return } qunit.Ok(true, "WebSocket opened") var expectedData = []byte{0x00, 0x01, 0x02, 0x03, 0x04} receivedData := make([]byte, len(expectedData)) n, err := ws.Read(receivedData) if err != nil { qunit.Ok(false, fmt.Sprintf("Error in first read: %s", err)) return } receivedData = receivedData[:n] if !bytes.Equal(receivedData, expectedData) { qunit.Ok(false, fmt.Sprintf("Received data did not match expected data. Got % x, expected % x.", receivedData, expectedData)) } else { qunit.Ok(true, fmt.Sprintf("Received data: % x", receivedData)) } _, err = ws.Read(receivedData) if err == io.EOF { qunit.Ok(true, "Received EOF") } else if err != nil { qunit.Ok(false, fmt.Sprintf("Unexpected error in second read: %s", err)) } else { qunit.Ok(false, "Expected EOF in second read, got no error") } }() return nil }) qunit.AsyncTest("Timeout", func() interface{} { qunit.Expect(2) go func() { defer qunit.Start() ws, err := websocket.Dial(wsBaseURL + "wait-30s") if err != nil { qunit.Ok(false, fmt.Sprintf("Error opening WebSocket: %s", err)) return } qunit.Ok(true, "WebSocket opened") start := time.Now() ws.SetReadDeadline(start.Add(1 * time.Second)) _, err = ws.Read(nil) if err != nil && err.Error() == "i/o timeout: deadline reached" { totalTime := time.Now().Sub(start) if totalTime < 750*time.Millisecond { qunit.Ok(false, fmt.Sprintf("Timeout was too short: Received timeout after %s", totalTime)) return } qunit.Ok(true, fmt.Sprintf("Received timeout after %s", totalTime)) } else if err != nil { qunit.Ok(false, fmt.Sprintf("Unexpected error in read: %s", err)) } else { qunit.Ok(false, "Expected timeout in read, got no error") } }() return nil }) }
func main() { rclient := &remoton.Client{Prefix: "/remoton"} qunit.Module("remoton") qunit.AsyncTest("RPC", func() interface{} { qunit.Expect(1) go func() { defer qunit.Start() session := &remoton.SessionClient{Client: rclient, ID: "test", APIURL: "http://localhost:3000"} conn, err := session.Dial("rpc") if err != nil { qunit.Ok(false, err.Error()) } defer conn.Close() rpcclient := rpc.NewClient(conn) fmt.Println("remote call") var reply int err = rpcclient.Call("Arith.Multiply", &Args{7, 5}, &reply) if err != nil { qunit.Ok(false, "Call remote function:"+err.Error()) return } defer rpcclient.Close() if reply == 35 { qunit.Ok(true, "Multiply 7 * 5 == 35") } else { qunit.Ok(false, "Invalid reply") } }() return nil }) qunit.AsyncTest("Stream", func() interface{} { qunit.Expect(1) go func() { defer qunit.Start() session := &remoton.SessionClient{Client: rclient, ID: "test", APIURL: "http://localhost:3000"} conn, err := session.Dial("counter") if err != nil { qunit.Ok(false, err.Error()) } defer conn.Close() var counter byte for { buf := make([]byte, 1) _, err := conn.Read(buf) if err != nil { panic(err) } rcounter := buf[0] if rcounter != counter { qunit.Ok(false, fmt.Sprintf("Unexpected counter was %d expect %d", rcounter, counter)) return } fmt.Println(counter, rcounter) counter += 1 if counter == 10 { break } } qunit.Ok(true, "Stream verified") }() return nil }) }
func main() { QUnit.Module("Core") QUnit.Test("jQuery Properties", func(assert QUnit.QUnitAssert) { assert.Equal(jQuery().Jquery, "2.1.1", "JQuery Version") assert.Equal(jQuery().Length, 0, "jQuery().Length") jQ2 := jQuery("body") assert.Equal(jQ2.Selector, "body", `jQ2 := jQuery("body"); jQ2.Selector.Selector`) assert.Equal(jQuery("body").Selector, "body", `jQuery("body").Selector`) }) //start dom tests QUnit.Test("Test Setup", func(assert QUnit.QUnitAssert) { test := jQuery(getDocumentBody()).Find(FIX) assert.Equal(test.Selector, FIX, "#qunit-fixture find Selector") assert.Equal(test.Context, getDocumentBody(), "#qunit-fixture find Context") }) QUnit.Test("Static Functions", func(assert QUnit.QUnitAssert) { jquery.GlobalEval("var globalEvalTest = 2;") assert.Equal(js.Global.Get("globalEvalTest").Int(), 2, "GlobalEval: Test variable declarations are global") assert.Equal(jquery.Trim(" GopherJS "), "GopherJS", "Trim: leading and trailing space") assert.Equal(jquery.Type(true), "boolean", "Type: Boolean") assert.Equal(jquery.Type(time.Now()), "date", "Type: Date") assert.Equal(jquery.Type("GopherJS"), "string", "Type: String") assert.Equal(jquery.Type(12.21), "number", "Type: Number") assert.Equal(jquery.Type(nil), "null", "Type: Null") assert.Equal(jquery.Type([2]string{"go", "lang"}), "array", "Type: Array") assert.Equal(jquery.Type([]string{"go", "lang"}), "array", "Type: Array") o := map[string]interface{}{"a": true, "b": 1.1, "c": "more"} assert.Equal(jquery.Type(o), "object", "Type: Object") assert.Equal(jquery.Type(getDocumentBody), "function", "Type: Function") assert.Ok(!jquery.IsPlainObject(""), "IsPlainObject: string") assert.Ok(jquery.IsPlainObject(o), "IsPlainObject: Object") assert.Ok(!jquery.IsEmptyObject(o), "IsEmptyObject: Object") assert.Ok(jquery.IsEmptyObject(map[string]interface{}{}), "IsEmptyObject: Object") assert.Ok(!jquery.IsFunction(""), "IsFunction: string") assert.Ok(jquery.IsFunction(getDocumentBody), "IsFunction: getDocumentBody") assert.Ok(!jquery.IsNumeric("a3a"), "IsNumeric: string") assert.Ok(jquery.IsNumeric("0xFFF"), "IsNumeric: hex") assert.Ok(jquery.IsNumeric("8e-2"), "IsNumeric: exponential") assert.Ok(!jquery.IsXMLDoc(getDocumentBody), "HTML Body element") assert.Ok(jquery.IsWindow(js.Global), "window") }) QUnit.Test("ToArray,InArray", func(assert QUnit.QUnitAssert) { jQuery(`<div>a</div> <div>b</div> <div>c</div>`).AppendTo(FIX) divs := jQuery(FIX).Find("div") assert.Equal(divs.Length, 3, "3 divs in Fixture inserted") str := "" for _, v := range divs.ToArray() { str += jQuery(v).Text() } assert.Equal(str, "abc", "ToArray() allows range over selection") arr := []interface{}{"a", 3, true, 2.2, "GopherJS"} assert.Equal(jquery.InArray(4, arr), -1, "InArray") assert.Equal(jquery.InArray(3, arr), 1, "InArray") assert.Equal(jquery.InArray("a", arr), 0, "InArray") assert.Equal(jquery.InArray("b", arr), -1, "InArray") assert.Equal(jquery.InArray("GopherJS", arr), 4, "InArray") }) QUnit.Test("ParseHTML, ParseXML, ParseJSON", func(assert QUnit.QUnitAssert) { str := `<ul> <li class="firstclass">list item 1</li> <li>list item 2</li> <li>list item 3</li> <li>list item 4</li> <li class="lastclass">list item 5</li> </ul>` arr := jquery.ParseHTML(str) jQuery(arr).AppendTo(FIX) assert.Equal(jQuery(FIX).Find("ul li").Length, 5, "ParseHTML") xml := "<rss version='2.0'><channel><title>RSS Title</title></channel></rss>" xmlDoc := jquery.ParseXML(xml) assert.Equal(jQuery(xmlDoc).Find("title").Text(), "RSS Title", "ParseXML") obj := jquery.ParseJSON(`{ "language": "go" }`) language := obj.(map[string]interface{})["language"].(string) assert.Equal(language, "go", "ParseJSON") }) QUnit.Test("Grep", func(assert QUnit.QUnitAssert) { arr := []interface{}{1, 9, 3, 8, 6, 1, 5, 9, 4, 7, 3, 8, 6, 9, 1} arr2 := jquery.Grep(arr, func(n interface{}, idx int) bool { return n.(float64) != float64(5) && idx > 4 }) assert.Equal(len(arr2), 9, "Grep") }) QUnit.Test("Noop,Now", func(assert QUnit.QUnitAssert) { callSth := func(fn func() interface{}) interface{} { return fn() } _ = callSth(jquery.Noop) _ = jquery.Noop() assert.Ok(jquery.IsFunction(jquery.Noop), "jquery.Noop") date := js.Global.Get("Date").New() time := date.Call("getTime").Float() assert.Ok(time <= jquery.Now(), "jquery.Now()") }) QUnit.Module("Dom") QUnit.Test("AddClass,Clone,Add,AppendTo,Find", func(assert QUnit.QUnitAssert) { jQuery("p").AddClass("wow").Clone().Add("<span id='dom02'>WhatADay</span>").AppendTo(FIX) txt := jQuery(FIX).Find("span#dom02").Text() assert.Equal(txt, "WhatADay", "Test of Clone, Add, AppendTo, Find, Text Functions") jQuery(FIX).Empty() html := ` <div>This div should be white</div> <div class="red">This div will be green because it now has the "green" and "red" classes. It would be red if the addClass function failed.</div> <div>This div should be white</div> <p>There are zero green divs</p> <button>some btn</button>` jQuery(html).AppendTo(FIX) jQuery(FIX).Find("div").AddClass(func(index int, currentClass string) string { addedClass := "" if currentClass == "red" { addedClass = "green" jQuery("p").SetText("There is one green div") } return addedClass }) jQuery(FIX).Find("button").AddClass("red") assert.Ok(jQuery(FIX).Find("button").HasClass("red"), "button hasClass red") assert.Ok(jQuery(FIX).Find("p").Text() == "There is one green div", "There is one green div") assert.Ok(jQuery(FIX).Find("div:eq(1)").HasClass("green"), "one div hasClass green") jQuery(FIX).Empty() }) QUnit.Test("Children,Append", func(assert QUnit.QUnitAssert) { var j = jQuery(`<div class="pipe animated"><div class="pipe_upper" style="height: 79px;"></div><div class="guess top" style="top: 114px;"></div><div class="pipe_middle" style="height: 100px; top: 179px;"></div><div class="guess bottom" style="bottom: 76px;"></div><div class="pipe_lower" style="height: 41px;"></div><div class="question"></div></div>`) assert.Ok(len(j.Html()) == 301, "jQuery html len") j.Children(".question").Append(jQuery(`<div class = "question_digit first" style = "background-image: url('assets/font_big_3.png');"></div>`)) assert.Ok(len(j.Html()) == 397, "jquery html len after 1st jquery object append") j.Children(".question").Append(jQuery(`<div class = "question_digit symbol" style="background-image: url('assets/font_shitty_x.png');"></div>`)) assert.Ok(len(j.Html()) == 497, "jquery htm len after 2nd jquery object append") j.Children(".question").Append(`<div class = "question_digit second" style = "background-image: url('assets/font_big_1.png');"></div>`) assert.Ok(len(j.Html()) == 594, "jquery html len after html append") }) QUnit.Test("ApiOnly:ScollFn,SetCss,CssArray,FadeOut", func(assert QUnit.QUnitAssert) { //QUnit.Expect(0) for i := 0; i < 3; i++ { jQuery("p").Clone().AppendTo(FIX) } jQuery(FIX).Scroll(func(e jquery.Event) { jQuery("span").SetCss("display", "inline").FadeOut("slow") }) htmlsnippet := `<style> div { height: 50px; margin: 5px; padding: 5px; float: left; } #box1 { width: 50px; color: yellow; background-color: blue; } #box2 { width: 80px; color: rgb(255, 255, 255); background-color: rgb(15, 99, 30); } #box3 { width: 40px; color: #fcc; background-color: #123456; } #box4 { width: 70px; background-color: #f11; } </style> <p id="result"> </p> <div id="box1">1</div> <div id="box2">2</div> <div id="box3">3</div> <div id="box4">4</div>` jQuery(htmlsnippet).AppendTo(FIX) jQuery(FIX).Find("div").On("click", func(evt jquery.Event) { html := []string{"The clicked div has the following styles:"} var styleProps = jQuery(evt.Target).CssArray("width", "height") for prop, value := range styleProps { html = append(html, prop+": "+value.(string)) } jQuery(FIX).Find("#result").SetHtml(strings.Join(html, "<br>")) }) jQuery(FIX).Find("div:eq(0)").Trigger("click") assert.Ok(jQuery(FIX).Find("#result").Html() == "The clicked div has the following styles:<br>width: 50px<br>height: 50px", "CssArray read properties") }) QUnit.Test("ApiOnly:SelectFn,SetText,Show,FadeOut", func(assert QUnit.QUnitAssert) { QUnit.Expect(0) jQuery(`<p>Click and drag the mouse to select text in the inputs.</p> <input type="text" value="Some text"> <input type="text" value="to test on"> <div></div>`).AppendTo(FIX) jQuery(":input").Select(func(e jquery.Event) { jQuery("div").SetText("Something was selected").Show().FadeOut("1000") }) }) QUnit.Test("Eq,Find", func(assert QUnit.QUnitAssert) { jQuery(`<div></div> <div></div> <div class="test"></div> <div></div> <div></div> <div></div>`).AppendTo(FIX) assert.Ok(jQuery(FIX).Find("div").Eq(2).HasClass("test"), "Eq(2) has class test") assert.Ok(!jQuery(FIX).Find("div").Eq(0).HasClass("test"), "Eq(0) has no class test") }) QUnit.Test("Find,End", func(assert QUnit.QUnitAssert) { jQuery(`<p class='ok'><span class='notok'>Hello</span>, how are you?</p>`).AppendTo(FIX) assert.Ok(jQuery(FIX).Find("p").Find("span").HasClass("notok"), "before call to end") assert.Ok(jQuery(FIX).Find("p").Find("span").End().HasClass("ok"), "after call to end") }) QUnit.Test("Slice,Attr,First,Last", func(assert QUnit.QUnitAssert) { jQuery(`<ul> <li class="firstclass">list item 1</li> <li>list item 2</li> <li>list item 3</li> <li>list item 4</li> <li class="lastclass">list item 5</li> </ul>`).AppendTo(FIX) assert.Equal(jQuery(FIX).Find("li").Slice(2).Length, 3, "Slice") assert.Equal(jQuery(FIX).Find("li").Slice(2, 4).Length, 2, "SliceByEnd") assert.Equal(jQuery(FIX).Find("li").First().Attr("class"), "firstclass", "First") assert.Equal(jQuery(FIX).Find("li").Last().Attr("class"), "lastclass", "Last") }) QUnit.Test("Css", func(assert QUnit.QUnitAssert) { jQuery(FIX).SetCss(map[string]interface{}{"color": "red", "background": "blue", "width": "20px", "height": "10px"}) assert.Ok(jQuery(FIX).Css("width") == "20px" && jQuery(FIX).Css("height") == "10px", "SetCssMap") div := jQuery("<div style='display: inline'/>").Show().AppendTo(FIX) assert.Equal(div.Css("display"), "inline", "Make sure that element has same display when it was created.") div.Remove() span := jQuery("<span/>").Hide().Show() assert.Equal(span.Get(0).Get("style").Get("display"), "inline", "For detached span elements, display should always be inline") span.Remove() }) QUnit.Test("Attributes", func(assert QUnit.QUnitAssert) { jQuery("<form id='testForm'></form>").AppendTo(FIX) extras := jQuery("<input id='id' name='id' /><input id='name' name='name' /><input id='target' name='target' />").AppendTo("#testForm") assert.Equal(jQuery("#testForm").Attr("target"), "", "Attr") assert.Equal(jQuery("#testForm").SetAttr("target", "newTarget").Attr("target"), "newTarget", "SetAttr2") assert.Equal(jQuery("#testForm").RemoveAttr("id").Attr("id"), "", "RemoveAttr ") assert.Equal(jQuery("#testForm").Attr("name"), "", "Attr undefined") extras.Remove() jQuery("<a/>").SetAttr(map[string]interface{}{"id": "tAnchor5", "href": "#5"}).AppendTo(FIX) assert.Equal(jQuery("#tAnchor5").Attr("href"), "#5", "Attr") jQuery("<a id='tAnchor6' href='#5' />").AppendTo(FIX) assert.Equal(jQuery("#tAnchor5").Prop("href"), jQuery("#tAnchor6").Prop("href"), "Prop") input := jQuery("<input name='tester' />") assert.StrictEqual(input.Clone(true).SetAttr("name", "test").Underlying().Index(0).Get("name"), "test", "Clone") jQuery(FIX).Empty() jQuery(`<input type="checkbox" checked="checked"> <input type="checkbox"> <input type="checkbox"> <input type="checkbox" checked="checked">`).AppendTo(FIX) jQuery(FIX).Find("input[type='checkbox']").SetProp("disabled", true) assert.Ok(jQuery(FIX).Find("input[type='checkbox']").Prop("disabled"), "SetProp") }) QUnit.Test("Unique", func(assert QUnit.QUnitAssert) { jQuery(`<div>There are 6 divs in this document.</div> <div></div> <div class="dup"></div> <div class="dup"></div> <div class="dup"></div> <div></div>`).AppendTo(FIX) divs := jQuery(FIX).Find("div").Get() assert.Equal(divs.Get("length"), 6, "6 divs inserted") jQuery(FIX).Find(".dup").Clone(true).AppendTo(FIX) divs2 := jQuery(FIX).Find("div").Get() assert.Equal(divs2.Get("length"), 9, "9 divs inserted") divs3 := jquery.Unique(divs) assert.Equal(divs3.Get("length"), 6, "post-qunique should be 6 elements") }) QUnit.Test("Serialize,SerializeArray,Trigger,Submit", func(assert QUnit.QUnitAssert) { QUnit.Expect(2) jQuery(`<form> <div><input type="text" name="a" value="1" id="a"></div> <div><input type="text" name="b" value="2" id="b"></div> <div><input type="hidden" name="c" value="3" id="c"></div> <div> <textarea name="d" rows="8" cols="40">4</textarea> </div> <div><select name="e"> <option value="5" selected="selected">5</option> <option value="6">6</option> <option value="7">7</option> </select></div> <div> <input type="checkbox" name="f" value="8" id="f"> </div> <div> <input type="submit" name="g" value="Submit" id="g"> </div> </form>`).AppendTo(FIX) var collectResults string jQuery(FIX).Find("form").Submit(func(evt jquery.Event) { sa := jQuery(evt.Target).SerializeArray() for i := 0; i < sa.Length(); i++ { collectResults += sa.Index(i).Get("name").String() } assert.Equal(collectResults, "abcde", "SerializeArray") evt.PreventDefault() }) serializedString := "a=1&b=2&c=3&d=4&e=5" assert.Equal(jQuery(FIX).Find("form").Serialize(), serializedString, "Serialize") jQuery(FIX).Find("form").Trigger("submit") }) QUnit.ModuleLifecycle("Events", EvtScenario{}) QUnit.Test("On,One,Off,Trigger", func(assert QUnit.QUnitAssert) { fn := func(ev jquery.Event) { assert.Ok(ev.Data != js.Undefined, "on() with data, check passed data exists") assert.Equal(ev.Data.Get("foo"), "bar", "on() with data, Check value of passed data") } data := map[string]interface{}{"foo": "bar"} jQuery("#firstp").On(jquery.CLICK, data, fn).Trigger(jquery.CLICK).Off(jquery.CLICK, fn) var clickCounter, mouseoverCounter int handler := func(ev jquery.Event) { if ev.Type == jquery.CLICK { clickCounter++ } else if ev.Type == jquery.MOUSEOVER { mouseoverCounter++ } } handlerWithData := func(ev jquery.Event) { if ev.Type == jquery.CLICK { clickCounter += ev.Data.Get("data").Int() } else if ev.Type == jquery.MOUSEOVER { mouseoverCounter += ev.Data.Get("data").Int() } } data2 := map[string]interface{}{"data": 2} elem := jQuery("#firstp").On(jquery.CLICK, handler).On(jquery.MOUSEOVER, handler).One(jquery.CLICK, data2, handlerWithData).One(jquery.MOUSEOVER, data2, handlerWithData) assert.Equal(clickCounter, 0, "clickCounter initialization ok") assert.Equal(mouseoverCounter, 0, "mouseoverCounter initialization ok") elem.Trigger(jquery.CLICK).Trigger(jquery.MOUSEOVER) assert.Equal(clickCounter, 3, "clickCounter Increased after Trigger/On/One") assert.Equal(mouseoverCounter, 3, "mouseoverCounter Increased after Trigger/On/One") elem.Trigger(jquery.CLICK).Trigger(jquery.MOUSEOVER) assert.Equal(clickCounter, 4, "clickCounter Increased after Trigger/On") assert.Equal(mouseoverCounter, 4, "a) mouseoverCounter Increased after TriggerOn") elem.Trigger(jquery.CLICK).Trigger(jquery.MOUSEOVER) assert.Equal(clickCounter, 5, "b) clickCounter not Increased after Off") assert.Equal(mouseoverCounter, 5, "c) mouseoverCounter not Increased after Off") elem.Off(jquery.CLICK).Off(jquery.MOUSEOVER) //2do: elem.Off(jquery.CLICK, handlerWithData).Off(jquery.MOUSEOVER, handlerWithData) elem.Trigger(jquery.CLICK).Trigger(jquery.MOUSEOVER) assert.Equal(clickCounter, 5, "clickCounter not Increased after Off") assert.Equal(mouseoverCounter, 5, "mouseoverCounter not Increased after Off") }) QUnit.Test("Each", func(assert QUnit.QUnitAssert) { jQuery(FIX).Empty() html := `<style> div { color: red; text-align: center; cursor: pointer; font-weight: bolder; width: 300px; } </style> <div>Click here</div> <div>to iterate through</div> <div>these divs.</div>` jQuery(html).AppendTo(FIX) blueCount := 0 jQuery(FIX).On(jquery.CLICK, func(e jquery.Event) { //jQuery(FIX).Find("div").Each(func(i int, elem interface{}) interface{} { jQuery(FIX).Find("div").Each(func(i int, elem interface{}) { style := jQuery(elem).Get(0).Get("style") if style.Get("color").String() != "blue" { style.Set("color", "blue") } else { blueCount += 1 style.Set("color", "") } }) }) for i := 0; i < 6; i++ { jQuery(FIX).Find("div:eq(0)").Trigger("click") } assert.Equal(jQuery(FIX).Find("div").Length, 3, "Test setup problem: 3 divs expected") assert.Equal(blueCount, 9, "blueCount Counter should be 9") }) QUnit.Test("Filter, Resize", func(assert QUnit.QUnitAssert) { jQuery(FIX).Empty() html := `<style> div { width: 60px; height: 60px; margin: 5px; float: left; border: 2px white solid; } </style> <div></div> <div class="middle"></div> <div class="middle"></div> <div class="middle"></div> <div class="middle"></div> <div></div>` jQuery(html).AppendTo(FIX) jQuery(FIX).Find("div").SetCss("background", "silver").Filter(func(index int) bool { return index%3 == 2 }).SetCss("font-weight", "bold") countFontweight := 0 jQuery(FIX).Find("div").Each(func(i int, elem interface{}) { fw := jQuery(elem).Css("font-weight") if fw == "bold" || fw == "700" { countFontweight += 1 } }) assert.Equal(countFontweight, 2, "2 divs should have font-weight = 'bold'") jQuery(js.Global).Resize(func() { jQuery(FIX).Find("div:eq(0)").SetText(strconv.Itoa(jQuery("div:eq(0)").Width())) }).Resize() assert.Equal(jQuery(FIX).Find("div:eq(0)").Text(), "60", "text of first div should be 60") }) QUnit.Test("Not,Offset", func(assert QUnit.QUnitAssert) { QUnit.Expect(0) //api test only jQuery(FIX).Empty() html := `<div></div> <div id="blueone"></div> <div></div> <div class="green"></div> <div class="green"></div> <div class="gray"></div> <div></div>` jQuery(html).AppendTo(FIX) jQuery(FIX).Find("div").Not(".green,#blueone").SetCss("border-color", "red") jQuery("*", "body").On("click", func(event jquery.Event) { offset := jQuery(event.Target).Offset() event.StopPropagation() tag := jQuery(event.Target).Prop("tagName").(string) jQuery("#result").SetText(tag + " coords ( " + strconv.Itoa(offset.Left) + ", " + strconv.Itoa(offset.Top) + " )") }) }) QUnit.Module("Ajax") QUnit.AsyncTest("Async Dummy Test", func() interface{} { QUnit.Expect(1) return js.Global.Call("setTimeout", func() { QUnit.Ok(true, " async ok") QUnit.Start() }, 1000) }) QUnit.AsyncTest("Ajax Call", func() interface{} { QUnit.Expect(1) ajaxopt := Object{ "async": true, "type": "POST", "url": ROOT + "/nestedjson/", "contentType": "application/json charset=utf-8", "dataType": "json", "data": nil, "beforeSend": func(data Object) { if SHOWCONSOLE { print(" before:", data) } }, "success": func(data Object) { dataStr := stringify(data) expected := `{"message":"Welcome!","nested":{"level":1,"moresuccess":true},"success":true}` QUnit.Ok(dataStr == expected, "Ajax call did not returns expected result") QUnit.Start() if SHOWCONSOLE { print(" ajax call success:", data) for k, v := range data { switch v.(type) { case bool: print(k, v.(bool)) case string: print(k, v.(string)) case float64: print(k, v.(float64)) default: print("sth. else:", k, v) } } } }, "error": func(status interface{}) { if SHOWCONSOLE { print(" ajax call error:", status) } }, } //ajax call: jquery.Ajax(ajaxopt) return nil }) QUnit.AsyncTest("Load", func() interface{} { QUnit.Expect(1) jQuery(FIX).Load("/resources/load.html", func() { if SHOWCONSOLE { print(" load got: ", jQuery(FIX).Html() == `<div>load successful!</div>`) } QUnit.Ok(jQuery(FIX).Html() == `<div>load successful!</div>`, "Load call did not returns expected result") QUnit.Start() }) return nil }) QUnit.AsyncTest("Get", func() interface{} { QUnit.Expect(1) jquery.Get("/resources/get.html", func(data interface{}, status string, xhr interface{}) { if SHOWCONSOLE { print(" data: ", data) print(" status: ", status) print(" xhr: ", xhr) } QUnit.Ok(data == `<div>get successful!</div>`, "Get call did not returns expected result") QUnit.Start() }) return nil }) QUnit.AsyncTest("Post", func() interface{} { QUnit.Expect(1) jquery.Post("/gopher", func(data interface{}, status string, xhr interface{}) { if SHOWCONSOLE { print(" data: ", data) print(" status: ", status) print(" xhr: ", xhr) } QUnit.Ok(data == `<div>Welcome gopher</div>`, "Post call did not returns expected result") QUnit.Start() }) return nil }) QUnit.AsyncTest("GetJSON", func() interface{} { QUnit.Expect(1) jquery.GetJSON("/json/1", func(data interface{}) { if val, ok := data.(map[string]interface{})["json"]; ok { if SHOWCONSOLE { print("GetJSON call returns: ", val) } QUnit.Ok(val == `1`, "Json call did not returns expected result") QUnit.Start() } }) return nil }) QUnit.AsyncTest("GetScript", func() interface{} { QUnit.Expect(1) jquery.GetScript("/script", func(data interface{}) { if SHOWCONSOLE { print("GetScript call returns script of length: ", len(data.(string))) } QUnit.Ok(len(data.(string)) == 29, "GetScript call did not returns expected result") QUnit.Start() }) return nil }) QUnit.AsyncTest("AjaxSetup", func() interface{} { QUnit.Expect(1) ajaxSetupOptions := Object{ "async": true, "type": "POST", "url": "/nestedjson/", "contentType": "application/json charset=utf-8", } jquery.AjaxSetup(ajaxSetupOptions) ajaxopt := Object{ "dataType": "json", "data": nil, "beforeSend": func(data Object) { if SHOWCONSOLE { print(" ajaxSetup call, before:", data) } }, "success": func(data Object) { dataStr := stringify(data) expected := `{"message":"Welcome!","nested":{"level":1,"moresuccess":true},"success":true}` QUnit.Ok(dataStr == expected, "AjaxSetup call did not returns expected result") QUnit.Start() if SHOWCONSOLE { print(" ajaxSetup call success:", data) for k, v := range data { switch v.(type) { case bool: print(k, v.(bool)) case string: print(k, v.(string)) case float64: print(k, v.(float64)) default: print("sth. else:", k, v) } } } }, "error": func(status interface{}) { if SHOWCONSOLE { print(" ajaxSetup Call error:", status) } }, } //ajax jquery.Ajax(ajaxopt) return nil }) QUnit.AsyncTest("AjaxPrefilter", func() interface{} { QUnit.Expect(1) jquery.AjaxPrefilter("+json", func(options interface{}, originalOptions string, jqXHR interface{}) { if SHOWCONSOLE { print(" ajax prefilter options:", options.(map[string]interface{})["url"].(string)) } //API Test only }) jquery.GetJSON("/json/3", func(data interface{}) { if val, ok := data.(map[string]interface{})["json"]; ok { if SHOWCONSOLE { print("ajaxPrefilter result: ", val.(string)) } QUnit.Ok(val.(string) == "3", "AjaxPrefilter call did not returns expected result") QUnit.Start() } }) return nil }) QUnit.AsyncTest("AjaxTransport", func() interface{} { QUnit.Expect(1) jquery.AjaxTransport("+json", func(options interface{}, originalOptions string, jqXHR interface{}) { if SHOWCONSOLE { print(" ajax transport options:", options) } //API Test only }) jquery.GetJSON("/json/4", func(data interface{}) { if val, ok := data.(map[string]interface{})["json"]; ok { QUnit.Ok(val.(string) == "4", "AjaxTransport call did not returns expected result") QUnit.Start() } }) return nil }) QUnit.Module("Deferreds") QUnit.AsyncTest("Deferreds Test 01", func() interface{} { QUnit.Expect(1) pass, fail, progress := 0, 0, 0 for i := 0; i < 10; i++ { jquery.When(asyncEvent(i%2 == 0, i)).Then( func(status interface{}) { if SHOWCONSOLE { log(status, "things are going well") } pass += 1 }, func(status interface{}) { if SHOWCONSOLE { log(status, ", you fail this time") } fail += 1 }, func(status interface{}) { if SHOWCONSOLE { log("Progress: ", status.(string)) } progress += 1 }, ).Done(func() { if SHOWCONSOLE { log(" Done. pass, fail, notify = ", pass, fail, progress) } if pass >= 5 { QUnit.Start() QUnit.Ok(pass >= 5 && fail >= 4 && progress >= 20, "Deferred Test 01 fail") } }) } return nil }) QUnit.Test("Deferreds Test 02", func(assert QUnit.QUnitAssert) { QUnit.Expect(1) o := NewWorking(jquery.NewDeferred()) o.Resolve("John") o.Done(func(name string) { o.hi(name) }).Done(func(name string) { o.hi("John") if SHOWCONSOLE { log(" test 02 done: ", countJohn /*2*/, countKarl /*0*/) } }) o.hi("Karl") if SHOWCONSOLE { log(" test 02 end : ", countJohn /*2*/, countKarl /*1*/) } assert.Ok(countJohn == 2 && countKarl == 1, "Deferred Test 02 fail") }) QUnit.AsyncTest("Deferreds Test 03", func() interface{} { QUnit.Expect(1) jquery.Get("/get.html").Always(func() { if SHOWCONSOLE { log("TEST 03: $.get completed with success or error callback arguments") } QUnit.Start() QUnit.Ok(true, "Deferred Test 03 fail") }) return nil }) QUnit.AsyncTest("Deferreds Test 04", func() interface{} { QUnit.Expect(2) jquery.Get("/get.html").Done(func() { QUnit.Ok(true, "Deferred Test 04 fail") if SHOWCONSOLE { log("$.get done: test 04") } }).Fail(func() { if SHOWCONSOLE { log("$.get fail: test 04") } }) jquery.Get("/shouldnotexist.html").Done(func() { if SHOWCONSOLE { log("$.get done: test 04 part 2") } }).Fail(func() { if SHOWCONSOLE { log("$.get fail: test 04 part 2") } QUnit.Start() QUnit.Ok(true, "Deferred Test 04 fail") }) return nil }) QUnit.AsyncTest("Deferreds Test 05", func() interface{} { QUnit.Expect(2) jquery.Get("/get.html").Then(func() { if SHOWCONSOLE { log("$.get done: with success, test 05") } QUnit.Ok(true, "Deferred Test 05 fail") }, func() { if SHOWCONSOLE { log("$.get fail: test 05 part 1") } }) jquery.Get("/shouldnotexist.html").Then(func() { if SHOWCONSOLE { log("$.get done: test 05 part 2") } }, func() { if SHOWCONSOLE { log("$.get fail: test 05 part 1") } QUnit.Start() QUnit.Ok(true, "Deferred Test 05, 2nd part, fail") }) return nil }) QUnit.Test("Deferreds Test 06", func(assert QUnit.QUnitAssert) { QUnit.Expect(1) o := jquery.NewDeferred() filtered := o.Then(func(value int) int { return value * 2 }) o.Resolve(5) filtered.Done(func(value int) { if SHOWCONSOLE { log("test 06: value is ( 2*5 ) = ", value) } assert.Ok(value == 10, "Deferred Test 06 fail") }) }) QUnit.Test("Deferreds Test 07", func(assert QUnit.QUnitAssert) { o := jquery.NewDeferred() filtered := o.Then(nil, func(value int) int { return value * 3 }) o.Reject(6) filtered.Fail(func(value int) { if SHOWCONSOLE { log("Value is ( 3*6 ) = ", value) } assert.Ok(value == 18, "Deferred Test 07 fail") }) }) }