improve code coverage of SlotList class

Author: tiagoschenkel

test/org/osflash/signals/SlotListTest.test.ts

@@ -14,6 +14,7 @@ describe("SlotListTest", () => {
     let listenerA: Function;
     let listenerB: Function;
     let listenerC: Function;
+    let listenerD: Function;
     let slotA: ISlot;
     let slotB: ISlot;
     let slotC: ISlot;
@@ -29,6 +30,8 @@ describe("SlotListTest", () => {
         };
         listenerC = function(e: any = null): void {
         };
+        listenerD = function(e: any = null): void {
+        };
         slotA = new Slot(listenerA, signal);
         slotB = new Slot(listenerB, signal);
         slotC = new Slot(listenerC, signal);
@@ -59,6 +62,10 @@ describe("SlotListTest", () => {
         assert.throws(() => new SlotList(null, null), Error);
     });
 
+    it("contains_should_return_false_when_listener_is_not_part_of_list", () => {
+        assert.isFalse(listOfABC.contains(listenerD));
+    });
+
     it("list_with_one_listener_contains_it", () => {
         assert.isTrue(listOfA.contains(listenerA));
     });
@@ -75,135 +82,121 @@ describe("SlotListTest", () => {
         assert.equal(listenerA, listOfA.head.listener);
     });
 
-
     it("NIL_does_not_contain_anonymous_listener", () => {
         assert.isFalse(SlotList.NIL.contains(new Function()));
     });
 
-
     it("find_in_empty_list_yields_null", () => {
         assert.isNull(SlotList.NIL.find(listenerA));
     });
 
-
     it("NIL_does_not_contain_null_listener", () => {
         assert.isFalse(SlotList.NIL.contains(null));
     });
 
-
     it("find_the_1st_of_2_listeners_yields_its_slot", () => {
         assert.equal(slotA, listOfAB.find(listenerA));
     });
 
-
     it("find_the_2nd_of_2_listeners_yields_its_slot", () => {
         assert.equal(slotB, listOfAB.find(listenerB));
     });
 
-
     it("find_the_1st_of_3_listeners_yields_its_slot", () => {
         assert.equal(slotA, listOfABC.find(listenerA));
     });
 
-
     it("find_the_2nd_of_3_listeners_yields_its_slot", () => {
         assert.equal(slotB, listOfABC.find(listenerB));
     });
 
-
     it("find_the_3rd_of_3_listeners_yields_its_slot", () => {
         assert.equal(slotC, listOfABC.find(listenerC));
     });
 
-
     it("prepend_a_slot_makes_it_head_of_new_list", () => {
         let newList: SlotList = listOfA.prepend(slotB);
         assert.equal(slotB, newList.head);
     });
 
-
     it("prepend_a_slot_makes_the_old_list_the_tail", () => {
         let newList: SlotList = listOfA.prepend(slotB);
         assert.equal(listOfA, newList.tail);
     });
 
-
     it("after_prepend_slot_new_list_contains_its_listener", () => {
         let newList: SlotList = listOfA.prepend(slotB);
         assert.isTrue(newList.contains(slotB.listener));
     });
 
-
     it("append_a_slot_yields_new_list_with_same_head", () => {
         let oldHead: ISlot = listOfA.head;
         let newList: SlotList = listOfA.append(slotB);
         assert.equal(oldHead, newList.head);
     });
 
-
     it("append_to_list_of_one_yields_list_of_length_two", () => {
         let newList: SlotList = listOfA.append(slotB);
         assert.equal(2, newList.length);
     });
 
-
     it("after_append_slot_new_list_contains_its_listener", () => {
         let newList: SlotList = listOfA.append(slotB);
         assert.isTrue(newList.contains(slotB.listener));
     });
 
-
     it("append_slot_yields_a_different_list", () => {
         let newList: SlotList = listOfA.append(slotB);
         assert.notEqual(listOfA, newList);
     });
 
-
     it("append_null_yields_same_list", () => {
         let newList: SlotList = listOfA.append(null);
         assert.equal(listOfA, newList);
     });
 
-
     it("filterNot_on_empty_list_yields_same_list", () => {
         let newList: SlotList = SlotList.NIL.filterNot(listenerA);
         assert.equal(SlotList.NIL, newList);
     });
 
-
     it("filterNot_null_yields_same_list", () => {
         let newList: SlotList = listOfA.filterNot(null);
         assert.equal(listOfA, newList);
     });
 
-
     it("filterNot_head_from_list_of_1_yields_empty_list", () => {
         let newList: SlotList = listOfA.filterNot(listOfA.head.listener);
         assert.equal(SlotList.NIL, newList);
     });
 
-
     it("filterNot_1st_listener_from_list_of_2_yields_list_of_2nd_listener", () => {
         let newList: SlotList = listOfAB.filterNot(listenerA);
         assert.equal(listenerB, newList.head.listener);
         assert.equal(1, newList.length);
     });
 
-
     it("filterNot_2nd_listener_from_list_of_2_yields_list_of_head", () => {
         let newList: SlotList = listOfAB.filterNot(listenerB);
         assert.equal(listenerA, newList.head.listener);
         assert.equal(1, newList.length);
     });
 
-
     it("filterNot_2nd_listener_from_list_of_3_yields_list_of_1st_and_3rd", () => {
         let newList: SlotList = listOfABC.filterNot(listenerB);
         assert.equal(listenerA, newList.head.listener);
         assert.equal(listenerC, newList.tail.head.listener);
         assert.equal(2, newList.length);
     });
 
+    it("filterNot_with_unknow_listener_should_not_change_list", () => {
+        let newList: SlotList = listOfABC.filterNot(listenerD);
+        assert.equal(listenerA, newList.head.listener);
+        assert.equal(listenerB, newList.tail.head.listener);
+        assert.equal(listenerC, newList.tail.tail.head.listener);
+        assert.equal(3, newList.length);
+        assert.equal(listOfABC, newList);
+    });
 
     // Issue #56
     it("insertWithPriority_adds_4_slots_without_losing_any", () => {
@@ -227,11 +220,10 @@ describe("SlotListTest", () => {
         assert.equal(slot4, list.tail.tail.head);
         assert.equal(slot2, list.tail.tail.tail.head);
     });
-});
-
-
-
-
-
-
 
+    it("toString_should_return_string", () => {
+        assert.isString(listOfA.toString());
+        assert.isString(listOfAB.toString());
+        assert.isString(listOfABC.toString());
+    });
+});