TestCaseTWikiJavascripts < TestCases

---+!! Unit tests for !TWikiJavascripts

These tests require TWiki:Plugins.JSUnitContrib to run.

*[[%PUBURL%/%SYSTEMWEB%/JSUnitContrib/testRunner.html?testpage=%SCRIPTURL{"view"}%/%BASEWEB%/%TOPIC%][Run tests]]*

<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/JSUnitContrib/app/jsUnitCore.js"></script>
<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/TWikiJavascripts/twikilib.js"></script>

%TOC%

---++ twiki.Array
<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/TWikiJavascripts/twikiArray.js"></script>

---+++ twiki.Array.remove

<script language="javascript">
/*<![CDATA[*/
    function testRemoveWithValidArgs() {
       var list = ["a", "b", "c"];
       twiki.Array.remove(list, "b");
        assertEquals("Remove object 1 from list", "ac", list.join(""));
        twiki.Array.remove(list, "a");
        assertEquals("Remove object 2 from list", "c", list.join(""));
        twiki.Array.remove(list, "c");
        assertEquals("Remove object 3 from list", "", list.join(""));
    }
    function testRemoveWithInvalidArgs() {
       var list = ["a", "b", "c"];
        assertNull("A null argument should result in null", twiki.Array.remove(list, null));
        twiki.Array.remove(list, null);
        assertEquals("A null argument should result in no objects removed", "abc", list.join(""));
    }
    function testRemoveWithUndefinedValue() {
       var list = ["a", "b", "c"];
        assertNull("An undefined argument should result in null", twiki.Array.remove(list, JSUNIT_UNDEFINED_VALUE));
    }
/*]]>*/
</script>

---+++ twiki.Array.convertArgumentsToArray

<script language="javascript">
/*<![CDATA[*/
   function returnArguments() {
      return arguments;
   }
    function testConvertArgumentsToArrayWithValidArgs() {
       var args = returnArguments("a", "b", "c");
       var argsArray = twiki.Array.convertArgumentsToArray(args);
       assertEquals("Convert valid arguments", "abc", argsArray.join(""));
       var argsArray = twiki.Array.convertArgumentsToArray(args,1);
       assertEquals("Convert valid arguments with starting point", "bc", argsArray.join(""));
    }
    function testConvertArgumentsToArrayWithInValidArgs() {
       {
         var args = returnArguments();
         var list = twiki.Array.convertArgumentsToArray(args);
         assertNull("Empty args list should result in null", list);
      }
      {
         var args = returnArguments("a", "b", "c");
         var list = twiki.Array.convertArgumentsToArray(args,3);
         assertNull("Start beyond bounds should result in null", list);
      }
      {
          assertNull("No args should result in null", twiki.Array.convertArgumentsToArray());
       }
       {
         var args = returnArguments("a", "b", "c");
         var list = twiki.Array.convertArgumentsToArray(args,"a");
         assertNull("String input as start should result in null", list);
      }
    }

/*]]>*/
</script>

---+++ twiki.Array.indexOf

<script language="javascript">
/*<![CDATA[*/

    function testIndexOfWithValidArgs() {
       var array = ["a", "b", "b", "c"];
       var index;
       
       index = twiki.Array.indexOf(array, "a");
       assertEquals("testIndexOfWithValidArgs 1", 0, index);

       index = twiki.Array.indexOf(array, "b");
       assertEquals("testIndexOfWithValidArgs 2", 1, index);
       
       index = twiki.Array.indexOf(array, "c");
       assertEquals("testIndexOfWithValidArgs 3", 3, index);
       
       index = twiki.Array.indexOf(array, "d");
       assertEquals("testIndexOfWithValidArgs 4", -1, index);
       
       var emptyArray = [];
       index = twiki.Array.indexOf(emptyArray, "a");
       assertEquals("Empty array input should result in -1", -1, index);
    }
    function testIndexOfWithInvalidArgs() {
       index = twiki.Array.indexOf(null, "a");
       assertNull("No array input should result in null", index);
    }
/*]]>*/
</script>




---++ twiki.Form
<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/TWikiJavascripts/twikiForm.js"></script>

<form id="testForm" name="testForm">

<!-- text input -->
<input type="text" name="testInput" id="testInput" value="TESTTEXT" size="40" disabled=true />

<!-- text input -->
<input type="password" name="testPwd" value="secret" size="40" disabled=true />

<!-- radio buttons -->
<input type="radio" name="testRadio" value="text" checked="checked" disabled=true /><label for="textbody">Text body</label><br />
<input type="radio" name="testRadio" value="topic" disabled=true /><label for="topictitle">Topic title</label><br />
<input type="radio" name="testRadio" value="all" disabled=true /><label for="both">Both body and title</label>

<!-- checkboxes -->
<input type="checkbox" name="testCbNoSearch" checked="checked" disabled=true /><label for="nosearch">Search string</label><br />
<input type="checkbox" name="testCbNoSummary" checked="checked" disabled=true /><label for="nosummary">Summaries</label><br />
<input type="checkbox" name="nototal" disabled=true /><label for="nototal">Total matches</label>

<!-- hidden field -->
<input type=hidden name="testHidden" value="classic" disabled=true  />

<!-- textarea -->
<textarea name="testTextArea" disabled=true >COMMENTSTEXT</textarea>

<!-- select dropdown -->
<select name="testSelect" disabled=true >
<option value="volvo">Volvo</option>
<option value="saab">Saab</option>
<option value="fiat" selected="selected">Fiat</option>
<option value="audi">Audi</option>
</select>

<!-- select multile -->
<select name="testSelectMultiple" size="5" multiple> 
<option>[New Genre]</option> 
<option selected="selected">Industrial</option> 
<option selected="selected">Rock</option> 
</select>

</form>

---+++ twiki.Form.formData2QueryString

<script language="javascript">
/*<![CDATA[*/

    function testFormData2QueryStringWithValidArgs() {
       {
         var queryString = twiki.Form.formData2QueryString(
            document.getElementById('testForm')
         );
         assertEquals("Form values not collapsed", "testInput=TESTTEXT;testPwd=secret;testRadio=text;testCbNoSearch=on;testCbNoSummary=on;testHidden=classic;testTextArea=COMMENTSTEXT;testSelect=fiat;testSelectMultiple=Industrial;testSelectMultiple=Rock", queryString);
      }
      {
         var queryString = twiki.Form.formData2QueryString(
            document.getElementById('testForm'),
            {collapseMulti:false}
         );
         assertEquals("Form values; collapsed false", "testInput=TESTTEXT;testPwd=secret;testRadio=text;testCbNoSearch=on;testCbNoSummary=on;testHidden=classic;testTextArea=COMMENTSTEXT;testSelect=fiat;testSelectMultiple=Industrial;testSelectMultiple=Rock", queryString);
      }
      {
         var queryString = twiki.Form.formData2QueryString(
            document.getElementById('testForm'),
            {collapseMulti:true}
         );
         assertEquals("Form values collapsed", "testInput=TESTTEXT;testPwd=secret;testRadio=text;testCbNoSearch=on;testCbNoSummary=on;testHidden=classic;testTextArea=COMMENTSTEXT;testSelect=fiat;testSelectMultiple=Industrial,Rock", queryString);
      }
    }

   function testFormData2QueryStringWithInvalidArgs() {
       {
          var formElem = document.getElementById('doesNotExist');
         var queryString = twiki.Form.formData2QueryString(formElem);
         assertNull("Non-existing form should return null", queryString);
      }
      {
         var queryString = twiki.Form.formData2QueryString(
            document.getElementById('testForm'),
            {bla:true}
         );
         assertEquals("Non-existing options should do nothing", "testInput=TESTTEXT;testPwd=secret;testRadio=text;testCbNoSearch=on;testCbNoSummary=on;testHidden=classic;testTextArea=COMMENTSTEXT;testSelect=fiat;testSelectMultiple=Industrial;testSelectMultiple=Rock", queryString);
      }
    }

/*]]>*/
</script>


---+++ twiki.Form.makeSafeForTableEntry

<script language="javascript">
/*<![CDATA[*/

    function testMakeSafeForTableEntry() {
       {
          var form = document.getElementById('testForm');
          var formElem = document.getElementById('testInput');
          var testValue = "1111|2222";
          formElem.value = testValue;
          assertEquals("Before make safe", formElem.value, testValue);
         var EXPECTED = "1111/2222 ";
         
         twiki.Form.makeSafeForTableEntry( form );
         assertEquals("Before make safe", formElem.value, EXPECTED);

      }
    }

/*]]>*/
</script>



---++ twiki.HTML

<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/TWikiJavascripts/twikiHTML.js"></script>


---+++ twiki.HTML.setHtmlOfElementWithId

<div id="testSetHtmlOfElementWithId"></div>

<script language="javascript">
/*<![CDATA[*/
    function testSetHtmlOfElementWithIdWithValidArgs() {
       var html = "<span style=\"color:#00f\">Blue text<\/span>";
      var elem = twiki.HTML.setHtmlOfElementWithId(
         "testSetHtmlOfElementWithId",
         html
      );
      
      var result = twiki.HTML.getHtmlOfElementWithId("testSetHtmlOfElementWithId");
       assertEquals(
          "Result setHtmlOfElementWithId",
          html.toLowerCase().replace(/\s*/g,''),
          result.toLowerCase().replace(/\s*/g,'')
       );
       
       assertEquals(
          "Result setHtmlOfElementWithId element",
          document.getElementById('testSetHtmlOfElementWithId'),
          elem
       );
   }
   
   function testSetHtmlOfElementWithIdWithInvalidArgs() {
      var html = "<span style=\"color:#00f\">Blue text<\/span>";
      var newElem = twiki.HTML.setHtmlOfElementWithId(
         "doesNotExist",
         html
      );
      assertNull("testSetHtmlOfElementWithIdWithInvalidArgs - Non-existing element should return null", newElem);
   }
   
 /*]]>*/
</script>

---+++ twiki.HTML.setHtmlOfElement

<div id="setHtmlOfElement"></div>

<script language="javascript">
/*<![CDATA[*/
    function testSetHtmlOfElementWithValidArgs() {
       var html = "<span style=\"color:#00f\">Blue text<\/span>";
       var elem = document.getElementById("setHtmlOfElement");
      var newElem = twiki.HTML.setHtmlOfElement(
         elem,
         html
      );
      
      var result = twiki.HTML.getHtmlOfElementWithId("setHtmlOfElement");
       assertEquals(
          "Result setHtmlOfElement",
          html.toLowerCase().replace(/\s*/g,''),
          result.toLowerCase().replace(/\s*/g,'')
       );
       
       assertEquals(
          "Result setHtmlOfElement element",
          document.getElementById('setHtmlOfElement'),
          newElem
       );

   }
   
   function testSetHtmlOfElementWithInvalidArgs() {
      var html = "<span style=\"color:#00f\">Blue text<\/span>";
      var newElem = twiki.HTML.setHtmlOfElement(
         null,
         html
      );
      assertNull("testSetHtmlOfElementWithInvalidArgs - Non-existing element should return null", newElem);
   }

 /*]]>*/
</script>

---+++ twiki.HTML.getHtmlOfElementWithId

<div id="testgetHtmlOfElementIdContainer">***HtmlOfElementWithId***</div>

<script language="javascript">
/*<![CDATA[*/
    function testGetHtmlOfElementWithIdWithValidArgs() {
       var result = twiki.HTML.getHtmlOfElementWithId("testgetHtmlOfElementIdContainer");
       assertEquals(
          "Result html of element with id",
          '***HtmlOfElementWithId***',
          result
       );
    }
/*]]>*/
</script>

---+++ twiki.HTML.getHtmlOfElement

<div id="testgetHtmlOfElementContainer">+++HtmlOfElement+++</div>

<script language="javascript">
/*<![CDATA[*/
    function testGetHtmlOfElementWithIdWithValidArgs() {
       var result = twiki.HTML.getHtmlOfElementWithId("testgetHtmlOfElementContainer");
       assertEquals(
          "Result html of element",
          '+++HtmlOfElement+++',
          result
       );
    }
/*]]>*/
</script>


---+++ twiki.HTML.clearElementWithId

<div id="testclearElementWithIdContainer">***clearElementWithId text***</div>

<script language="javascript">
/*<![CDATA[*/
    function testClearElementWithIdWithValidArgs() {
       var elem = twiki.HTML.clearElementWithId("testclearElementWithIdContainer");
       
       var result = twiki.HTML.getHtmlOfElementWithId("testclearElementWithIdContainer");
       assertEquals(
          "Result html of clear element with id",
          '',
          result
       );
       
       assertEquals(
          "Result clearElementWithId element",
          document.getElementById('testclearElementWithIdContainer'),
          elem
       );
    }
/*]]>*/
</script>

---+++ twiki.HTML.clearElement

<div id="testclearElementContainer">***clearElement text***</div>

<script language="javascript">
/*<![CDATA[*/
    function testClearElementWithValidArgs() {
       var elem = document.getElementById("testclearElementContainer");
       var newElem = twiki.HTML.clearElement(elem);
       
       var result = twiki.HTML.getHtmlOfElementWithId("testclearElementContainer");
       assertEquals(
          "Result html of clear element",
          '',
          result
       );
       
       assertEquals(
          "Result clearElement element",
          document.getElementById('testclearElementContainer'),
          newElem
       );
    }
/*]]>*/
</script>



---+++ twiki.HTML.insertAfterElement

<div id="testInsertAfter">insert after this div...</div>

<script language="javascript">
/*<![CDATA[*/
    function testInsertAfterWithValidArgs() {
       var html = "<strong>RESULT INSERT AFTER</strong>";
       var newElem = twiki.HTML.insertAfterElement(
          document.getElementById('testInsertAfter'),
          'div',
          html,
          {
             "id":"testInsertAfterResult",
             "style":"color:red"
          }
       );
       var result = twiki.HTML.getHtmlOfElementWithId("testInsertAfterResult");
       assertEquals(
          "Result insert after",
          html.toLowerCase().replace(/\s*/g,''),
          result.toLowerCase().replace(/\s*/g,'')
       );
       
       assertEquals(
          "Resulting element insert after",
          document.getElementById('testInsertAfterResult'),
          newElem
       );
    }
    
    function testInsertAfterWithInvalidArgs() {
       var newElem = twiki.HTML.insertAfterElement(
          document.getElementById('doesNotExist')
       );
       assertNull("testInsertAfterWithValidArgs - Non-existing element should return null", newElem);
    }
 /*]]>*/
</script>

---+++ twiki.HTML.insertBeforeElement

<div id="testInsertBefore">insert before this div...</div>

<script language="javascript">
/*<![CDATA[*/
    function testInsertBeforeWithValidArgs() {
       var html = '<strong>RESULT INSERT BEFORE</strong>';
       var newElem = twiki.HTML.insertBeforeElement(
          document.getElementById('testInsertBefore'),
          'div',
          html,
          {
             "id":"testInsertBeforeResult"
          }
       );
       var result = twiki.HTML.getHtmlOfElementWithId("testInsertBeforeResult");
       assertEquals(
          "Result insert before",
          html.toLowerCase().replace(/\s*/g,''),
          result.toLowerCase().replace(/\s*/g,'')
       );
       
       assertEquals(
          "Resulting element insert before",
          document.getElementById('testInsertBeforeResult'),
          newElem
       );
    }
    
    function testInsertBeforeWithInvalidArgs() {
       var newElem = twiki.HTML.insertBeforeElement(
          document.getElementById('doesNotExist')
       );
       assertNull("testInsertBeforeWithInvalidArgs - Non-existing element should return null", newElem);
    }
/*]]>*/
</script>

---+++ twiki.HTML.replaceElement

<div id="testReplace">replace this div...</div>

<script language="javascript">
/*<![CDATA[*/
    function testReplaceWithValidArgs() {
       var html = '<strong>RESULT REPLACE</strong>';
       var newElem = twiki.HTML.replaceElement(
          document.getElementById('testReplace'),
          'div',
          html,
          {
             id:'resultReplaced'
          }
          
       );
       var result = twiki.HTML.getHtmlOfElementWithId("resultReplaced");
       assertEquals(
          "Result replaced",
          html.toLowerCase().replace(/\s*/g,''),
          result.toLowerCase().replace(/\s*/g,'')
       );
       
       assertEquals(
          "Resulting element replaced",
          document.getElementById('resultReplaced'),
          newElem
       );
    }
    
    function testReplaceWithInvalidArgs() {
       var newElem = twiki.HTML.replaceElement(
          document.getElementById('doesNotExist')
       );
       assertNull("testReplaceWithInvalidArgs - Non-existing element should return null", newElem);
    }
/*]]>*/
</script>

---+++ twiki.HTML.setNodeAttributesInList

<div id="setNodeAttributesInListContainer">
<ul>
   <li>Item 1</li>
   <li>Item 2</li>
   <li>Item 3</li>
</ul>
</div>

<script language="javascript">
/*<![CDATA[*/
    function testSetNodeAttributesInListWithValidArgs() {
       var elem = document.getElementById("setNodeAttributesInListContainer");
       var nodeList = elem.getElementsByTagName('ul');
       var attributes = {
          "class":"twikiSmall twikiGrayText",
          "style":
             {
                "fontSize":"20px",
                "backgroundColor":"#444",
                "borderLeft":"5px solid red",
               "margin":"0 0 1em 0"
             }
       };
       twiki.HTML.setNodeAttributesInList(nodeList, attributes);
       
       // test first element
       var elem = nodeList[0];
       /*
       assertEquals("testSetNodeAttributesInListWithValidArgs class",
          "twikiSmall twikiGrayText",
          elem.getAttribute("class"));
       assertEquals("testSetNodeAttributesInListWithValidArgs style.color",
          "20px",
          elem.style["font-size"]);
       */
    }
   testSetNodeAttributesInListWithValidArgs();
/*]]>*/
</script>


---++ twiki.Window
<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/TWikiJavascripts/twikiWindow.js"></script>

---+++ twiki.Window.openPopup

<button class="twikiButton testopenPopup">Test open window</button>

<script type="text/javascript" src="%PUBURL%/%SYSTEMWEB%/BehaviourContrib/behaviour.compressed.js"></script>


<script language="javascript">
/*<![CDATA[*/
   function openPopup() {
      var win = twiki.Window.openPopup(
          "%SCRIPTURL{view}%/",
          {
             topic:"WebChanges",
             web:"%SYSTEMWEB%",
             name:"TEST_WINDOW",
             width:"700",
             height:"200",
             template:"view.print",
             skin:"classic",
             cover:"pattern",
             attributes:"titlebar=1,resizable=no,scrollbars=no"
          },
          this
       );
       return win;
   }
    function testOpenPopupWithValidArgs() {
       var win = openPopup();
       if (!win) {
          alert("Disable your pop-up blocker to run this test");
          return;
       }
       assertEquals("Window name", "TEST_WINDOW", win.name);
       win.close();
    }
    
    function testOpenPopupWithInvalidArgs() {
       var win = twiki.Window.openPopup();
       assertNull("No url passed should result in null", win);
    }

   //openPopup();
   
   var myrules = {
      '.testopenPopup' : function(el) {
        el.onclick = function() {
          openPopup();
          return false;
        }
      }
   };
   Behaviour.register(myrules);
/*]]>*/
</script>

---++ twiki.Event
<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/TWikiJavascripts/twikiEvent.js"></script>

---+++ twiki.Event.addLoadEvent

<div id="testAddLoadEventContainer">Here goes...</div>

<script language="javascript">
/*<![CDATA[*/
twiki.Event.addLoadEvent(
   function() {
      document.body.style.backgroundColor = '#ffc';
   });

twiki.Event.addLoadEvent(
   function() {
      document.getElementById("testAddLoadEventContainer").appendChild(document.createTextNode(' monkeys!'));
   });

twiki.Event.addLoadEvent(
   function() {
      document.getElementById("testAddLoadEventContainer").appendChild(document.createTextNode('Hungry'));
   },
   true);

twiki.Event.addLoadEvent("createTextNode");
   
    function testAddLoadEventWithValidArgs() {
       
       assertEquals(
          "Text contents", 
          document.getElementById("testAddLoadEventContainer").innerHTML,
          "Here goes...Hungry monkeys!"
       );
    }
    function testAddLoadEventWithInvalidArgs() {
       // see addLoadEvent No. 4
    }
    
/*]]>*/
</script>

---++ twiki.Function
<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/TWikiJavascripts/twikiFunction.js"></script>

---+++ twiki.Function.extendClass
<script language="javascript">
/*<![CDATA[*/
    function testExtendClassWithValidArgs() {
       var conversation = "";
       var expectedConversation = "poohgrmmpfgarfieldmew";
       
       function Animal (inName) {
          this.name = inName;
       }
       Animal.prototype.yell = "...";
       Animal.prototype.talk = function () {
         conversation += this.name + this.yell;
       }
       function Grizzly () {}
       Grizzly = twiki.Function.extendClass(Grizzly, Animal);
       Grizzly.prototype.yell = "grmmpf";
       var pooh = new Grizzly("pooh");
       pooh.talk();
       
       function Cat () {}
       Cat = twiki.Function.extendClass(Cat, Animal);
       Cat.prototype.yell = "mew";
       var garfield = new Cat("garfield");
       garfield.talk();
       assertEquals("Conversation result", expectedConversation, conversation);
    }
/*]]>*/
</script>


---++ twiki.Pref
<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/TWikiJavascripts/twikiPref.js"></script>

---+++ twiki.Pref.setCookie, twiki.Pref.getCookie
<script language="javascript">
/*<![CDATA[*/
    function testGetSetCookieWithValidArgs() {
       var name = "TestCaseTWikiJavascriptsCookie1"; 
       var value = "delightful";
       var expiryDate = new Date();
       expiryDate.setDate(expiryDate.getDate() + 1);
      var path = null;
      var domain = null;
       twiki.Pref.setCookie(name, value, expiryDate, path, domain);
       var cookie = twiki.Pref.getCookie(name);
       assertEquals("Cookie ", value, cookie);
    }
/*]]>*/
</script>
    
---+++ twiki.Pref.deleteCookie

<script language="javascript">
/*<![CDATA[*/
    function testDeleteCookieWithValidArgs() {
       var name = "TestCaseTWikiJavascriptsCookie2"; 
       var value = "enchanting";
       var expiryDate = new Date();
       expiryDate.setDate(expiryDate.getDate() + 1);
      var path = null;
      var domain = null;
       twiki.Pref.setCookie(name, value, expiryDate, path, domain);
       var cookie = twiki.Pref.getCookie(name);
       twiki.Pref.deleteCookie(name, path, domain);
       var deletedCookie = twiki.Pref.getCookie(name);
       assertNull("Deleted cookie", deletedCookie);
    }
    
    function testDeleteCookieWithInValidArgs() {
       var name = "TestCaseTWikiJavascriptsCookie3"; 
       var value = "heavenly";
       var expiryDate = new Date();
       expiryDate.setDate(expiryDate.getDate() + 1);
      var path = "/";
      var domain = "twiki4.visiblearea.com";
       twiki.Pref.setCookie(name, value, expiryDate, path, domain);
       var cookie = twiki.Pref.getCookie(name);
       twiki.Pref.deleteCookie(name, path);
       var notDeletedCookie = twiki.Pref.getCookie(name);
       assertEquals("Not deleted cookie ", cookie, notDeletedCookie);
    }
/*]]>*/
</script>

---+++ twiki.Pref.setPref, twiki.Pref.getPref

<script language="javascript">
/*<![CDATA[*/
    function testSetPrefWithValidArgs() {
       var prefName = "TestCaseTWikiJavascriptsPref1";
       var value = "a battuta";
      twiki.Pref.setPref(prefName, value);
      var retrievedValue = twiki.Pref.getPref(prefName);
      assertEquals("Set pref ", retrievedValue, value);
   }
/*]]>*/
</script>

---+++ twiki.Pref.getPrefList, twiki.Pref.getPrefValueFromPrefList

<script language="javascript">
/*<![CDATA[*/
   function testGetPrefListWithValidArgs() {
      var prefName = "TestCaseTWikiJavascriptsPref2";
       var value = "a capella";
      twiki.Pref.setPref(prefName, value);
      var prefList = twiki.Pref.getPrefList();
      var retrievedValue = twiki.Pref.getPrefValueFromPrefList(prefName, prefList);
      assertEquals("Pref from prefList", retrievedValue, value);
      
   }
/*]]>*/
</script>

---++ twiki.CSS
<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/TWikiJavascripts/twikiCSS.js"></script>

---+++ twiki.CSS.removeClass, twiki.CSS.getClassList

<div id="twikiCSSremoveClass" class="someClass twikiSmall otherClass">text</div>

<script language="javascript">
/*<![CDATA[*/
    function testRemoveClassWithValidArgs() {
       var el = document.getElementById("twikiCSSremoveClass");
       twiki.CSS.removeClass(el, "twikiSmall");
       var classList = twiki.CSS.getClassList(el);
       var classListString = classList.join(",");
       var expectedClassListString = "someClass,otherClass";
       assertEquals("Remaining classes ", expectedClassListString, classListString);
    }
/*]]>*/
</script>

---+++ twiki.CSS.addClass

<div id="twikiCSSaddClass">text</div>

<script language="javascript">
/*<![CDATA[*/
    function testAddClassWithValidArgs() {
       var el = document.getElementById("twikiCSSaddClass");
       twiki.CSS.addClass(el, "twikiSmall");
       twiki.CSS.addClass(el, "secondClass");
       var classList = twiki.CSS.getClassList(el);
       var classListString = classList.join(",");
       var expectedClassListString = "twikiSmall,secondClass";
       assertEquals("Added classes ", expectedClassListString, classListString);
    }
/*]]>*/
</script>

---+++ twiki.CSS.replaceClass

<div id="twikiCSSreplaceClass" class="someClass replaceThisClass otherClass">text</div>

<script language="javascript">
/*<![CDATA[*/
    function testReplaceClassWithValidArgs() {
       var el = document.getElementById("twikiCSSreplaceClass");
       twiki.CSS.replaceClass(el, "replaceThisClass", "myClass");
       var classList = twiki.CSS.getClassList(el);
       var classListString = classList.join(",");
       var expectedClassListString = "someClass,otherClass,myClass";
       assertEquals("Replaced classes ", expectedClassListString, classListString);
    }
/*]]>*/
</script>

---+++ twiki.CSS.setClassList

<div id="twikiCSSsetClassList">text</div>

<script language="javascript">
/*<![CDATA[*/
    function testSetClassListWithValidArgs() {
       var el = document.getElementById("twikiCSSsetClassList");
       var classList = [];
       classList.push("classOne");
       classList.push("classTwo");
       classList.push("classThree");
      twiki.CSS.setClassList(el, classList);
       var classListString = classList.join(",");
       var setClassListString = twiki.CSS.getClassList(el).join(",");
       assertEquals("Set classes ", classListString, setClassListString);
    }
/*]]>*/
</script>

---+++ twiki.CSS.hasClass

<div id="twikiCSShasClass" class="classOne classTwo">text</div>

<script language="javascript">
/*<![CDATA[*/
    function testHasClassWithValidArgs() {
       var el = document.getElementById("twikiCSShasClass");
       assertTrue("Has class 1", twiki.CSS.hasClass(el, "classOne"));
       assertTrue("Has class 2", twiki.CSS.hasClass(el, "classTwo"));
       assertFalse("Has class 3", twiki.CSS.hasClass(el, "classThree"));
    }
/*]]>*/
</script>


---++ twiki.String
<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/TWikiJavascripts/twikiString.js"></script>

---+++ twiki.String.isWikiWord
<script language="javascript">
/*<![CDATA[*/
    function testIsWikiWordWithValidArgs() {
       assertTrue("WikiWord", twiki.String.isWikiWord("WikiWord"));
       assertFalse("ABC", twiki.String.isWikiWord("ABC"));
       assertTrue("ThisIsAWikiWord", twiki.String.isWikiWord("ThisIsAWikiWord"));
       assertTrue("ThisIsAWikiWord123", twiki.String.isWikiWord("ThisIsAWikiWord123"));
       assertFalse("123", twiki.String.isWikiWord("123"));
       assertFalse("No Wikiword", twiki.String.isWikiWord("No Wikiword"));
    }
    
    function testIsWikiWordWithInvalidArgs() {
       assertFalse("Invalid wiki word", twiki.String.isWikiWord(" "));
       assertFalse("Invalid wiki word", twiki.String.isWikiWord("_"));
       assertFalse("Invalid wiki word", twiki.String.isWikiWord(0));
       assertFalse("Invalid wiki word", twiki.String.isWikiWord(null));
   }
   function testIsWikiWordWithUndefinedValue() {
      assertFalse("An undefined argument should result in false", twiki.String.isWikiWord(JSUNIT_UNDEFINED_VALUE));
   }
/*]]>*/
</script>

---+++ twiki.String.capitalize
<script language="javascript">
/*<![CDATA[*/
    function testCapitalizeWordsWithValidArgs() {
       var text, result, expected;
       
       text = "abc";
       expected = "Abc";
       result = twiki.String.capitalize(text);
       assertEquals("Capitalized text:", result, expected);
       
       text = "abc def";
       expected = "Abc Def";
       result = twiki.String.capitalize(text);
       assertEquals("Capitalized text:", result, expected);
       
       text = "abc 123";
       expected = "Abc 123";
       result = twiki.String.capitalize(text);
       assertEquals("Capitalized text:", result, expected);
    }
   function testCapitalizeWordsWithInvalidArgs() {
       assertNull("Invalid capitalized text:", twiki.String.capitalize(null));
       assertNull("Invalid capitalized text:", twiki.String.capitalize(0));
   }
   function testCapitalizedWordsWithUndefinedValue() {
      assertNull("An undefined argument should result in null:", twiki.String.capitalize(JSUNIT_UNDEFINED_VALUE));
   }
/*]]>*/
</script>

---+++ twiki.String.isBoolean
<script language="javascript">
/*<![CDATA[*/
    function testIsBooleanWithValidArgs() {
       var text;
       
       text = "1";
       assertTrue("isBoolean:", twiki.String.isBoolean(text));
       
       text = "0";
       assertFalse("isBoolean:", twiki.String.isBoolean(text));
       
       text = "2";
       assertFalse("isBoolean:", twiki.String.isBoolean(text));
       
       text = "on";
       assertTrue("isBoolean:", twiki.String.isBoolean(text));
       
       text = "true";
       assertTrue("isBoolean:", twiki.String.isBoolean(text));
       
       text = "1.1";
       assertFalse("isBoolean:", twiki.String.isBoolean(text));
    }
    function testIsBooleanWithInvalidArgs() {
       assertFalse("Invalid capitalized text:", twiki.String.isBoolean(null));
       assertFalse("Invalid capitalized text:", twiki.String.isBoolean(0));
   }
   function testIsBooleanWithUndefinedValue() {
      assertFalse("An undefined argument should result in false", twiki.String.isBoolean(JSUNIT_UNDEFINED_VALUE));
   }
/*]]>*/
</script>

---+++ twiki.String.removeSpaces
<script language="javascript">
/*<![CDATA[*/
    function testRemoveSpacesWithValidArgs() {
       var text, result, expected;
       
       text = "abc";
       expected = "abc";
       result = twiki.String.removeSpaces(text);
       assertEquals("Removed spaces:", result, expected);
       
       text = "abc def";
       expected = "abcdef";
       result = twiki.String.removeSpaces(text);
       assertEquals("Removed spaces:", result, expected);
       
       text = "abc 123";
       expected = "abc123";
       result = twiki.String.removeSpaces(text);
       assertEquals("Removed spaces:", result, expected);
       
       text = "A Handy Dictionary";
       expected = "AHandyDictionary";
       result = twiki.String.removeSpaces(text);
       assertEquals("Removed spaces:", result, expected);   
    }
    function testRemoveSpacesWithInvalidArgs() {
       assertNull("An invalid argument should result in null:", twiki.String.removeSpaces(null));
       assertNull("An invalid argument should result in null:", twiki.String.removeSpaces(0));
   }
   function testRemoveSpacesWithUndefinedValue() {
      assertNull("An undefined argument should result in null:", twiki.String.removeSpaces(JSUNIT_UNDEFINED_VALUE));
   }
/*]]>*/
</script>


---+++ twiki.String.removePunctuation
<script language="javascript">
/*<![CDATA[*/
    function testRemovePunctuationWithValidArgs() {
       var text, result, expected;
       
       text = "a b c,";
       expected = "abc";
       result = twiki.String.removePunctuation(text);
       assertEquals("Removed punctuation:", result, expected);
       
       text = ",abc, def,";
       expected = "abcdef";
       result = twiki.String.removePunctuation(text);
       assertEquals("Removed punctuation:", result, expected);
       
       text = "abc !@#$%&*()_+-={}[]:;\"'|\<,>.?/123";
       expected = "abc123";
       result = twiki.String.removePunctuation(text);
       assertEquals("Removed punctuation:", result, expected);
       
       text = "___";
       expected = "";
       result = twiki.String.removePunctuation(text);
       assertEquals("Removed punctuation:", result, expected);   
    }
    function testRemovePunctuationWithInvalidArgs() {
       assertNull("An invalid argument should result in null:", twiki.String.removePunctuation(null));
       assertNull("An invalid argument should result in null:", twiki.String.removePunctuation(0));
   }
   function testRemovePunctuationWithUndefinedValue() {
      assertNull("An undefined argument should result in null:", twiki.String.removePunctuation(JSUNIT_UNDEFINED_VALUE));
   }
/*]]>*/
</script>



---+++ twiki.String.makeWikiWord
<script language="javascript">
/*<![CDATA[*/
    function testMakeWikiWordWithValidArgs() {
       var text, result, expected;
       
       text = "abc";
       expected = "Abc";
       result = twiki.String.makeWikiWord(text);
       assertEquals("makeWikiWord:", result, expected);
       
       text = "wiki word";
       expected = "WikiWord";
       result = twiki.String.makeWikiWord(text);
       assertEquals("makeWikiWord:", result, expected);
       
       text = "abc !@#$%&*()_+-={}[]:;\"'|\<,>.?/123";
       expected = "Abc123";
       result = twiki.String.makeWikiWord(text);
       assertEquals("makeWikiWord:", result, expected);
    }
    function testMakeWikiWordWithInvalidArgs() {
       assertNull("An invalid argument should result in null:", twiki.String.makeWikiWord(null));
       assertNull("An invalid argument should result in null:", twiki.String.makeWikiWord(0));
   }
   function testmakeWikiWordWithUndefinedValue() {
      assertNull("An undefined argument should result in null:", twiki.String.makeWikiWord(JSUNIT_UNDEFINED_VALUE));
   }
/*]]>*/
</script>


---++ twiki.String (unicode chars)
<script language="javascript" src="%PUBURL%/%SYSTEMWEB%/TWikiJavascripts/twikiStringUnicodeChars.js"></script>

---+++ twiki.String.makeWikiWord
<script language="javascript">
/*<![CDATA[*/
    function testMakeWikiWord_UniCode_WithValidArgs() {
       var text, result, expected;
       
       twiki.StringConstants.getInstance().init();

       text = "abc";
       expected = "Abc";
       result = twiki.String.makeWikiWord(text);
       assertEquals("makeWikiWord:", result, expected);
       
       text = "wiki word";
       expected = "WikiWord";
       result = twiki.String.makeWikiWord(text);
       assertEquals("makeWikiWord:", result, expected);
       
       text = "abc !@#$%&*()_+-={}[]:;\"'|\<,>.?/123";
       expected = "Abc123";
       result = twiki.String.makeWikiWord(text);
       assertEquals("makeWikiWord:", result, expected);
       
       /*
       TESTS (OR CODE) NOT FINISHED YET
       NEEDS REAL LIFE CODE
       */

    }
    function testMakeWikiWord_UniCode_WithInvalidArgs() {
       assertNull("An invalid argument should result in null:", twiki.String.makeWikiWord(null));
       assertNull("An invalid argument should result in null:", twiki.String.makeWikiWord(0));
   }
   function testmakeWikiWord_UniCode_WithUndefinedValue() {
      assertNull("An undefined argument should result in null:", twiki.String.makeWikiWord(JSUNIT_UNDEFINED_VALUE));
   }
/*]]>*/
</script>
This topic: TestCases > TestCaseTWikiJavascripts
Topic revision: r0 - 2005-03-27 - TWikiContributor