Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use test method in ts-auto-mock

Best JavaScript code snippet using ts-auto-mock

traits-core.test.js

Source:traits-core.test.js

1"use strict";2const ERR_CONFLICT = 'Remaining conflicting property: ',3      ERR_REQUIRED = 'Missing required property: ';4function assertSametrait(test, trait1, trait2) {5  let names1 = Object.getOwnPropertyNames(trait1),6      names2 = Object.getOwnPropertyNames(trait2);7  test.assertEqual(8    names1.length,9    names2.length,10    'equal traits must have same amount of properties'11  );12  for (let i = 0; i < names1.length; i++) {13    let name = names1[i];14    test.assertNotEqual(15      -1,16      names2.indexOf(name),17      'equal traits must contain same named properties: ' + name18    );19    assertSameDescriptor(test, name, trait1[name], trait2[name]);20  }21}22function assertSameDescriptor(test, name, desc1, desc2) {23  if (desc1.conflict || desc2.conflict) {24    test.assertEqual(25      desc1.conflict,26      desc2.conflict,27      'if one of same descriptors has `conflict` another must have it: '28        + name29    );30  } else if (desc1.required || desc2.required) {31    test.assertEqual(32      desc1.required,33      desc2.required,34      'if one of same descriptors is has `required` another must have it: '35        + name36    );37  } else {38    test.assertEqual(39      desc1.get,40      desc2.get,41      'get must be the same on both descriptors: ' + name42    );43    test.assertEqual(44      desc1.set,45      desc2.set,46      'set must be the same on both descriptors: ' + name47    );48    test.assertEqual(49      desc1.value,50      desc2.value,51      'value must be the same on both descriptors: ' + name52    );53    test.assertEqual(54      desc1.enumerable,55      desc2.enumerable,56      'enumerable must be the same on both descriptors: ' + name57    );58    test.assertEqual(59      desc1.required,60      desc2.required,61      'value must be the same on both descriptors: ' + name62    );63  }64}65function Data(value, enumerable, confligurable, writable) {66  return {67    value: value,68    enumerable: false !== enumerable,69    confligurable: false !== confligurable,70    writable: false !== writable71  };72}73function Method(method, enumerable, confligurable, writable) {74  return {75    value: method,76    enumerable: false !== enumerable,77    confligurable: false !== confligurable,78    writable: false !== writable79  };80}81function Accessor(get, set, enumerable, confligurable) {82  return {83    get: get,84    set: set,85    enumerable: false !== enumerable,86    confligurable: false !== confligurable,87  };88}89function Required(name) {90  function required() { throw new Error(ERR_REQUIRED + name) }91  return {92    get: required,93    set: required,94    required: true95  };96}97function Conflict(name) {98  function conflict() { throw new Error(ERR_CONFLICT + name) }99  return {100    get: conflict,101    set: conflict,102    conflict: true103  };104}105function testMethod() {};106const { trait, compose, resolve, required, override, create } =107  require('traits/core');108exports['test:empty trait'] = function(test) {109  assertSametrait(110    test,111    trait({}),112    {}113  );114};115exports['test:simple trait'] = function(test) {116  assertSametrait(117    test,118    trait({119      a: 0,120      b: testMethod121    }),122    {123      a: Data(0, true, true, true),124      b: Method(testMethod, true, true, true)125    }126  );127};128exports['test:simple trait with required prop'] = function(test) {129  assertSametrait(130    test,131    trait({132      a: required,133      b: 1134    }),135    {136      a: Required('a'),137      b: Data(1)138    }139  );140};141exports['test:ordering of trait properties is irrelevant'] = function(test) {142  assertSametrait(test,143    trait({ a: 0, b: 1, c: required }),144    trait({ b: 1, c: required, a: 0 })145  );146};147exports['test:trait with accessor property'] = function(test) {148  let record = { get a() {}, set a(v) {} };149  let get = Object.getOwnPropertyDescriptor(record,'a').get;150  let set = Object.getOwnPropertyDescriptor(record,'a').set;151  assertSametrait(test,152    trait(record),153    { a: Accessor(get, set ) }154  );155};156exports['test:simple composition'] = function(test) {157  assertSametrait(test,158    compose(159      trait({ a: 0, b: 1 }),160      trait({ c: 2, d: testMethod })161    ),162    {163      a: Data(0),164      b: Data(1),165      c: Data(2),166      d: Method(testMethod)167    }168  );169};170exports['test:composition with conflict'] = function(test) {171  assertSametrait(test,172    compose(173      trait({ a: 0, b: 1 }),174      trait({ a: 2, c: testMethod })175    ),176    {177      a: Conflict('a'),178      b: Data(1),179      c: Method(testMethod)180    }181  );182};183exports['test:composition of identical props does not cause conflict'] =184function(test) {185  assertSametrait(test,186    compose(187      trait({ a: 0, b: 1 }),188      trait({ a: 0, c: testMethod })189    ),190    {191      a: Data(0),192      b: Data(1),193      c: Method(testMethod) }194  )195};196exports['test:composition with identical required props'] =197function(test) {198  assertSametrait(test,199    compose(200      trait({ a: required, b: 1 }),201      trait({ a: required, c: testMethod })202    ),203    {204      a: Required(),205      b: Data(1),206      c: Method(testMethod)207    }208  );209};210exports['test:composition satisfying a required prop'] = function (test) {211  assertSametrait(test,212    compose(213      trait({ a: required, b: 1 }),214      trait({ a: testMethod })215    ),216    {217      a: Method(testMethod),218      b: Data(1)219    }220  );221};222exports['test:compose is neutral wrt conflicts'] = function (test) {223  assertSametrait(test,224    compose(225      compose(226        trait({ a: 1 }),227        trait({ a: 2 })228      ),229      trait({ b: 0 })230    ),231    {232      a: Conflict('a'),233      b: Data(0)234    }235  );236};237exports['test:conflicting prop overrides required prop'] = function (test) {238  assertSametrait(test,239    compose(240      compose(241        trait({ a: 1 }),242        trait({ a: 2 })243      ),244      trait({ a: required })245    ),246    {247      a: Conflict('a')248    }249  );250};251exports['test:compose is commutative'] = function (test) {252  assertSametrait(test,253    compose(254      trait({ a: 0, b: 1 }),255      trait({ c: 2, d: testMethod })256    ),257    compose(258      trait({ c: 2, d: testMethod }),259      trait({ a: 0, b: 1 })260    )261  );262};263exports['test:compose is commutative, also for required/conflicting props'] =264function (test) {265  assertSametrait(test,266    compose(267      trait({ a: 0, b: 1, c: 3, e: required }),268      trait({ c: 2, d: testMethod })269    ),270    compose(271      trait({ c: 2, d: testMethod }),272      trait({ a: 0, b: 1, c: 3, e: required })273    )274  );275};276exports['test:compose is associative'] = function (test) {277  assertSametrait(test,278    compose(279      trait({ a: 0, b: 1, c: 3, d: required }),280      compose(281        trait({ c: 3, d: required }),282        trait({ c: 2, d: testMethod, e: 'foo' })283      )284    ),285    compose(286      compose(287        trait({ a: 0, b: 1, c: 3, d: required }),288        trait({ c: 3, d: required })289      ),290      trait({ c: 2, d: testMethod, e: 'foo' })291    )292  );293};294exports['test:diamond import of same prop does not generate conflict'] =295function (test) {296  assertSametrait(test,297    compose(298      compose(299        trait({ b: 2 }),300        trait({ a: 1 })301      ),302      compose(303        trait({ c: 3 }),304        trait({ a: 1 })305      ),306      trait({ d: 4 })307    ),308    {309      a: Data(1),310      b: Data(2),311      c: Data(3),312      d: Data(4)313    }314  );315};316exports['test:resolve with empty resolutions has no effect'] =317function (test) {318  assertSametrait(test, resolve({}, trait({319    a: 1,320    b: required,321    c: testMethod322  })), {323    a: Data(1),324    b: Required(),325    c: Method(testMethod)326  });327};328exports['test:resolve: renaming'] = function (test) {329  assertSametrait(test,330    resolve(331      { a: 'A', c: 'C' },332      trait({ a: 1, b: required, c: testMethod })333    ),334    {335      A: Data(1),336      b: Required(),337      C: Method(testMethod),338      a: Required(),339      c: Required()340    }341  );342};343exports['test:resolve: renaming to conflicting name causes conflict, order 1']344= function (test) {345  assertSametrait(test,346    resolve(347      { a: 'b'},348      trait({ a: 1, b: 2 })349    ),350    {351      b: Conflict('b'),352      a: Required()353    }354  );355};356exports['test:resolve: renaming to conflicting name causes conflict, order 2']357= function (test) {358  assertSametrait(test,359    resolve(360      { a: 'b' },361      trait({ b: 2, a: 1 })362    ),363    {364      b: Conflict('b'),365      a: Required()366    }367  );368};369exports['test:resolve: simple exclusion'] = function (test) {370  assertSametrait(test,371    resolve(372      { a: undefined },373      trait({ a: 1, b: 2 })374    ),375    {376      a: Required(),377      b: Data(2)378    }379  );380};381exports['test:resolve: exclusion to "empty" trait'] = function (test) {382  assertSametrait(test,383    resolve(384      { a: undefined, b: undefined },385      trait({ a: 1, b: 2 })386    ),387    {388      a: Required(),389      b: Required()390    }391  );392};393exports['test:resolve: exclusion and renaming of disjoint props'] =394function (test) {395  assertSametrait(test,396    resolve(397      { a: undefined, b: 'c' },398      trait({ a: 1, b: 2 })399    ),400    {401      a: Required(),402      c: Data(2),403      b: Required()404    }405  );406};407exports['test:resolve: exclusion and renaming of overlapping props'] =408function (test) {409  assertSametrait(test,410    resolve(411      { a: undefined, b: 'a' },412      trait({ a: 1, b: 2 })413    ),414    {415      a: Data(2),416      b: Required()417    }418  );419};420exports['test:resolve: renaming to a common alias causes conflict'] =421function (test) {422  assertSametrait(test,423    resolve(424      { a: 'c', b: 'c' },425      trait({ a: 1, b: 2 })426    ),427    {428      c: Conflict('c'),429      a: Required(),430      b: Required()431    }432  );433};434exports['test:resolve: renaming overrides required target'] =435function (test) {436  assertSametrait(test,437    resolve(438      { b: 'a' },439      trait({ a: required, b: 2 })440    ),441    {442      a: Data(2),443      b: Required()444    }445  );446};447exports['test:resolve: renaming required properties has no effect'] =448function (test) {449  assertSametrait(test,450    resolve(451      { b: 'a' },452      trait({ a: 2, b: required })453    ),454    {455      a: Data(2),456      b: Required()457    }458  );459};460exports['test:resolve: renaming of non-existent props has no effect'] =461function (test) {462  assertSametrait(test,463    resolve(464      { a: 'c', d: 'c' },465      trait({ a: 1, b: 2 })466    ),467    {468      c: Data(1),469      b: Data(2),470      a: Required()471    }472  );473};474exports['test:resolve: exclusion of non-existent props has no effect'] =475function (test) {476  assertSametrait(test,477    resolve(478      { b: undefined },479      trait({ a: 1 })480    ),481    {482      a: Data(1)483    }484  );485};486exports['test:resolve is neutral w.r.t. required properties'] =487function (test) {488  assertSametrait(test,489    resolve(490      { a: 'c', b: undefined },491      trait({ a: required, b: required, c: 'foo', d: 1 })492    ),493    {494      a: Required(),495      b: Required(),496      c: Data('foo'),497      d: Data(1)498    }499  );500};501exports['test:resolve supports swapping of property names, ordering 1'] =502function (test) {503  assertSametrait(test,504    resolve(505      { a: 'b', b: 'a' },506      trait({ a: 1, b: 2 })507    ),508    {509      a: Data(2),510      b: Data(1)511    }512  );513};514exports['test:resolve supports swapping of property names, ordering 2'] =515function (test) {516  assertSametrait(test,517    resolve(518      { b: 'a', a: 'b' },519      trait({ a: 1, b: 2 })520    ),521    {522      a: Data(2),523      b: Data(1)524    }525  );526};527exports['test:resolve supports swapping of property names, ordering 3'] =528function (test) {529  assertSametrait(test,530    resolve(531      { b: 'a', a: 'b' },532      trait({ b: 2, a: 1 })533    ),534    {535      a: Data(2),536      b: Data(1)537    }538  );539};540exports['test:resolve supports swapping of property names, ordering 4'] =541function (test) {542  assertSametrait(test,543    resolve(544      { a: 'b', b: 'a' },545      trait({ b: 2, a: 1 })546    ),547    {548      a: Data(2),549      b: Data(1)550    }551  );552};553exports['test:override of mutually exclusive traits'] = function (test) {554  assertSametrait(test,555    override(556      trait({ a: 1, b: 2 }),557      trait({ c: 3, d: testMethod })558    ),559    {560      a: Data(1),561      b: Data(2),562      c: Data(3),563      d: Method(testMethod)564    }565  );566};567exports['test:override of mutually exclusive traits is compose'] =568function (test) {569  assertSametrait(test,570    override(571      trait({ a: 1, b: 2 }),572      trait({ c: 3, d: testMethod })573    ),574    compose(575      trait({ d: testMethod, c: 3 }),576      trait({ b: 2, a: 1 })577    )578  );579};580exports['test:override of overlapping traits'] = function (test) {581  assertSametrait(test,582    override(583      trait({ a: 1, b: 2 }),584      trait({ a: 3, c: testMethod })585    ),586    {587      a: Data(1),588      b: Data(2),589      c: Method(testMethod)590    }591  );592};593exports['test:three-way override of overlapping traits'] = function (test) {594  assertSametrait(test,595    override(596      trait({ a: 1, b: 2 }),597      trait({ b: 4, c: 3 }),598      trait({ a: 3, c: testMethod, d: 5 })599    ),600    {601      a: Data(1),602      b: Data(2),603      c: Data(3),604      d: Data(5)605    }606  );607};608exports['test:override replaces required properties'] = function (test) {609  assertSametrait(test,610    override(611      trait({ a: required, b: 2 }),612      trait({ a: 1, c: testMethod })613    ),614    {615      a: Data(1),616      b: Data(2),617      c: Method(testMethod)618    }619  );620};621exports['test:override is not commutative'] = function (test) {622  assertSametrait(test,623    override(624      trait({ a: 1, b: 2 }),625      trait({ a: 3, c: 4 })626    ),627    {628      a: Data(1),629      b: Data(2),630      c: Data(4)631    }632  );633  assertSametrait(test,634    override(635      trait({ a: 3, c: 4 }),636      trait({ a: 1, b: 2 })637    ),638    {639      a: Data(3),640      b: Data(2),641      c: Data(4)642    }643  );644};645exports['test:override is associative'] = function (test) {646  assertSametrait(test,647    override(648      override(649        trait({ a: 1, b: 2 }),650        trait({ a: 3, c: 4, d: 5 })651      ),652      trait({ a: 6, c: 7, e: 8 })653    ),654    override(655      trait({ a: 1, b: 2 }),656      override(657        trait({ a: 3, c: 4, d: 5 }),658        trait({ a: 6, c: 7, e: 8 })659      )660    )661  );662};663exports['test:create simple'] = function(test) {664  let o1 = create(665    Object.prototype,666    trait({ a: 1, b: function() { return this.a; } })667  );668  test.assertEqual(669    Object.prototype,670    Object.getPrototypeOf(o1),671    'o1 prototype'672  );673  test.assertEqual(1, o1.a, 'o1.a');674  test.assertEqual(1, o1.b(), 'o1.b()');675  test.assertEqual(676    2,677    Object.getOwnPropertyNames(o1).length,678    'Object.keys(o1).length === 2'679  );680};681exports['test:create with Array.prototype'] = function(test) {682  let o2 = create(Array.prototype, trait({}));683  test.assertEqual(684    Array.prototype,685    Object.getPrototypeOf(o2),686    "o2 prototype"687  );688};689exports['test:exception for incomplete required properties'] =690function(test) {691  try {692    create(Object.prototype, trait({ foo: required }));693    test.fail('expected create to complain about missing required props');694  } catch(e) {695    test.assertEqual(696      'Error: Missing required property: foo',697      e.toString(),698      'required prop error'699    );700  }701};702exports['test:exception for unresolved conflicts'] = function(test) {703  try {704    create({}, compose(trait({ a: 0 }), trait({ a: 1 })));705    test.fail('expected create to complain about unresolved conflicts');706  } catch(e) {707    test.assertEqual(708      'Error: Remaining conflicting property: a',709      e.toString(),710      'conflicting prop error'711    );712  }713};714exports['test:verify that required properties are present but undefined'] =715function(test) {716  try {717    let o4 = Object.create(Object.prototype, trait({ foo: required }));718    test.assertEqual(true, 'foo' in o4, 'required property present');719    try {720      let foo = o4.foo;721      test.fail('access to required property must throw');722    } catch(e) {723      test.assertEqual(724        'Error: Missing required property: foo',725        e.toString(),726        'required prop error'727      )728    }729  } catch(e) {730    test.fail('did not expect create to complain about required props');731  }732};733exports['test:verify that conflicting properties are present'] =734function(test) {735  try {736    let o5 = Object.create(737      Object.prototype,738      compose(trait({ a: 0 }), trait({ a: 1 }))739    );740    test.assertEqual(true, 'a' in o5, 'conflicting property present');741    try {742      let a = o5.a; // accessors or data prop743      test.fail('expected conflicting prop to cause exception');744    } catch (e) {745      test.assertEqual(746        'Error: Remaining conflicting property: a',747        e.toString(),748        'conflicting prop access error'749      );750    }751  } catch(e) {752    test.fail('did not expect create to complain about conflicting props');753  }754};755exports['test diamond with conflicts'] = function(test) {756  function makeT1(x) trait({ m: function() { return x; } })757  function makeT2(x) compose(trait({ t2: 'foo' }), makeT1(x))758  function makeT3(x) compose(trait({ t3: 'bar' }), makeT1(x))759  let T4 = compose(makeT2(5), makeT3(5));760  try {761    let o = create(Object.prototype, T4);762    test.fail('expected diamond prop to cause exception');763  } catch(e) {764    test.assertEqual(765      'Error: Remaining conflicting property: m',766      e.toString(),767      'diamond prop conflict'768    );769  }...

EventDispatcherTests.js

Source:EventDispatcherTests.js

...38            "Assert dispatcher target is set to the target passed in during instantiation");39    }40};41annotate(eventDispatcherInstantiationTest).with(42    test().name("EventDispatcher instantiation test")43);44/**45 * This tests46 * 1) Adding and event listener47 * 2) Dispatching a simple event48 */49var eventDispatcherSimpleAddEventListenerDispatchEventTest = {50    // Setup Test51    //-------------------------------------------------------------------------------52    setup: function() {53        this.eventDispatcher = new EventDispatcher();54        this.testEventType = "testEventType";55        this.testEventData = "testEventData";56        this.testEvent = new Event(this.testEventType, this.testEventData);57        this.calledVar = false;58        this.testContextVar = "some value";59        this.testListenerContext = {60            testContextVar: this.testContextVar61        };62    },63    // Run Test64    //-------------------------------------------------------------------------------65    test: function(test) {66        var _this = this;67        this.testListenerFunction = function(event) {68            _this.calledVar = true;69            test.assertEqual(this.testContextVar, _this.testContextVar,70                "Assert the listener function was called in the listener context");71            test.assertEqual(event.getType(), _this.testEventType,72                "Assert event type received was the event type published");73            test.assertEqual(event.getData(), _this.testEventData,74                "Assert event data received was the event data published");75            test.assertEqual(event.getTarget(), _this.eventDispatcher,76                "Assert event target is the dispatcher that dispatched the event");77        };78        this.eventDispatcher.addEventListener(this.testEventType, this.testListenerFunction, this.testListenerContext);79        this.eventDispatcher.dispatchEvent(this.testEvent);80        test.assertTrue(this.calledVar, "Assert listener function was called.");81    }82};83annotate(eventDispatcherSimpleAddEventListenerDispatchEventTest).with(84    test().name("EventDispatcher simple add event listener and dispatch event test")85);86/**87 * This tests88 * 1) Adding an anonymous event listener89 * 2) Dispatching a simple event with anonymous listeners90 */91var eventDispatcherAddAnonymousEventListenerDispatchEventTest = {92    // Setup Test93    //-------------------------------------------------------------------------------94    setup: function() {95        this.eventDispatcher = new EventDispatcher();96        this.testEventType = "testEventType";97        this.testEventData = "testEventData";98        this.testEvent = new Event(this.testEventType, this.testEventData);99        this.calledVar = false;100    },101    // Run Test102    //-------------------------------------------------------------------------------103    test: function(test) {104        var _this = this;105        this.testListenerFunction = function(event) {106            _this.calledVar = true;107            test.assertEqual(event.getType(), _this.testEventType,108                "Assert event type received was the event type published");109            test.assertEqual(event.getData(), _this.testEventData,110                "Assert event data received was the event data published");111            test.assertEqual(event.getTarget(), _this.eventDispatcher,112                "Assert event target is the dispatcher that dispatched the event");113        };114        this.eventDispatcher.addEventListener(this.testEventType, this.testListenerFunction);115        this.eventDispatcher.dispatchEvent(this.testEvent);116        test.assertTrue(this.calledVar, "Assert listener function was called.");117    }118};119annotate(eventDispatcherAddAnonymousEventListenerDispatchEventTest).with(120    test().name("EventDispatcher add anonymous event listener and dispatch event test")121);122/**123 * This tests124 * 1) That an event does not bubble when bubbles is false on dispatchEvent125 */126var eventDispatcherDispatchEventBubblesFalseTest = {127    // Setup Test128    //-------------------------------------------------------------------------------129    setup: function() {130        this.testChildEventDispatcher = new EventDispatcher();131        this.testParentEventDispatcher = new EventDispatcher();132        this.testEventType = "testEventType";133        this.testEventData = "testEventData";134        this.testEvent = new Event(this.testEventType, this.testEventData);135        this.testBubbles = false;136        this.childCalledVar = false;137        var _this = this;138        this.testChildListenerFunction = function(event) {139            _this.childCalledVar = true;140        };141        this.parentCalledVar = false;142        this.testParentListenerFunction = function(event) {143            _this.parentCalledVar = true;144        };145    },146    // Run Test147    //-------------------------------------------------------------------------------148    test: function(test) {149        this.testChildEventDispatcher.setParentDispatcher(this.testParentEventDispatcher);150        this.testChildEventDispatcher.addEventListener(this.testEventType, this.testChildListenerFunction);151        this.testParentEventDispatcher.addEventListener(this.testEventType, this.testParentListenerFunction);152        this.testChildEventDispatcher.dispatchEvent(this.testEvent, this.testBubbles);153        test.assertTrue(this.childCalledVar,154            "Assert listener function on child dispatcher was called when bubbles is false.");155        test.assertFalse(this.parentCalledVar,156            "Assert listener function on parent dispatcher was not called when bubbles is false.");157    }158};159annotate(eventDispatcherDispatchEventBubblesFalseTest).with(160    test().name("EventDispatcher dispatch event with bubbles false test")161);162/**163 * This tests164 * 1) That an event does bubble when bubbles is true on dispatchEvent165 */166var eventDispatcherDispatchEventBubblesTrueTest = {167    // Setup Test168    //-------------------------------------------------------------------------------169    setup: function() {170        var _this = this;171        this.testChildEventDispatcher = new EventDispatcher();172        this.testParentEventDispatcher = new EventDispatcher();173        this.testEventType = "testEventType";174        this.testEventData = "testEventData";175        this.testEvent = new Event(this.testEventType, this.testEventData);176        this.testBubbles = true;177        this.childCalledVar = false;178        this.testChildListenerFunction = function(event) {179            _this.childCalledVar = true;180        };181        this.parentCalledVar = false;182        this.testParentListenerFunction = function(event) {183            _this.parentCalledVar = true;184        };185    },186    // Run Test187    //-------------------------------------------------------------------------------188    test: function(test) {189        this.testChildEventDispatcher.setParentDispatcher(this.testParentEventDispatcher);190        this.testChildEventDispatcher.addEventListener(this.testEventType, this.testChildListenerFunction);191        this.testParentEventDispatcher.addEventListener(this.testEventType, this.testParentListenerFunction);192        this.testChildEventDispatcher.dispatchEvent(this.testEvent, this.testBubbles);193        test.assertTrue(this.childCalledVar,194            "Assert listener function on child dispatcher was called when bubbles is true.");195        test.assertTrue(this.parentCalledVar,196            "Assert listener function on parent dispatcher was called when bubbles is true.");197    }198};199annotate(eventDispatcherDispatchEventBubblesTrueTest).with(200    test().name("EventDispatcher dispatch event with bubbles true test")201);202/**203 * This tests204 * 1) That an event does not bubble on dispatchEvent when stopPropagation is called205 */206var eventDispatcherDispatchEventStopPropagationTest = {207    // Setup Test208    //-------------------------------------------------------------------------------209    setup: function() {210        var _this = this;211        this.testChildEventDispatcher = new EventDispatcher();212        this.testParentEventDispatcher = new EventDispatcher();213        this.testEventType = "testEventType";214        this.testEventData = "testEventData";215        this.testEvent = new Event(this.testEventType, this.testEventData);216        this.testBubbles = true;217        this.childCalledVar = false;218        this.testChildListenerFunction = function(event) {219            _this.childCalledVar = true;220            event.stopPropagation();221        };222        this.parentCalledVar = false;223        this.testParentListenerFunction = function(event) {224            _this.parentCalledVar = true;225        };226    },227    // Run Test228    //-------------------------------------------------------------------------------229    test: function(test) {230        this.testChildEventDispatcher.setParentDispatcher(this.testParentEventDispatcher);231        this.testChildEventDispatcher.addEventListener(this.testEventType, this.testChildListenerFunction);232        this.testParentEventDispatcher.addEventListener(this.testEventType, this.testParentListenerFunction);233        this.testChildEventDispatcher.dispatchEvent(this.testEvent, this.testBubbles);234        test.assertTrue(this.childCalledVar,235            "Assert listener function on child dispatcher was called");236        test.assertFalse(this.parentCalledVar,237            "Assert listener function on parent dispatcher was not called when stopPropagation was called on a child " +238                "EventDispatcher");239    }240};241annotate(eventDispatcherDispatchEventStopPropagationTest).with(242    test().name("EventDispatcher dispatch event stopPropagation test")243);244/**245 * This tests246 * 1) Adding an event listener247 * 2) That hasEventListener returns true after adding an event listener248 * 3) Removing the event listener249 * 4) That hasEventListener returns false after removing the event listener250 */251var eventDispatcherSimpleAddAndRemoveEventListenerTest = {252    // Setup Test253    //-------------------------------------------------------------------------------254    setup: function() {255        this.eventDispatcher = new EventDispatcher();256        this.testEventType = "testEventType";257        this.testListenerContext = {};258        this.testListenerFunction = function(event) {};259    },260    // Run Test261    //-------------------------------------------------------------------------------262    test: function(test) {263        this.eventDispatcher.addEventListener(this.testEventType, this.testListenerFunction, this.testListenerContext);264        var hasListenerAfterAdd = this.eventDispatcher.hasEventListener(this.testEventType, this.testListenerFunction,265            this.testListenerContext);266        test.assertTrue(hasListenerAfterAdd,267            "Assert hasEventListener returns true after adding an event listener.");268        this.eventDispatcher.removeEventListener(this.testEventType, this.testListenerFunction,269            this.testListenerContext);270        var hasListenerAfterRemove = this.eventDispatcher.hasEventListener(this.testEventType,271            this.testListenerFunction, this.testListenerContext);272        test.assertFalse(hasListenerAfterRemove,273            "Assert hasEventListener returns false after removing the event listener.");274    }275};276annotate(eventDispatcherSimpleAddAndRemoveEventListenerTest).with(277    test().name("EventDispatcher simple add and remove event listener test")...

SVGMarkerTests.js

Source:SVGMarkerTests.js

1//mocks2/**3 * Init package4 */5if(!ORYX) {var ORYX = {};}6if(!ORYX.Core) {ORYX.Core = {};}7if(!ORYX.Core.SVG) {ORYX.Core.SVG = {};}89// mocking ORYX.Editor object10if(!ORYX) {var ORYX = {};}11if(!ORYX.Editor) {ORYX.Editor = {};}1213//stubs1415// stubbing ORYX.Editor.checkClassType16ORYX.Editor.checkClassType = function( classInst, classType ) {17		return classInst instanceof classType18}1920//tests2122function setUp() {23	// set oryx namespace24	NAMESPACE_ORYX_TEST = "http://www.b3mn.org/oryx";25	testChild1 = document.createElementNS('http://www.w3.org/2000/svg', 'svg' )26	testChild2 = document.createElementNS('http://www.w3.org/2000/svg', 'rect' )27	testChildChild1 = document.createElementNS('http://www.w3.org/2000/svg', 'path' )28	testSVGMarkerElement = document.createElementNS('http://www.w3.org/2000/svg', 'marker')29}3031/**32 * Tests if an exception is thrown if no valid SVGMarkerElement is passed to the constructor.33 */34function testFailForAnInvalidSVGMarkerElement() {35	try {36		testSVGMarker = new ORYX.Core.SVG.SVGMarker(5);37		fail("SVGMarker test should fail yet.")38	} catch (e) {39		if ((e instanceof JsUnitException)) {40			throw e;41		}42	}43}4445/**46 * Creates a SVGMarker instance, from an empty SVGMarkerElement.47 */48function testCreateSVGMarkerFromDOMElement() {49	try {50		testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);51		fail(" ")52	} catch (e) {53		if (!(e instanceof JsUnitException)) {54			throw e;55		}56	}57}5859/**60 * No further attributes specified. So check if default values are set.61 */62function testDefaultValues() {63	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);64	assertNotNaN("Is oldRefX a Number?",Number(testSVGMarker.oldRefX))65	assertNotNaN("Is oldRefY a Number?",Number(testSVGMarker.oldRefY))66	assertNotNaN("Is oldMarkerWidth a Number?",Number(testSVGMarker.oldMarkerWidth))67	assertNotNaN("Is oldMarkerHeight a Number?",Number(testSVGMarker.oldMarkerHeight))68	assertFalse("Not optional",testSVGMarker.optional)69	assertTrue("Enabled",testSVGMarker.enabled)70	assertFalse("Should not be resizable",testSVGMarker.resize)71}7273/**74 * Test parsing of id attribute75 */76function testIDValue() {77	testSVGMarkerElement.setAttributeNS(null, "id", "myMarker")78	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);79	assertEquals("ID value should be 'myMarker'", testSVGMarker.id, "myMarker")80}8182/**83 * Test parsing of refX attribute84 */85function testRefXValue() {86	testSVGMarkerElement.setAttributeNS(null, "refX", 89.45)87	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);88	assertEquals("Checks RefX value.", testSVGMarker.refX, 89.45)89	assertEquals("Checks oldRefX value.", testSVGMarker.oldRefX, 89.45)90}9192/**93 * Test parsing of refX as String attribute94 */95function testRefXStringValue() {96	testSVGMarkerElement.setAttributeNS(null, "refX", "89.45")97	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);98	assertEquals("Checks RefX value.", testSVGMarker.refX, 89.45)99	assertEquals("Checks oldRefX value.", testSVGMarker.oldRefX, 89.45)100}101102/**103 * If RefX is not a number, it should throw an Exception.104 */105function testFailForNaNRefXValue() {106	try {107		testSVGMarkerElement.setAttributeNS(null, "refX", "two")108		testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);109		fail("Test should fail yet.")110	} catch (e) {111		if ((e instanceof JsUnitException)) {112			throw e;113		}114	}115}116117/**118 * Test parsing of refY attribute119 */120function testRefYValue() {121	testSVGMarkerElement.setAttributeNS(null, "refY", 89.45)122	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);123	assertEquals("Checks RefY value.", testSVGMarker.refY, 89.45)124	assertEquals("Checks oldRefX value.", testSVGMarker.oldRefY, 89.45)125}126127/**128 * Test parsing of refY as String attribute129 */130function testRefYStringValue() {131	testSVGMarkerElement.setAttributeNS(null, "refY", "89.45")132	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);133	assertEquals("Checks RefY value.", testSVGMarker.refY, 89.45)134	assertEquals("Checks oldRefY value.", testSVGMarker.oldRefY, 89.45)135}136137/**138 * If RefY is not a number, it should throw an Exception.139 */140function testFailForNaNRefYValue() {141	try {142		testSVGMarkerElement.setAttributeNS(null, "refY", "two")143		testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);144		fail("Test should fail yet.")145	} catch (e) {146		if ((e instanceof JsUnitException)) {147			throw e;148		}149	}150}151152/**153 * Test parsing of markerWidth attribute154 */155function testMarkerWidthValue() {156	testSVGMarkerElement.setAttributeNS(null, "markerWidth", 4.45)157	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);158	assertEquals("Checks MarkerWidth value.", testSVGMarker.markerWidth, 4.45)159}160161/**162 * Test parsing of markerWidth as String attribute163 */164function testMarkerWidthStringValue() {165	testSVGMarkerElement.setAttributeNS(null, "markerWidth", "4.45")166	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);167	assertEquals("Checks markerWidth value.", testSVGMarker.markerWidth, 4.45)168}169170/**171 * If markerWidth is not a number, it should throw an Exception.172 */173function testFailForNaNMarkerWidthValue() {174	try {175		testSVGMarkerElement.setAttributeNS(null, "markerWidth", "two")176		testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);177		fail("Test should fail yet.")178	} catch (e) {179		if ((e instanceof JsUnitException)) {180			throw e;181		}182	}183}184185/**186 * Test parsing of markerHeight attribute187 */188function testMarkerHeightValue() {189	testSVGMarkerElement.setAttributeNS(null, "markerHeight", 4.45)190	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);191	assertEquals("Checks MarkerHeight value.", testSVGMarker.markerHeight, 4.45)192}193194/**195 * Test parsing of markerHeight as String attribute196 */197function testMarkerHeightStringValue() {198	testSVGMarkerElement.setAttributeNS(null, "markerHeight", "4.45")199	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);200	assertEquals("Checks markerHeight value.", testSVGMarker.markerHeight, 4.45)201}202203/**204 * If markerHeight is not a number, it should throw an Exception.205 */206function testFailForNaNMarkerHeightValue() {207	try {208		testSVGMarkerElement.setAttributeNS(null, "markerHeight", "two")209		testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);210		fail("Test should fail yet.")211	} catch (e) {212		if ((e instanceof JsUnitException)) {213			throw e;214		}215	}216}217218/**219 * Test parsing of oryx:optional attribute220 */221function testMarkerOryxOptionalValue() {222	testSVGMarkerElement.setAttributeNS(NAMESPACE_ORYX_TEST, "optional", "yes")223	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);224	assertTrue("Checks oryx:optional value.", testSVGMarker.optional)225}226227/**228 * Test parsing of oryx:optional with a "no" value229 */230function testMarkerOryxOptionalNoValue() {231	testSVGMarkerElement.setAttributeNS(NAMESPACE_ORYX_TEST, "optional", "")232	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);233	assertFalse("Checks oryx:optional value.", testSVGMarker.optional)234}235236/**237 * Test parsing of oryx:enabled attribute238 */239function testMarkerOryxEnabledValue() {240	testSVGMarkerElement.setAttributeNS(NAMESPACE_ORYX_TEST, "enabled", "yes")241	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);242	assertTrue("Checks oryx:enabled value.", testSVGMarker.enabled)243}244245/**246 * Test parsing of oryx:optional with a "no" value247 */248function testMarkerOryxEnabledNoValue() {249	testSVGMarkerElement.setAttributeNS(NAMESPACE_ORYX_TEST, "enabled", "nO")250	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);251	assertFalse("Checks oryx:enabled value.", testSVGMarker.optional)252}253254/**255 * Test parsing of oryx:resize attribute256 */257function testMarkerOryxResizeValue() {258	testSVGMarkerElement.setAttributeNS(NAMESPACE_ORYX_TEST, "resize", "yes")259	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);260	assertTrue("Checks oryx:resize value.", testSVGMarker.resize)261}262263/**264 * Test parsing of oryx:resize with a "no" value265 */266function testMarkerOryxOptionalNoValue() {267	testSVGMarkerElement.setAttributeNS(NAMESPACE_ORYX_TEST, "resize", "")268	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);269	assertFalse("Checks oryx:resize value.", testSVGMarker.resize)270}271272/**273 * Test parsing of oryx:minimumLength attribute as string274 */275function testMarkerOryxMinimumLengthAsStringValue() {276	testSVGMarkerElement.setAttributeNS(NAMESPACE_ORYX_TEST, "minimumLength", "51.8")277	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);278	assertEquals("Checks oryx:minimumLength value.", testSVGMarker.minimumLength, 51.8)279}280281/**282 * Test parsing of oryx:minimumLength attribute283 */284function testMarkerOryxMinimumLengthValue() {285	testSVGMarkerElement.setAttributeNS(NAMESPACE_ORYX_TEST, "minimumLength", 51.8)286	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);287	assertEquals("Checks oryx:minimumLength value.", testSVGMarker.minimumLength, 51.8)288}289290/**291 * If oryx:minimumLength is not a number, it should throw an Exception.292 */293function testFailForNaNMarkerOryxMinimumLengthtValue() {294	try {295		testSVGMarkerElement.setAttributeNS(NAMESPACE_ORYX_TEST, "minimumLength", "two")296		testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);297		fail("Test should fail yet.")298	} catch (e) {299		if ((e instanceof JsUnitException)) {300			throw e;301		}302	}303}304305// test _getSVGShape method306307/**308 * 309 */310function testReturnEmptyArrayForNonNestedElement() {311	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);312	assertEquals("_getSVGShape() without child nodes should return an empty array.", testSVGMarker._getSVGShapes(testSVGMarkerElement), [])313}314315/**316 * There are two rectagle shape added to the SVGMarker. So you should retrieve two ORYX.Core.SVG.SVGShape 317 * instances from the _getSVGShapes method318 */319function testGetSVGShapes() {320	testSVGRectElement1 = document.createElementNS('http://www.w3.org/2000/svg', 'rect');321	testSVGRectElement1.setAttributeNS(null, "x", 2);322	testSVGRectElement1.setAttributeNS(null, "y", 2);323	testSVGRectElement1.setAttributeNS(null, "height", 3);324	testSVGRectElement1.setAttributeNS(null, "width", 4);325	326	testSVGRectElement2 = document.createElementNS('http://www.w3.org/2000/svg', 'rect');327	testSVGRectElement2.setAttributeNS(null, "x", 2);328	testSVGRectElement2.setAttributeNS(null, "y", 2);329	testSVGRectElement2.setAttributeNS(null, "height", 5);330	testSVGRectElement2.setAttributeNS(null, "width", 4);331	332	testSVGMarkerElement.appendChild(testSVGRectElement1)333	testSVGMarkerElement.appendChild(testSVGRectElement2)334	335	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);336	var childShapes = testSVGMarker._getSVGShapes(testSVGMarkerElement)337	338	assertTrue("SVGShape instance in array", childShapes[0] instanceof ORYX.Core.SVG.SVGShape)339	assertTrue("SVGShape instance in array", childShapes[1] instanceof ORYX.Core.SVG.SVGShape)340}341342/**343 * Test the update method344 */345function testUpdate() {346	testSVGMarker = new ORYX.Core.SVG.SVGMarker(testSVGMarkerElement);347	testSVGMarker.refX = 66348	testSVGMarker.refY = 88349	testSVGMarker.markerWidth = 9350	testSVGMarker.markerHeight = 22351	testSVGMarker.update();352	353	assertEquals("Check oldRefX value", testSVGMarker.oldRefX, 66 )	354	assertEquals("Check oldRefY value", testSVGMarker.oldRefY, 88 )355	assertEquals("Check oldMarkerWidth value", testSVGMarker.oldMarkerWidth, 9 )356	assertEquals("Check oldMarkerHeight value", testSVGMarker.oldMarkerHeight, 22)		
...

tests.js

Source:tests.js

1var EntryPool = require('../pool.js');2exports.poolGetEmpty = function(test) {3    var pool = new EntryPool(0, 1);4    test.strictEqual(pool.size, 0);5    test.throws(function() {6        pool.get();7    });8    test.done();9};10exports.poolGetEmptyStep = function(test) {11    var pool = new EntryPool(0, 1, 1);12    test.strictEqual(pool.size, 0);13    test.notStrictEqual(pool.get(), undefined);14    test.strictEqual(pool.size, 1);15    test.strictEqual(pool.size, pool.pool.length);16    test.done();17};18exports.poolAddGet = function(test) {19    var pool = new EntryPool(0, 1);20    test.strictEqual(pool.size, 0);21    pool.add(1);22    test.strictEqual(pool.size, 1);23    test.strictEqual(pool.size, pool.pool.length);24    test.notStrictEqual(pool.get(), undefined);25    test.done();26};27exports.poolGetNoneLeft = function(test) {28    var pool = new EntryPool(1, 1);29    test.notStrictEqual(pool.get(), undefined);30    test.strictEqual(pool.size, 1);31    test.notStrictEqual(pool.get(), undefined);32    test.strictEqual(pool.size, 2);33    test.strictEqual(pool.size, pool.pool.length);34    test.done();35};36exports.poolGetNoneLeftCustomStep = function(test) {37    var pool = new EntryPool(1, 1, 3);38    test.notStrictEqual(pool.get(), undefined);39    test.strictEqual(pool.size, 1);40    test.notStrictEqual(pool.get(), undefined);41    //since we didn't put the original one back the size should be only 3 (step size)42    test.strictEqual(pool.size, 4);43    test.strictEqual(pool.size, pool.pool.length);44    test.done();45};46exports.poolPutGet = function(test) {47    var pool = new EntryPool(1, 1),48        arr = pool.get();49    pool.put(arr);50    test.strictEqual(pool.get(), arr);51    test.strictEqual(pool.size, 1);52    test.done();53};54exports.arrAdd = function(test) {55    var pool = new EntryPool(1, 2),56        arr = pool.get();57    test.strictEqual(arr.add(1), 0);58    test.strictEqual(arr.add(2), 1);59    test.strictEqual(arr.at(0), 1);60    test.strictEqual(arr.at(1), 2);61    test.done();62};63exports.arrAddValue = function(test) {64    var pool = new EntryPool(1, 2),65        arr = pool.get();66    test.strictEqual(arr.add(1, 1), 0);67    test.strictEqual(arr.add(2, 2), 1);68    test.strictEqual(arr.at(0), 1);69    test.strictEqual(arr.at(1), 2);70    test.done();71};72exports.arrAddUndefined = function(test) {73    var pool = new EntryPool(1, 2),74        arr = pool.get();75    test.throws(function() {76        EntryPool.addEntry(arr, undefined);77    });78    test.throws(function() {79        arr.add(undefined);80    });81    test.done();82};83exports.arrRemove = function(test) {84    var pool = new EntryPool(1, 1),85        arr = pool.get();86    EntryPool.addEntry(arr, 1);87    test.strictEqual(arr.remove(2), false);88    test.strictEqual(arr.remove(1), true);89    test.strictEqual(arr.numEntries(arr), 0);90    test.strictEqual(arr.remove(undefined), true);91    test.done();92};93exports.arrRemoveValues = function(test) {94    var pool = new EntryPool(1, 3),95        arr = pool.get();96    arr.add(999, 1);97    arr.add(2, 8);98    arr.add(3, 9);99    test.strictEqual(arr.remove(5), false); //matches nothing100    test.strictEqual(arr.numEntries(), 3);101    test.strictEqual(arr.remove(1), false); //matches nothing unless mismatch value/timestamp102    test.strictEqual(arr.numEntries(), 3);103    test.strictEqual(arr.remove(undefined, 1), false); //matches on value104    test.strictEqual(arr.numEntries(), 2);105    test.strictEqual(arr.remove(2), false); //matches on timestamp106    test.strictEqual(arr.numEntries(), 1);107    test.strictEqual(arr.remove(3, 3), false); //matches nothing unless value ignored108    test.strictEqual(arr.numEntries(), 1);109    test.strictEqual(arr.remove(3, 9), true); //matches on value and timestamp110    test.strictEqual(arr.numEntries(), 0);111    test.done();112};113exports.arrRemoveShifts = function(test) {114    var pool = new EntryPool(1, 3),115        arr = pool.get();116    arr.add(1);117    arr.add(2);118    arr.add(3);119    arr.remove(1);120    test.strictEqual(arr.numEntries(), 2);121    test.strictEqual(arr.at(0), 2);122    test.strictEqual(arr.at(1), 3);123    test.strictEqual(arr.at(2), undefined);124    test.done();125};126exports.arrAddOverLimit = function(test) {127    var pool = new EntryPool(1, 1),128        arr = pool.get();129    arr.add(arr, 1);130    test.strictEqual(arr.add(2), -1);131    test.strictEqual(arr.at(0), 1);132    test.strictEqual(arr.at(1), undefined);133    test.done();134};135exports.arrNumEntries = function(test) {136    var pool = new EntryPool(1, 1),137        arr = pool.get();138    arr.add(1);139    test.strictEqual(arr.numEntries(), 1);140    test.done();141};142exports.arrCleanup = function(test) {143    var pool = new EntryPool(1, 3),144        arr = pool.get();145    arr.add(1);146    arr.add(2);147    arr.add(3);148    test.strictEqual(arr.cleanup(3), 1);149    test.strictEqual(arr.numEntries(), 1);150    test.strictEqual(arr.at(0), 3);151    test.strictEqual(arr.at(1), undefined);152    test.strictEqual(arr.at(2), undefined);153    test.strictEqual(arr.cleanup(4), 0);154    test.strictEqual(arr.numEntries(), 0);155    test.strictEqual(arr.at(0), undefined);156    test.done();157};158exports.arrCleanupUndefined = function(test) {159    var pool = new EntryPool(1, 1),160        arr = pool.get();161    arr.add(1);162    test.strictEqual(arr.cleanup(undefined), 0);163    test.strictEqual(arr.numEntries(), 0);164    test.done();165};166exports.poolPutEmpties = function(test) {167    var pool = new EntryPool(1, 1),168        arr = pool.get();169    arr.add(1);170    pool.put(arr);171    test.strictEqual(arr.numEntries(), 0);172    test.done();173};174exports.poolPutEmpties = function(test) {175    var pool = new EntryPool(1, 1),176        arr = pool.get();177    arr.add(1);178    pool.put(arr);179    test.strictEqual(arr.numEntries(), 0);180    test.done();181};182exports.poolPutInvalid = function(test) {183    var pool = new EntryPool(0, 1);184    test.throws(function() {185        pool.put('test');186    });187    test.done();188};189exports.poolPutInvalidSize = function(test) {190    var pool = new EntryPool(0, 1);191    test.throws(function() {192        pool.put(new Array(3));193    });194    test.done();195};196exports.poolPutArrayThrows = function(test) {197    var pool = new EntryPool(0, 1);198    test.throws(function() {199        pool.put(new Array(1));200    });201    test.strictEqual(pool.size, 0);202    test.done();203};204exports.poolPutPastEnd = function(test) {205    var pool = new EntryPool(0, 1),206        pool2 = new EntryPool(1, 1);207    pool.put(pool2.get());208    test.strictEqual(pool.size, 1);209    test.done();210};211exports.poolTrimAll = function(test) {212    var pool = new EntryPool(5, 1),213        arr = pool.get();214    pool.trim();215    test.strictEqual(pool.size, 1);216    test.strictEqual(pool.size, pool.pool.length);217    pool.put(arr);218    test.strictEqual(pool.size, 1);219    test.done();220};221exports.poolTrimAllButOne = function(test) {222    var pool = new EntryPool(5, 1),223        arr = pool.get();224    pool.trim(1);225    test.strictEqual(pool.size, 1);226    test.strictEqual(pool.size, pool.pool.length);227    pool.put(arr);228    test.strictEqual(pool.size, 1);229    test.done();230};231exports.poolTrimSome = function(test) {232    var pool = new EntryPool(5, 1),233        arr = pool.get();234    pool.trim(3);235    test.strictEqual(pool.size, 3);236    test.strictEqual(pool.size, pool.pool.length);237    pool.put(arr);238    test.strictEqual(pool.size, 3);239    test.done();240};241exports.poolTrimNone = function(test) {242    var pool = new EntryPool(1, 1);243    pool.trim(3);244    test.strictEqual(pool.size, 1);245    test.strictEqual(pool.size, pool.pool.length);246    test.done();247};248exports.poolTrimNoneAvailable = function(test) {249    var pool = new EntryPool(4, 1),250        arr1 = pool.get(),251        arr2 = pool.get();252    pool.get();253    pool.get();254    pool.trim();255    test.strictEqual(pool.size, 4);256    test.strictEqual(pool.size, pool.pool.length);257    //now put 2 back and try trimming again258    pool.put(arr1);259    pool.put(arr2);260    pool.trim();261    test.strictEqual(pool.size, 2);262    test.strictEqual(pool.size, pool.pool.length);263    test.done();264};265exports.poolTrimDoesntChangeOrder = function(test) {266    var pool = new EntryPool(3, 1),267        arr1 = pool.get(),268        arr2 = pool.get();269    pool.get();270    pool.trim();271    //now put 2 back and try trimming again272    pool.put(arr1);273    pool.put(arr2);274    pool.trim(2);275    test.strictEqual(pool.size, 2);276    test.strictEqual(pool.size, pool.pool.length);277    test.strictEqual(pool.get(), arr1);278    test.done();...

_getDataFunctions.js

Source:_getDataFunctions.js

1// DATA_TEMPLATE: dom_data2oTest.fnStart( "Check behaviour of the data get functions that DataTables uses" );3$(document).ready( function () {4	// Slightly unusual test set this one, in that we don't really care about the DOM5	// but want to test the internal data handling functions but we do need a table to6	// get at the functions!7	var table = $('#example').dataTable();8	var fn, test;9	10	// Object property access11	oTest.fnTest(12		"Single object, single property",13		function () {14			fn = table.oApi._fnGetObjectDataFn('test');15			test = fn( { "test": true } );16		},17		function () { return test }18	);19	20	oTest.fnTest(21		"Single property from object",22		function () {23			fn = table.oApi._fnGetObjectDataFn('test');24			test = fn( { "test": true, "test2": false } );25		},26		function () { return test }27	);28	29	oTest.fnTest(30		"Single property from object - different property",31		function () {32			fn = table.oApi._fnGetObjectDataFn('test2');33			test = fn( { "test": true, "test2": false } );34		},35		function () { return test===false }36	);37	38	oTest.fnTest(39		"Undefined property from object",40		function () {41			fn = table.oApi._fnGetObjectDataFn('test3');42			test = fn( { "test": true, "test2": false } );43		},44		function () { return test===undefined }45	);46	47	// Array index access48	oTest.fnTest(49		"Array access - index 0",50		function () {51			fn = table.oApi._fnGetObjectDataFn(0);52			test = fn( [true, false, false, false] );53		},54		function () { return test }55	);56	57	oTest.fnTest(58		"Array access - index 1",59		function () {60			fn = table.oApi._fnGetObjectDataFn(2);61			test = fn( [false, false, true, false] );62		},63		function () { return test }64	);65	66	oTest.fnTest(67		"Array access - undefined",68		function () {69			fn = table.oApi._fnGetObjectDataFn(7);70			test = fn( [false, false, true, false] );71		},72		function () { return test===undefined }73	);74	// null source75	oTest.fnTest(76		"null source",77		function () {78			fn = table.oApi._fnGetObjectDataFn( null );79			test = fn( [false, false, true, false] );80		},81		function () { return test===null }82	);83	// nested objects84	oTest.fnTest(85		"Nested object property",86		function () {87			fn = table.oApi._fnGetObjectDataFn( 'a.b' );88			test = fn( {89				"a":{90					"b": true,91					"c": false,92					"d": 193				}94			} );95		},96		function () { return test }97	);98	oTest.fnTest(99		"Nested object property - different prop",100		function () {101			fn = table.oApi._fnGetObjectDataFn( 'a.d' );102			test = fn( {103				"a":{104					"b": true,105					"c": false,106					"d": 1107				}108			} );109		},110		function () { return test===1 }111	);112	113	oTest.fnTest(114		"Nested object property - undefined prop",115		function () {116			fn = table.oApi._fnGetObjectDataFn( 'a.z' );117			test = fn( {118				"a":{119					"b": true,120					"c": false,121					"d": 1122				}123			} );124		},125		function () { return test===undefined }126	);127	// Nested array128	oTest.fnTest(129		"Nested array index property",130		function () {131			fn = table.oApi._fnGetObjectDataFn( 'a.0' );132			test = fn( {133				"a": [134					true,135					false,136					1137				]138			} );139		},140		function () { return test }141	);142	oTest.fnTest(143		"Nested array index property - different index",144		function () {145			fn = table.oApi._fnGetObjectDataFn( 'a.2' );146			test = fn( {147				"a": [148					true,149					false,150					1151				]152			} );153		},154		function () { return test===1 }155	);156	oTest.fnTest(157		"Nested array index property - undefined index",158		function () {159			fn = table.oApi._fnGetObjectDataFn( 'a.10' );160			test = fn( {161				"a": [162					true,163					false,164					1165				]166			} );167		},168		function () { return test===undefined }169	);170	// Nested array object property171	oTest.fnTest(172		"Nested array index object property",173		function () {174			fn = table.oApi._fnGetObjectDataFn( 'a.0.m' );175			test = fn( {176				"a": [177					{ "m": true, "n": 1 },178					{ "m": false, "n": 2 },179					{ "m": false, "n": 3 }180				]181			} );182		},183		function () { return test }184	);185	oTest.fnTest(186		"Nested array index object property - different index",187		function () {188			fn = table.oApi._fnGetObjectDataFn( 'a.2.n' );189			test = fn( {190				"a": [191					{ "m": true, "n": 1 },192					{ "m": false, "n": 2 },193					{ "m": false, "n": 3 }194				]195			} );196		},197		function () { return test===3 }198	);199	oTest.fnTest(200		"Nested array index object property - undefined index",201		function () {202			fn = table.oApi._fnGetObjectDataFn( 'a.0.z' );203			test = fn( {204				"a": [205					{ "m": true, "n": 1 },206					{ "m": false, "n": 2 },207					{ "m": false, "n": 3 }208				]209			} );210		},211		function () { return test===undefined }212	);213	// Array notation - no join214	oTest.fnTest(215		"Array notation - no join - property",216		function () {217			fn = table.oApi._fnGetObjectDataFn( 'a[].n' );218			test = fn( {219				"a": [220					{ "m": true, "n": 1 },221					{ "m": false, "n": 2 },222					{ "m": false, "n": 3 }223				]224			} );225		},226		function () {227			return test.length===3 && test[0]===1228				&& test[1]===2 && test[2]===3;229		}230	);231	oTest.fnTest(232		"Array notation - no join - property (2)",233		function () {234			fn = table.oApi._fnGetObjectDataFn( 'a[].m' );235			test = fn( {236				"a": [237					{ "m": true, "n": 1 },238					{ "m": false, "n": 2 }239				]240			} );241		},242		function () {243			return test.length===2 && test[0]===true244				&& test[1]===false;245		}246	);247	oTest.fnTest(248		"Array notation - no join - undefined property",249		function () {250			fn = table.oApi._fnGetObjectDataFn( 'a[].z' );251			test = fn( {252				"a": [253					{ "m": true, "n": 1 },254					{ "m": false, "n": 2 }255				]256			} );257		},258		function () {259			return test.length===2 && test[0]===undefined260				&& test[1]===undefined;261		}262	);263	// Array notation - join264	oTest.fnTest(265		"Array notation - space join - property",266		function () {267			fn = table.oApi._fnGetObjectDataFn( 'a[ ].n' );268			test = fn( {269				"a": [270					{ "m": true, "n": 1 },271					{ "m": false, "n": 2 },272					{ "m": false, "n": 3 }273				]274			} );275		},276		function () { return test === '1 2 3'; }277	);278	oTest.fnTest(279		"Array notation - space join - property (2)",280		function () {281			fn = table.oApi._fnGetObjectDataFn( 'a[ ].m' );282			test = fn( {283				"a": [284					{ "m": true, "n": 1 },285					{ "m": false, "n": 2 }286				]287			} );288		},289		function () { return test === 'true false'; }290	);291	oTest.fnTest(292		"Array notation - sapce join - undefined property",293		function () {294			fn = table.oApi._fnGetObjectDataFn( 'a[ ].z' );295			test = fn( {296				"a": [297					{ "m": true, "n": 1 },298					{ "m": false, "n": 2 }299				]300			} );301		},302		function () { return test === ' '; }303	);304	oTest.fnTest(305		"Array notation - string join - property",306		function () {307			fn = table.oApi._fnGetObjectDataFn( 'a[qwerty].n' );308			test = fn( {309				"a": [310					{ "m": true, "n": 1 },311					{ "m": false, "n": 2 },312					{ "m": false, "n": 3 }313				]314			} );315		},316		function () { return test === '1qwerty2qwerty3'; }317	);318	oTest.fnTest(319		"Array notation - string join - property (2)",320		function () {321			fn = table.oApi._fnGetObjectDataFn( 'a[qwerty].m' );322			test = fn( {323				"a": [324					{ "m": true, "n": 1 },325					{ "m": false, "n": 2 }326				]327			} );328		},329		function () { return test === 'trueqwertyfalse'; }330	);331	332	// Array alone join333	oTest.fnTest(334		"Flat array join",335		function () {336			fn = table.oApi._fnGetObjectDataFn( 'a[ ]' );337			test = fn( {338				"a": [339					true,340					false,341					1342				]343			} );344		},345		function () { return test==="true false 1"; }346	);347	oTest.fnTest(348		"Flat array string join",349		function () {350			fn = table.oApi._fnGetObjectDataFn( 'a[qwerty]' );351			test = fn( {352				"a": [353					true,354					false,355					1356				]357			} );358		},359		function () { return test==="trueqwertyfalseqwerty1"; }360	);361	oTest.fnTest(362		"Flat array no join",363		function () {364			fn = table.oApi._fnGetObjectDataFn( 'a[]' );365			test = fn( {366				"a": [367					true,368					false,369					1370				]371			} );372		},373		function () { return test.length===3 && test[0]===true &&374			test[1]===false && test[2]===1; }375	);376	377	378	379	oTest.fnComplete();...

test-test-case.js

Source:test-test-case.js

...3var assert = require('assert');4var Sandbox = common.sandbox('test_case');5var TestCase = Sandbox.exports;6var testCase;7function test(fn) {8  testCase = new TestCase();9  fn();10}11test(function createFactory() {12  var testCase = TestCase.create(10);13  assert.strictEqual(testCase.testTimeout, 10);14});15test(function sugarAddTestFunction() {16  var sugarAddTest = testCase.sugarAddTest();17  Object18    .keys(TestCase.prototype)19    .concat(Object.keys(testCase))20    .forEach(function(property) {21      if (typeof testCase[property] !== 'function') {22        assert.strictEqual(sugarAddTest[property], testCase[property]);23        return;24      }25      var returns = 'the answer';26      var args = [1, 2, 3];27      testCase[property] = sinon.stub().returns(returns);28      var r = sugarAddTest[property].apply(null, args);29      assert.strictEqual(returns, r);30      assert.ok(testCase[property].calledOn(testCase));31      assert.ok(testCase[property].calledWith(1, 2, 3));32      assert.ok(testCase[property].callCount, 1);33    });34  var returns = 'another answer';35  var args = [1, 2];36  testCase.addTest = sinon.stub().returns(returns);37  var r = sugarAddTest.apply(null, args);38  assert.strictEqual(r, returns);39  assert.ok(testCase.addTest.calledOn(testCase));40  assert.ok(testCase.addTest.calledWith(1, 2));41  assert.ok(testCase.addTest.callCount, 1);42});43test(function addTestWithNameAndFn() {44  var testName = 'my test';45  var testFn = function() {};46  testCase.addTest(testName, testFn);47  assert.equal(testCase.tests.length, 1);48  assert.equal(testCase.tests[0].name, testName);49  assert.equal(testCase.tests[0].testFn, testFn);50  assert.equal(testCase.tests[0].timeout, null);51});52test(function addTestWithOptions() {53  var testName = 'my test';54  var testFn = function() {};55  var options = {foo: 'bar'};56  testCase.addTest(testName, options, testFn);57  assert.equal(testCase.tests[0].name, testName);58  assert.equal(testCase.tests[0].testFn, testFn);59  assert.equal(testCase.tests[0].foo, options.foo);60});61test(function addTestWithTestTimeout() {62  testCase.testTimeout = 20;63  var testName = 'my test';64  var testFn = function() {};65  testCase.addTest(testName, testFn);66  assert.equal(testCase.tests[0].timeout, 20);67});68test(function addTestWithTestTimeoutAndOptions() {69  testCase.testTimeout = 20;70  var testName = 'my test';71  var testFn = function() {};72  var testOptions = {};73  testCase.addTest(testName, testOptions, testFn);74  assert.equal(testCase.tests[0].timeout, 20);75});76test(function addTestWithTestTimeoutAndTimeoutOption() {77  testCase.testTimeout = 20;78  var testName = 'my test';79  var testFn = function() {};80  var testOptions = {timeout: 50};81  testCase.addTest(testName, testOptions, testFn);82  assert.equal(testCase.tests[0].timeout, 50);83});84test(function addTestCaseWithBeforeAndAfterFn() {85  var before = function() {};86  var after = function() {};87  testCase.before(before);88  testCase.after(after);89  var testName = 'my test';90  var testFn = function() {};91  testCase.addTest(testName, testFn);92  assert.strictEqual(testCase.tests[0].beforeFn, before);93  assert.strictEqual(testCase.tests[0].afterFn, after);94});95test(function runNoTestCases() {96  var runCb = sinon.spy();97  testCase.run(runCb);98  assert.ok(runCb.called);99  assert.ok(runCb.calledWith(null));100  assert.ok(testCase._started);101  assert.ok(testCase._ended);102});103test(function runOneSuccessTest() {104  var testInstance = {};105  testInstance.run = sinon.stub().yields(null);106  sinon.stub(testCase, 'selectedCount');107  testCase.tests.push(testInstance);108  var runCb = sinon.spy();109  testCase.run(runCb);110  assert.ok(runCb.calledWith(null));111});112test(function runOneErrorTest() {113  var err = new Error('something went wrong');114  var testInstance = {};115  testInstance.run = sinon.stub().yields(err);116  testCase.tests.push(testInstance);117  sinon.stub(testCase, 'selectedCount');118  var runCb = sinon.spy();119  testCase.run(runCb);120  assert.ok(runCb.calledWith([err]));121});122test(function runOneSuccessAndOneErrorTest() {123  var err = new Error('something went wrong');124  sinon.stub(testCase, 'selectedCount');125  var errorTest = {my: 'error test'};126  errorTest.run = sinon.stub().yields(err);127  testCase.tests.push(errorTest);128  var successTest = {my: 'success test'};129  successTest.run = sinon.stub().yields(null);130  testCase.tests.push(successTest);131  var emitTestEnd = sinon.spy();132  testCase.on('test.end', emitTestEnd);133  var runCb = sinon.spy();134  testCase.run(runCb);135  assert.ok(runCb.calledWith([err]));136  assert.ok(emitTestEnd.calledWith(errorTest));137  assert.ok(emitTestEnd.calledWith(successTest));138});139test(function runWithSelected() {140  testCase.tests = [141    {selected: sinon.stub().returns(false), run: sinon.stub().yields(null)},142    {selected: sinon.stub().returns(true), run: sinon.stub().yields(null)},143  ];144  var runCb = sinon.spy();145  testCase.run(runCb);146  assert.ok(runCb.calledWith(null));147  assert.equal(testCase.tests[0].run.called, false);148  assert.equal(testCase.tests[1].run.called, true);149  var stats = testCase.stats();150  assert.equal(stats.index, 2);151  assert.equal(stats.pass, 1);152  assert.equal(stats.skip, 1);153  assert.equal(stats.fail, 0);154  assert.equal(stats.total, 2);155});156test(function selectedCount() {157  testCase.tests = [158    {selected: sinon.stub().returns(false)},159    {selected: sinon.stub().returns(false)},160  ];161  assert.equal(testCase.selectedCount(), 0);162  testCase.tests.push({selected: sinon.stub().returns(true)});163  assert.equal(testCase.selectedCount(), 1);164});165test(function duration() {166  testCase._started = 20;167  testCase._ended = 30;168  assert.equal(testCase.duration(), 10);169});170test(function durationBeforeEnded() {171  testCase._started = +new Date;172  assert.ok(testCase.duration() >= 0);173  assert.ok(testCase.duration() < 10);174});175test(function statsNumbers() {176  testCase.tests = {length: 5};177  testCase.errors = {length: 3};178  testCase.index = 4;179  var stats = testCase.stats();180  assert.strictEqual(stats.pass, 1);181  assert.strictEqual(stats.fail, 3);182  assert.strictEqual(stats.index, testCase.index);183  assert.strictEqual(stats.total, 5);184});185test(function endWithoutCb() {186  testCase.end();187});188test(function endEmitsEvent() {189  var endCb = sinon.spy();190  testCase.on('end', endCb);191  testCase.end();192  assert.ok(endCb.called);...

read-blob-test-cases.js

Source:read-blob-test-cases.js

1var testCases = [2    "testReadingNonExistentFileBlob",3    "testReadingNonExistentFileBlob2",4    "testReadingEmptyFileBlob",5    "testReadingEmptyTextBlob",6    "testReadingEmptyFileAndTextBlob",7    "testReadingSingleFileBlob",8    "testReadingSingleTextBlob",9    "testReadingSingleTextBlobAsDataURL",10    "testReadingSingleTextBlobAsDataURL2",11    "testReadingSingleArrayBufferBlob",12    "testReadingSlicedFileBlob",13    "testReadingSlicedTextBlob",14    "testReadingSlicedArrayBufferBlob",15    "testReadingMultipleFileBlob",16    "testReadingMultipleTextBlob",17    "testReadingMultipleArrayBufferBlob",18    "testReadingHybridBlob",19    "testReadingSlicedHybridBlob",20    "testReadingTripleSlicedHybridBlob",21];22var testIndex = 0;23function runNextTest(testFiles)24{25    if (testIndex < testCases.length) {26        testIndex++;27        self[testCases[testIndex - 1]](testFiles);28    } else {29        log("DONE");30    }31}32function testReadingNonExistentFileBlob(testFiles)33{34    log("Test reading a blob containing non-existent file");35    var blob = buildBlob([testFiles['non-existent']]);36    readBlobAsBinaryString(testFiles, blob);37}38function testReadingNonExistentFileBlob2(testFiles)39{40    log("Test reading a blob containing existent and non-existent file");41    var blob = buildBlob([testFiles['file1'], testFiles['non-existent'], testFiles['empty-file']]);42    readBlobAsBinaryString(testFiles, blob);43}44function testReadingEmptyFileBlob(testFiles)45{46    log("Test reading a blob containing empty file");47    var blob = buildBlob([testFiles['empty-file']]);48    readBlobAsBinaryString(testFiles, blob);49}50function testReadingEmptyTextBlob(testFiles)51{52    log("Test reading a blob containing empty text");53    var blob = buildBlob(['']);54    readBlobAsBinaryString(testFiles, blob);55}56function testReadingEmptyFileAndTextBlob(testFiles)57{58    log("Test reading a blob containing empty files and empty texts");59    var blob = buildBlob(['', testFiles['empty-file'], '', testFiles['empty-file']]);60    readBlobAsBinaryString(testFiles, blob);61}62function testReadingSingleFileBlob(testFiles)63{64    log("Test reading a blob containing single file");65    var blob = buildBlob([testFiles['file1']]);66    readBlobAsBinaryString(testFiles, blob);67}68function testReadingSingleTextBlob(testFiles)69{70    log("Test reading a blob containing single text");71    var blob = buildBlob(['First']);72    readBlobAsBinaryString(testFiles, blob);73}74function testReadingSingleTextBlobAsDataURL(testFiles)75{76    log("Test reading a blob containing single text as data URL");77    var blob = buildBlob(['First']);78    readBlobAsDataURL(testFiles, blob);79}80function testReadingSingleTextBlobAsDataURL2(testFiles)81{82    log("Test reading a blob containing single text as data URL (optional content type provided)");83    var blob = buildBlob(['First'], 'type/foo');84    readBlobAsDataURL(testFiles, blob);85}86function testReadingSingleArrayBufferBlob(testFiles)87{88    log("Test reading a blob containing single ArrayBuffer");89    var array = new Uint8Array([0, 1, 2, 128, 129, 130, 253, 254, 255]);90    var blob = buildBlob([array.buffer]);91    readBlobAsBinaryString(testFiles, blob);92}93function testReadingSlicedFileBlob(testFiles)94{95    log("Test reading a blob containing sliced file");96    var blob = buildBlob([testFiles['file2'].webkitSlice(1, 6)]);97    readBlobAsBinaryString(testFiles, blob);98}99function testReadingSlicedTextBlob(testFiles)100{101    log("Test reading a blob containing sliced text");102    var blob = buildBlob(['First'])103    blob = blob.webkitSlice(1, 11);104    readBlobAsBinaryString(testFiles, blob);105}106function testReadingSlicedArrayBufferBlob(testFiles)107{108    log("Test reading a blob containing sliced ArrayBuffer");109    var array = new Uint8Array([0, 1, 2, 128, 129, 130, 253, 254, 255]);110    var blob = buildBlob([array.buffer])111    blob = blob.webkitSlice(1, 11);112    readBlobAsBinaryString(testFiles, blob);113}114function testReadingMultipleFileBlob(testFiles)115{116    log("Test reading a blob containing multiple files");117    var blob = buildBlob([testFiles['file1'], testFiles['file2'], testFiles['file3']]);118    readBlobAsBinaryString(testFiles, blob);119}120function testReadingMultipleTextBlob(testFiles)121{122    log("Test reading a blob containing multiple texts");123    var blob = buildBlob(['First', 'Second', 'Third']);124    readBlobAsBinaryString(testFiles, blob);125}126function testReadingMultipleArrayBufferBlob(testFiles)127{128    log("Test reading a blob containing multiple ArrayBuffer");129    var array1 = new Uint8Array([0, 1, 2]);130    var array2 = new Uint8Array([128, 129, 130]);131    var array3 = new Uint8Array([253, 254, 255]);132    var blob = buildBlob([array1.buffer, array2.buffer, array3.buffer]);133    readBlobAsBinaryString(testFiles, blob);134}135function testReadingHybridBlob(testFiles)136{137    log("Test reading a hybrid blob");138    var array = new Uint8Array([48, 49, 50]);139    var blob = buildBlob(['First', testFiles['file1'], 'Second', testFiles['file2'], testFiles['file3'], 'Third', array.buffer]);140    readBlobAsBinaryString(testFiles, blob);141}142function testReadingSlicedHybridBlob(testFiles)143{144    log("Test reading a sliced hybrid blob");145    var array = new Uint8Array([48, 49, 50]);146    var blob = buildBlob(['First', testFiles['file1'], 'Second', testFiles['file2'], testFiles['file3'], 'Third', array.buffer]);147    var blob = blob.webkitSlice(7, 19);148    readBlobAsBinaryString(testFiles, blob);149}150function testReadingTripleSlicedHybridBlob(testFiles)151{152    log("Test reading a triple-sliced hybrid blob");153    var builder = new WebKitBlobBuilder();154    var array = new Uint8Array([48, 49, 50]);155    var blob = buildBlob(['First', testFiles['file1'].webkitSlice(1, 11), testFiles['empty-file'], 'Second', testFiles['file2'], testFiles['file3'], 'Third', array.buffer], undefined, builder);156    var blob = blob.webkitSlice(7, 19);157    var blob2 = buildBlob(['Foo', blob, 'Bar'], undefined, builder);158    var blob2 = blob2.webkitSlice(12, 42);159    readBlobAsBinaryString(testFiles, blob2);...

read-file-test-cases.js

Source:read-file-test-cases.js

1var testCases = [2    "testReadingNonExistentFileAsArrayBuffer",3    "testReadingNonExistentFileAsBinaryString",4    "testReadingNonExistentFileAsText",5    "testReadingNonExistentFileAsDataURL",6    "testReadingEmptyFileAsArrayBuffer",7    "testReadingEmptyFileAsBinaryString",8    "testReadingEmptyFileAsText",9    "testReadingEmptyFileAsDataURL",10    "testReadingUTF8EncodedFileAsArrayBuffer",11    "testReadingUTF8EncodedFileAsBinaryString",12    "testReadingBinaryFileAsArrayBuffer",13    "testReadingBinaryFileAsBinaryString",14    "testReadingUTF8EncodedFileAsText",15    "testReadingUTF16BEBOMEncodedFileAsText",16    "testReadingUTF16LEBOMEncodedFileAsText",17    "testReadingUTF8BOMEncodedFileAsText",18    "testReadingUTF16BEEncodedFileAsTextWithUTF16Encoding",19    "testReadingUTF16BEBOMEncodedFileAsTextWithUTF8Encoding",20    "testReadingUTF16BEBOMEncodedFileAsTextWithInvalidEncoding",21    "testReadingUTF8EncodedFileAsDataURL",22    "testMultipleReads",23];24var testIndex = 0;25function runNextTest(testFiles)26{27    if (testIndex < testCases.length) {28        testIndex++;29        self[testCases[testIndex - 1]](testFiles);30    } else {31        log("DONE");32    }33}34function testReadingNonExistentFileAsArrayBuffer(testFiles)35{36    log("Test reading a non-existent file as array buffer");37    readBlobAsArrayBuffer(testFiles, testFiles['non-existent']);38}39function testReadingNonExistentFileAsBinaryString(testFiles)40{41    log("Test reading a non-existent file as binary string");42    readBlobAsBinaryString(testFiles, testFiles['non-existent']);43}44function testReadingNonExistentFileAsText(testFiles)45{46    log("Test reading a non-existent file as text");47    readBlobAsText(testFiles, testFiles['non-existent']);48}49function testReadingNonExistentFileAsDataURL(testFiles)50{51    log("Test reading a non-existent file as data URL");52    readBlobAsDataURL(testFiles, testFiles['non-existent']);53}54function testReadingEmptyFileAsArrayBuffer(testFiles)55{56    log("Test reading an empty file as array buffer");57    readBlobAsArrayBuffer(testFiles, testFiles['empty-file']);58}59function testReadingEmptyFileAsBinaryString(testFiles)60{61    log("Test reading an empty file as binary string");62    readBlobAsBinaryString(testFiles, testFiles['empty-file']);63}64function testReadingEmptyFileAsText(testFiles)65{66    log("Test reading an empty file as text");67    readBlobAsText(testFiles, testFiles['empty-file']);68}69function testReadingEmptyFileAsDataURL(testFiles)70{71    log("Test reading an empty file as data URL");72    readBlobAsDataURL(testFiles, testFiles['empty-file']);73}74function testReadingUTF8EncodedFileAsArrayBuffer(testFiles)75{76    log("Test reading a UTF-8 file as array buffer");77    readBlobAsArrayBuffer(testFiles, testFiles['UTF8-file']);78}79function testReadingUTF8EncodedFileAsBinaryString(testFiles)80{81    log("Test reading a UTF-8 file as binary string");82    readBlobAsBinaryString(testFiles, testFiles['UTF8-file']);83}84function testReadingBinaryFileAsArrayBuffer(testFiles)85{86    log("Test reading a binary file as array buffer");87    readBlobAsArrayBuffer(testFiles, testFiles['binary-file']);88}89function testReadingBinaryFileAsBinaryString(testFiles)90{91    log("Test reading a binary file as binary string");92    readBlobAsBinaryString(testFiles, testFiles['binary-file']);93}94function testReadingUTF8EncodedFileAsText(testFiles)95{96    log("Test reading a UTF-8 file as text");97    readBlobAsText(testFiles, testFiles['UTF8-file']);98}99function testReadingUTF16BEBOMEncodedFileAsText(testFiles)100{101    log("Test reading a UTF-16BE BOM file as text");102    readBlobAsText(testFiles, testFiles['UTF16BE-BOM-file']);103}104function testReadingUTF16LEBOMEncodedFileAsText(testFiles)105{106    log("Test reading a UTF-16LE BOM file as text");107    readBlobAsText(testFiles, testFiles['UTF16LE-BOM-file']);108}109function testReadingUTF8BOMEncodedFileAsText(testFiles)110{111    log("Test reading a UTF-8 BOM file as text");112    readBlobAsText(testFiles, testFiles['UTF8-BOM-file']);113}114function testReadingUTF16BEEncodedFileAsTextWithUTF16Encoding(testFiles)115{116    log("Test reading a UTF-16BE file as text with UTF-16BE encoding");117    readBlobAsText(testFiles, testFiles['UTF16BE-file'], "UTF-16BE");118}119function testReadingUTF16BEBOMEncodedFileAsTextWithUTF8Encoding(testFiles)120{121    log("Test reading a UTF-16BE BOM file as text with UTF8 encoding");122    readBlobAsText(testFiles, testFiles['UTF16BE-BOM-file'], "UTF-8");123}124function testReadingUTF16BEBOMEncodedFileAsTextWithInvalidEncoding(testFiles)125{126    log("Test reading a UTF-16BE BOM file as text with invalid encoding");127    readBlobAsText(testFiles, testFiles['UTF16BE-BOM-file'], "AnyInvalidEncoding");128}129function testReadingUTF8EncodedFileAsDataURL(testFiles)130{131    log("Test reading a UTF-8 file as data URL");132    readBlobAsDataURL(testFiles, testFiles['UTF8-file']);133}134function testMultipleReads(testFiles)135{136    // This test case is only available for async reading.137    if (!isReadAsAsync()) {138        runNextTest(testFiles);139        return;140    }141    log("Test calling multiple read methods and only last one is processed");142    var reader = createReaderAsync();143    reader.readAsArrayBuffer(testFiles['UTF8-file']);144    reader.readAsBinaryString(testFiles['UTF8-file']);145    reader.readAsText(testFiles['UTF8-file']);146    reader.readAsDataURL(testFiles['UTF8-file']);...

Using AI Code Generation

1import { test } from 'ts-auto-mock';2test('test1', () => {3    expect(true).toBe(true);4});5test('test2', () => {6    expect(true).toBe(true);7});8test('test3', () => {9    expect(true).toBe(true);10});11test('test4', () => {12    expect(true).toBe(true);13});14test('test5', () => {15    expect(true).toBe(true);16});17test('test6', () => {18    expect(true).toBe(true);19});20test('test7', () => {21    expect(true).toBe(true);22});23test('test8', () => {24    expect(true).toBe(true);25});26test('test9', () => {27    expect(true).toBe(true);28});29test('test10', () => {30    expect(true).toBe(true);31});32test('test11', () => {33    expect(true).toBe(true);34});35test('test12', () => {36    expect(true).toBe(true);37});38test('test13', () => {39    expect(true).toBe(true);40});41test('test14', () => {42    expect(true).toBe(true);43});44test('test15', () => {45    expect(true).toBe(true);46});47test('test16', () =>

Using AI Code Generation

1import {test} from 'ts-auto-mock';2test('test', () => {3});4import {test} from 'ts-auto-mock';5test('test', () => {6});7import {test} from 'ts-auto-mock';8test('test', () => {9});10import {test} from 'ts-auto-mock';11test('test', () => {12});13import {test} from 'ts-auto-mock';14test('test', () => {15});16import {test} from 'ts-auto-mock';17test('test', () => {18});19import {test} from 'ts-auto-mock';20test('test', () => {21});22import {test} from 'ts-auto-mock';23test('test', () => {24});25import {test} from 'ts-auto-mock';26test('test', () => {27});28import {test} from 'ts-auto-mock';29test('test', () => {30});31import {test} from 'ts-auto-mock';32test('test', () => {

Using AI Code Generation

1import {test} from 'ts-auto-mock';2import {myFunction} from './myFunction';3describe('myFunction', () => {4    it('should return the correct value', () => {5        const result = myFunction(test('string'), test('number'), test('boolean'));6        expect(result).toEqual('string');7    });8});9export function myFunction(str, num, bool) {10    return str;11}12{13    "compilerOptions": {14    },15}16{17  "scripts": {18  },19  "devDependencies": {20  }21}22    at Object.getMockName (node_modules/ts-auto-mock/dist/getMockName

Using AI Code Generation

1describe('test1', () => {2    it('test1', () => {3        const test = createMock<Test>();4        expect(test.test()).toEqual('test');5    });6});7describe('test2', () => {8    it('test2', () => {9        const test = createMock<Test>();10        expect(test.test()).toEqual('test');11    });12});13export function createMock<T>(name?: string, properties?: Properties): T {14  const mock: T = {} as T;15  if (name) {16    mock[Symbol.for('name')] = name;17  }18  if (properties) {19    Object.keys(properties).forEach((property) => {20      const value = properties[property];21      if (value) {22        mock[Symbol.for(property)] = value;23      }24    });25  }26  return mock;27}28I have also tried to create a new project from scratch and I have the same problem. I have tried to create the mock in the test1.js file and then to import it in the test2.js file. This is also not working. I have no idea why

Using AI Code Generation

1import { testMethod } from 'ts-auto-mock';2describe('testMethod', () => {3  it('should return the same value', () => {4    const value = 'test';5    expect(testMethod(value)).toEqual(value);6  });7});8import { testMethod } from 'ts-auto-mock';9describe('testMethod', () => {10  it('should return the same value', () => {11    const value = 'test';12    expect(testMethod(value)).toEqual(value);13  });14});15import { testMethod } from 'ts-auto-mock';16describe('testMethod', () => {17  it('should return the same value', () => {18    const value = 'test';19    expect(testMethod(value)).toEqual(value);20  });21});22import { testMethod } from 'ts-auto-mock';23describe('testMethod', () => {24  it('should return the same value', () => {25    const value = 'test';26    expect(testMethod(value)).toEqual(value);27  });28});29import { testMethod } from 'ts-auto-mock';30describe('testMethod', () => {31  it('should return the same value', () => {32    const value = 'test';33    expect(testMethod(value)).toEqual(value);34  });35});36import { testMethod } from 'ts-auto-mock';37describe('testMethod', () => {38  it('should return the same value', () => {39    const value = 'test';40    expect(testMethod(value)).toEqual(value);41  });42});43import { testMethod } from

Using AI Code Generation

1import {test} from 'ts-auto-mock';2test('test1', () => {3  const mock: string = 'mocked';4  expect(mock).toBe('mocked');5});6import {test} from 'ts-auto-mock';7test('test2', () => {8  const mock: string = 'mocked';9  expect(mock).toBe('mocked');10});11import {test} from 'ts-auto-mock';12test('test3', () => {13  const mock: string = 'mocked';14  expect(mock).toBe('mocked');15});16import {test} from 'ts-auto-mock';17test('test4', () => {18  const mock: string = 'mocked';19  expect(mock).toBe('mocked');20});21import {test} from 'ts-auto-mock';22test('test5', () => {23  const mock: string = 'mocked';24  expect(mock).toBe('mocked');25});26import {test} from 'ts-auto-mock';27test('test6', () => {28  const mock: string = 'mocked';29  expect(mock).toBe('mocked');30});31import {test} from 'ts-auto-mock';32test('test7', () => {33  const mock: string = 'mocked';34  expect(mock).toBe('mocked');35});36import {test} from 'ts-auto-mock';37test('test8', () => {38  const mock: string = 'mocked';39  expect(mock).toBe('mocked');40});41import {test} from 'ts-auto-mock';42test('test9', () => {43  const mock: string = 'mocked';44  expect(mock).toBe

Using AI Code Generation

1import { createMock } from 'ts-auto-mock';2import { Test } from './test';3const test: Test = createMock<Test>();4export class Test {5  public test(): void {6    console.log('Hello world');7  }8}

Using AI Code Generation

1import {test} from 'ts-auto-mock';2const mock = test('test1');3import {test} from 'ts-auto-mock';4const mock = test('test2');5I have tried using the following import statements:6import {test} from 'ts-auto-mock';7import {test} from 'ts-auto-mock/dist';8import {test} from 'ts-auto-mock/dist/index';9import {test} from 'ts-auto-mock/dist/index.js';10import {test} from 'ts-auto-mock/dist/index.ts';11import {test} from 'ts-auto-mock/dist/index.d.ts';12import {test} from 'ts-auto-mock/dist/index.d.ts';13I have also tried using the following import statements:14import {test} from 'ts-auto-mock';15import {test} from 'ts-auto-mock/dist';16import {test} from 'ts-auto-mock/dist/index';17import {test} from 'ts-auto-mock/dist/index.js';18import {test} from 'ts-auto-mock/dist/index.ts';19import {test} from 'ts-auto-mock/dist/index.d.ts';20import {test} from 'ts-auto-mock/dist/index.d.ts';21I have also tried using the following import statements:22import {test} from 'ts-auto-mock';23import {test} from 'ts-auto-mock/dist';24import {test} from 'ts-auto-mock/dist/index';25import {test} from 'ts-auto-mock/dist/index.js';26import {test} from 'ts-auto-mock/dist/index.ts';27import {test} from 'ts-auto-mock/dist/index.d.ts';28import {test} from 'ts-auto-mock/dist/index.d.ts';29I have also tried using the following import statements:30import {test} from 'ts-auto-mock';31import {test} from 'ts-auto-mock/dist';32import {test} from 'ts-auto-mock/dist/index';33import {test} from 'ts-auto-mock/dist/index.js';34import {test} from 'ts-auto-mock/dist/index.ts';35import {

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.