var lem = new Lemmatizer();

QUnit.test( 'JavaScript Lemmatizer QUnit Tests', function( assert ) {
  assert.deepEqual( lem.lemmas('analyses', 'noun'), [ ["analysis", "noun"] ] );

  // Lemmatizer leaves alone words that its dictionary does not contain.
  assert.deepEqual( lem.lemmas('MacBooks', 'noun'), [ ['MacBooks', 'noun'] ] );

  // Lemmatize a word with a part of speech (pos).
  assert.deepEqual( lem.lemmas('desks', 'noun'), [ ['desk', 'noun'] ] );
  assert.deepEqual( lem.lemmas('hired', 'verb'), [ ['hire', 'verb'] ] );
  assert.deepEqual( lem.lemmas('worried', 'verb'), [ ['worry', 'verb'] ]);
  assert.deepEqual( lem.lemmas('partying', 'verb'), [ ['party', 'verb'] ]);
  assert.deepEqual( lem.lemmas('better', 'adj'),  [ ['better', 'adj'], ['good', 'adj'] ] );
  assert.deepEqual( lem.lemmas('hotter', 'adj'),  [ ['hot', 'adj'] ]  );
  assert.deepEqual( lem.lemmas('best', 'adv'),  [ ['best', 'adv'], ['well', 'adv'] ] );
  assert.deepEqual( lem.lemmas('best', 'adj'),  [ ['best', 'adj'], ['good', 'adj'] ] );
  
  // Lemmatizer give a result even when no pos is given, by assuming it to be :verb, :noun, :adv, or :adj.
  assert.deepEqual( lem.lemmas('plays'), [ ['play', 'verb'], ['play', 'noun'] ] );
  assert.deepEqual( lem.lemmas('oxen'), [ ['oxen', 'noun'], ['ox', 'noun'] ] );
  assert.deepEqual( lem.lemmas('fired'), [ ['fire', 'verb'], ['fired', 'adj'] ] );
  assert.deepEqual( lem.lemmas('slower'), [ ['slower', 'adv'], ['slow', 'adv'], ['slow', 'adj'] ] );

  // non-existing word
  assert.deepEqual( lem.lemmas('asdfassda'), [ ['asdfassda', ''] ] );

  // various test with pos
  assert.deepEqual( lem.lemmas('goes', 'verb'), [ ['go', 'verb'] ] );
  assert.deepEqual( lem.lemmas('went', 'verb'), [ ['go', 'verb'] ] );
  assert.deepEqual( lem.lemmas('gone', 'verb'), [ ['go', 'verb'] ] );
  assert.deepEqual( lem.lemmas('writes', 'verb'), [ ['write', 'verb'] ] );
  assert.deepEqual( lem.lemmas('wrote', 'verb'), [ ['write', 'verb'] ] );
  assert.deepEqual( lem.lemmas('written', 'verb'), [ ['write', 'verb'] ] );
  assert.deepEqual( lem.lemmas('confirms', 'verb'), [ ['confirm', 'verb'] ] );
  assert.deepEqual( lem.lemmas('confirmed', 'verb'), [ ['confirm', 'verb'] ] );
  assert.deepEqual( lem.lemmas('confirming', 'verb'), [ ['confirm', 'verb'] ] );
  assert.deepEqual( lem.lemmas('acidless', 'noun'), [ ['acidless', 'noun'] ] );
  assert.deepEqual( lem.lemmas('pizzas', 'noun'), [ ['pizza', 'noun'] ] );
  assert.deepEqual( lem.lemmas('foxes', 'noun'), [ ['fox', 'noun'] ] );
  assert.deepEqual( lem.lemmas('hacked', 'verb'), [ ['hack', 'verb'] ] );
  assert.deepEqual( lem.lemmas('coded', 'verb'), [ ['code', 'verb'] ] );
  assert.deepEqual( lem.lemmas('fitting', 'verb'), [ ['fit', 'verb'] ] );
  assert.deepEqual( lem.lemmas('coding', 'verb'), [ ['code', 'verb'] ] );
  assert.deepEqual( lem.lemmas('pirouetting', 'verb'), [ ['pirouette', 'verb'] ] );
  assert.deepEqual( lem.lemmas('hacking', 'verb'), [ ['hack', 'verb'] ] );
  assert.deepEqual( lem.lemmas('earliest', 'adj'), [ ['earliest', 'adj'], ['early', 'adj'] ] );
  assert.deepEqual( lem.lemmas('biggest', 'adj'), [ ['big', 'adj'] ] );
  assert.deepEqual( lem.lemmas('largest', 'adj'), [ ['large', 'adj'] ] );
  assert.deepEqual( lem.lemmas('smallest', 'adj'), [ ['small', 'adj'] ] );
  assert.deepEqual( lem.lemmas('earlier', 'adj'), [ ['earlier', 'adj'], ['early', 'adj'] ] );
  assert.deepEqual( lem.lemmas('bigger', 'adj'), [ ['bigger', 'adj'], ['big', 'adj'] ] );
  assert.deepEqual( lem.lemmas('larger', 'adj'), [ ['larger', 'adj'], ['large', 'adj'] ] );
  assert.deepEqual( lem.lemmas('smaller', 'adj'), [ ['smaller', 'adj'], ['small', 'adj'] ] );
  assert.deepEqual( lem.lemmas('recognizable', 'adj'), [ ['recognizable', 'adj'] ] );
  assert.deepEqual( lem.lemmas('networkable', 'adj'), [ ['networkable', 'adj'] ] );
  assert.deepEqual( lem.lemmas('resettability', 'noun'), [ ['resettability', 'noun'] ] );
  assert.deepEqual( lem.lemmas('repairability', 'noun'), [ ['repairability', 'noun'] ] );
  assert.deepEqual( lem.lemmas('reorganizability', 'noun'), [ ['reorganizability', 'noun'] ] );
  assert.deepEqual( lem.lemmas('starts', 'verb'), [ ['start', 'verb'] ] );
  assert.deepEqual( lem.lemmas('teaches', 'verb'), [ ['teach', 'verb'] ] );
  assert.deepEqual( lem.lemmas('talked', 'verb'), [ ['talk', 'verb'] ] );
  assert.deepEqual( lem.lemmas('saved', 'verb'), [ ['save', 'verb'] ] );
  assert.deepEqual( lem.lemmas('sitting', 'verb'), [ ['sit', 'verb'] ] );
  assert.deepEqual( lem.lemmas('having', 'verb'), [ ['have', 'verb'] ] );
  assert.deepEqual( lem.lemmas('talking', 'verb'), [ ['talk', 'verb'] ] );
  assert.deepEqual( lem.lemmas('heavier', 'adj'), [ ['heavy', 'adj'] ] );
  assert.deepEqual( lem.lemmas('bigger', 'adj'), [ ['bigger', 'adj'], ['big', 'adj'] ] );
  assert.deepEqual( lem.lemmas('huger', 'adj'), [ ['huge', 'adj'] ] );
  assert.deepEqual( lem.lemmas('lower', 'adj'), [ ['low', 'adj'] ] );
  assert.deepEqual( lem.lemmas('writable', 'adj'), [ ['writable', 'adj'] ] );
  assert.deepEqual( lem.lemmas('readable', 'adj'), [ ['readable', 'adj'] ] );
  assert.deepEqual( lem.lemmas('readability', 'noun'), [ ['readability', 'noun'] ] );
  assert.deepEqual( lem.lemmas('writability', 'noun'), [ ['writability', 'noun'] ] );
  assert.deepEqual( lem.lemmas('scoreless', 'noun'), [ ['scoreless', 'noun'] ] );
  assert.deepEqual( lem.lemmas('dogs', 'noun'), [ ['dog', 'noun'] ] );
  assert.deepEqual( lem.lemmas('dishes', 'noun'), [ ['dish', 'noun'] ] );
  assert.deepEqual( lem.lemmas('heaviest', 'adj'), [ ['heavy', 'adj'] ] );
  assert.deepEqual( lem.lemmas('biggest', 'adj'), [ ['big', 'adj'] ] );
  assert.deepEqual( lem.lemmas('hugest', 'adj'), [ ['huge', 'adj'] ] );
  assert.deepEqual( lem.lemmas('lowest', 'adj'), [ ['lowest', 'adj'], ['low', 'adj'] ] );
  assert.deepEqual( lem.lemmas('heavier', 'adj'), [ ['heavy', 'adj'] ] );
  assert.deepEqual( lem.lemmas('bigger', 'adj'), [ ['bigger', 'adj'], ['big', 'adj'] ] );
  assert.deepEqual( lem.lemmas('lower', 'adj'), [ ['low', 'adj'] ] );
  assert.deepEqual( lem.lemmas('higher', 'adj'), [ ['higher', 'adj'], ['high', 'adj'] ] );
  assert.deepEqual( lem.lemmas('leaves', 'noun'), [ ['leave', 'noun'], ['leaf', 'noun'] ] );
  assert.deepEqual( lem.lemmas('player', 'noun'), [ ['player', 'noun'] ] );
  assert.deepEqual( lem.lemmas('priorities', 'noun'), [ ['priority', 'noun'] ] );
  assert.deepEqual( lem.lemmas('matter', 'verb'), [ ['matter', 'verb'] ] );
  assert.deepEqual( lem.lemmas('matter', 'noun'), [ ['matter', 'noun'] ] );
  assert.deepEqual( lem.lemmas('matter', 'adj'), [ ['matte', 'adj'], ['matt', 'adj'], ['mat', 'adj'] ] );
  assert.deepEqual( lem.lemmas('added', 'verb'), [ ['add', 'verb'] ] );
  assert.deepEqual( lem.lemmas('opposes', 'verb'), [ ['oppose', 'verb' ] ] );
  assert.deepEqual( lem.lemmas('singing', 'verb'), [ ['sing', 'verb' ] ] );
  assert.deepEqual( lem.lemmas('dying', 'verb'), [ ['die', 'verb' ] ] );
  assert.deepEqual( lem.lemmas('after', 'adv'), [ ['after', 'adv' ], ['aft', 'adv' ] ] );
  assert.deepEqual( lem.lemmas('us', 'noun'), [ ['us', 'noun' ] ] );

  // various test without pos
  assert.deepEqual( lem.lemmas('goes'), [ ['go', 'verb'], ['go', 'noun'] ] );
  assert.deepEqual( lem.lemmas('went'), [ ['go', 'verb'] ] );
  assert.deepEqual( lem.lemmas('gone'), [ ['go', 'verb'], ['gone', 'adj'] ] );
  assert.deepEqual( lem.lemmas('writes'), [ ['write', 'verb'] ] );
  assert.deepEqual( lem.lemmas('wrote'), [ ['write', 'verb'] ] );
  assert.deepEqual( lem.lemmas('written'), [ ['write', 'verb'], ['written', 'adj'] ] );
  assert.deepEqual( lem.lemmas('confirms'), [ ['confirm', 'verb'] ] );
  assert.deepEqual( lem.lemmas('confirmed'), [ ['confirm', 'verb'], ['confirmed', 'adj'] ] );
  assert.deepEqual( lem.lemmas('confirming'), [ ['confirm', 'verb'], ['confirming', 'adj'] ] );
  assert.deepEqual( lem.lemmas('acidless'), [ ['acidless', ''] ] );
  assert.deepEqual( lem.lemmas('pizzas'), [ ['pizza', 'noun'] ] );
  assert.deepEqual( lem.lemmas('foxes'), [ ['fox', 'verb'], ['fox', 'noun'] ] );
  assert.deepEqual( lem.lemmas('hacked'), [ ['hack', 'verb'] ] );
  assert.deepEqual( lem.lemmas('coded'), [ ['code', 'verb'] ] );
  assert.deepEqual( lem.lemmas('fitting'), [ ['fit', 'verb'], ['fitting', 'noun'], ['fitting', 'adj'] ] );
  assert.deepEqual( lem.lemmas('coding'), [ ['code', 'verb'], ['coding', 'noun'] ] );
  assert.deepEqual( lem.lemmas('pirouetting'), [ ['pirouette', 'verb'] ] );
  assert.deepEqual( lem.lemmas('hacking'), [ ['hack', 'verb'] ] );
  assert.deepEqual( lem.lemmas('earliest'), [ ['earliest', 'adv'], ['early', 'adv'], ['earliest', 'adj'], ['early', 'adj'] ] );
  assert.deepEqual( lem.lemmas('biggest'), [ ['big', 'adv'], ['big', 'adj'] ] );
  assert.deepEqual( lem.lemmas('largest'), [ ['large', 'adv'], ['large', 'adj'] ] );
  assert.deepEqual( lem.lemmas('smallest'), [ ['small', 'adv'], ['small', 'adj'] ] );
  assert.deepEqual( lem.lemmas('earlier'), [ ['earlier', 'adv'], ['early', 'adv'], ['earlier', 'adj'], ['early', 'adj'] ] );
  assert.deepEqual( lem.lemmas('bigger'), [ ['big', 'adv'], ['bigger', 'adj'], ['big', 'adj'] ] );
  assert.deepEqual( lem.lemmas('larger'), [ ['large', 'adv'], ['larger', 'adj'], ['large', 'adj'] ] );
  assert.deepEqual( lem.lemmas('smaller'), [ ['small', 'adv'], ['smaller', 'adj'], ['small', 'adj'] ] );
  assert.deepEqual( lem.lemmas('recognizable'), [ ['recognize', 'verb'], ['recognizable', 'adj'] ] );
  assert.deepEqual( lem.lemmas('networkable'), [ ['network', 'verb'] ] );
  assert.deepEqual( lem.lemmas('resettability'), [ ['reset', 'verb'] ] );
  assert.deepEqual( lem.lemmas('repairability'), [ ['repair', 'verb'] ] );
  assert.deepEqual( lem.lemmas('reorganizability'), [ ['reorganize', 'verb'] ] );
  assert.deepEqual( lem.lemmas('starts'), [ ['start', 'verb'], ['start', 'noun'] ] );
  assert.deepEqual( lem.lemmas('teaches'), [ ['teach', 'verb'], ['teach', 'noun'] ] );
  assert.deepEqual( lem.lemmas('talked'), [ ['talk', 'verb'] ] );
  assert.deepEqual( lem.lemmas('saved'), [ ['save', 'verb'], ['saved', 'adj'] ] );
  assert.deepEqual( lem.lemmas('sitting'), [ ['sit', 'verb'], ['sitting', 'noun'], ['sitting', 'adj'] ] );
  assert.deepEqual( lem.lemmas('having'), [ ['have', 'verb'] ] );
  assert.deepEqual( lem.lemmas('talking'), [ ['talk', 'verb'], ['talking', 'noun'] ] );
  assert.deepEqual( lem.lemmas('heavier'), [ ['heavy', 'adv'], ['heavy', 'adj'] ] );
  assert.deepEqual( lem.lemmas('bigger'), [ ['big', 'adv'], ['bigger', 'adj'], ['big', 'adj'] ] );
  assert.deepEqual( lem.lemmas('huger'), [ ['huge', 'adj'] ] );
  assert.deepEqual( lem.lemmas('lower'), [ ['lower', 'verb'], ['lower', 'noun'], ['low', 'adv'], ['low', 'adj'] ] );
  assert.deepEqual( lem.lemmas('writable'), [ ['write', 'verb'] ] );
  assert.deepEqual( lem.lemmas('readable'), [ ['read', 'verb'], ['readable', 'adj'] ] );
  assert.deepEqual( lem.lemmas('resettable'), [ ['reset', 'verb'] ] );
  assert.deepEqual( lem.lemmas('readability'), [ ['read', 'verb'], ['readability', 'noun'] ] );
  assert.deepEqual( lem.lemmas('writability'), [ ['write', 'verb'] ] );
  assert.deepEqual( lem.lemmas('scoreless'), [ ['scoreless', 'adj'] ] );
  assert.deepEqual( lem.lemmas('dogs'), [ ['dog', 'verb'], ['dog', 'noun'] ] );
  assert.deepEqual( lem.lemmas('dishes'), [ ['dish', 'verb'], ['dish', 'noun'] ] );
  assert.deepEqual( lem.lemmas('heaviest'), [ ['heavy', 'adv'], ['heavy', 'adj'] ] );
  assert.deepEqual( lem.lemmas('biggest'), [ ['big', 'adv'], ['big', 'adj'] ] );
  assert.deepEqual( lem.lemmas('hugest'), [ ['huge', 'adj'] ] );
  assert.deepEqual( lem.lemmas('lowest'), [ ['lowest', 'adv'], ['low', 'adv'], ['lowest', 'adj'], ['low', 'adj'] ] );
  assert.deepEqual( lem.lemmas('heavier'), [ ['heavy', 'adv'], ['heavy', 'adj'] ] );
  assert.deepEqual( lem.lemmas('bigger'), [ ['big', 'adv'], ['bigger', 'adj'], ['big', 'adj'] ] );
  assert.deepEqual( lem.lemmas('lower'), [ ['lower', 'verb'], ['lower', 'noun'], ['low', 'adv'], ['low', 'adj'] ] );
  assert.deepEqual( lem.lemmas('higher'), [ ['high', 'adv'], ['higher', 'adj'], ['high', 'adj'] ] );
  assert.deepEqual( lem.lemmas('leaves'), [ ['leave', 'verb'], ['leave', 'noun'], ['leaf', 'noun'] ] );
  assert.deepEqual( lem.lemmas('player'), [ ['player', 'noun'] ] );
  assert.deepEqual( lem.lemmas('priorities'), [ ['priority', 'noun'] ] );
  assert.deepEqual( lem.lemmas('matter'), [ ['matter', 'verb'], ['matter', 'noun'], ['matte', 'adj'], ['matt', 'adj'], ['mat', 'adj'] ] );
  assert.deepEqual( lem.lemmas('added'), [ ['add', 'verb'] ] );
  assert.deepEqual( lem.lemmas('opposes'), [ ['oppose', 'verb' ] ] );
  assert.deepEqual( lem.lemmas('singing'), [ ['sing', 'verb'], ['singing', 'noun'], ['singing', 'adj'] ] );
  assert.deepEqual( lem.lemmas('dying'), [ ['die', 'verb'], ['dying', 'noun'], ['dying', 'adj'] ] );
  assert.deepEqual( lem.lemmas('after'), [ ['after', 'adv' ], ['aft', 'adv'], ['after', 'adj' ], ['aft', 'adj'] ] );
  assert.deepEqual( lem.lemmas('us'), [ ['us', 'noun' ] ] );

  // **************************************************
  // only_lemmas tests
  // **************************************************
  assert.deepEqual( lem.only_lemmas('analyses', 'noun'), [ 'analysis' ] );

  // Lemmatizer leaves alone words that its dictionary does not contain.
  assert.deepEqual( lem.only_lemmas('MacBooks', 'noun'), [ 'MacBooks' ] );

  // Lemmatize a word with a part of speech (pos).
  assert.deepEqual( lem.only_lemmas('desks', 'noun'), [ 'desk' ] );
  assert.deepEqual( lem.only_lemmas('hired', 'verb'), [ 'hire' ] );
  assert.deepEqual( lem.only_lemmas('worried', 'verb'), [ 'worry' ]);
  assert.deepEqual( lem.only_lemmas('partying', 'verb'), [ 'party' ]);
  assert.deepEqual( lem.only_lemmas('better', 'adj'), ['better', 'good'] );
  assert.deepEqual( lem.only_lemmas('hotter', 'adj'), ['hot']  );
  assert.deepEqual( lem.only_lemmas('best', 'adv'), ['best', 'well'] );
  assert.deepEqual( lem.only_lemmas('best', 'adj'), ['best', 'good'] );
  
  // Lemmatizer give a result even when no pos is given, by assuming it to be :verb, :noun, :adv, or :adj.
  assert.deepEqual( lem.only_lemmas('plays'), [ 'play' ] );
  assert.deepEqual( lem.only_lemmas('oxen'), [ 'oxen', 'ox' ] );
  assert.deepEqual( lem.only_lemmas('fired'), [ 'fire', 'fired' ] );
  assert.deepEqual( lem.only_lemmas('slower'), [ 'slower', 'slow' ] );

  // non-existing word
  assert.deepEqual( lem.only_lemmas('asdfassda'), [ 'asdfassda' ] );

  // various test with pos
  assert.deepEqual( lem.only_lemmas('goes', 'verb'), [ 'go' ] );
  assert.deepEqual( lem.only_lemmas('went', 'verb'), [ 'go' ] );
  assert.deepEqual( lem.only_lemmas('gone', 'verb'), [ 'go' ] );
  assert.deepEqual( lem.only_lemmas('writes', 'verb'), [ 'write' ] );
  assert.deepEqual( lem.only_lemmas('wrote', 'verb'), [ 'write' ] );
  assert.deepEqual( lem.only_lemmas('written', 'verb'), [ 'write' ] );
  assert.deepEqual( lem.only_lemmas('confirms', 'verb'), [ 'confirm' ] );
  assert.deepEqual( lem.only_lemmas('confirmed', 'verb'), [ 'confirm' ] );
  assert.deepEqual( lem.only_lemmas('confirming', 'verb'), [ 'confirm' ] );
  assert.deepEqual( lem.only_lemmas('acidless', 'noun'), [ 'acidless' ] );
  assert.deepEqual( lem.only_lemmas('pizzas', 'noun'), [ 'pizza' ] );
  assert.deepEqual( lem.only_lemmas('foxes', 'noun'), [ 'fox' ] );
  assert.deepEqual( lem.only_lemmas('hacked', 'verb'), [ 'hack' ] );
  assert.deepEqual( lem.only_lemmas('coded', 'verb'), [ 'code' ] );
  assert.deepEqual( lem.only_lemmas('fitting', 'verb'), [ 'fit' ] );
  assert.deepEqual( lem.only_lemmas('coding', 'verb'), [ 'code' ] );
  assert.deepEqual( lem.only_lemmas('pirouetting', 'verb'), [ 'pirouette' ] );
  assert.deepEqual( lem.only_lemmas('hacking', 'verb'), [ 'hack' ] );
  assert.deepEqual( lem.only_lemmas('earliest', 'adj'), [ 'earliest', 'early' ] );
  assert.deepEqual( lem.only_lemmas('biggest', 'adj'), [ 'big' ] );
  assert.deepEqual( lem.only_lemmas('largest', 'adj'), [ 'large' ] );
  assert.deepEqual( lem.only_lemmas('smallest', 'adj'), [ 'small' ] );
  assert.deepEqual( lem.only_lemmas('earlier', 'adj'), [ 'earlier', 'early' ] );
  assert.deepEqual( lem.only_lemmas('bigger', 'adj'), [ 'bigger', 'big' ] );
  assert.deepEqual( lem.only_lemmas('larger', 'adj'), [ 'larger', 'large' ] );
  assert.deepEqual( lem.only_lemmas('smaller', 'adj'), [ 'smaller', 'small' ] );
  assert.deepEqual( lem.only_lemmas('recognizable', 'adj'), [ 'recognizable' ] );
  assert.deepEqual( lem.only_lemmas('networkable', 'adj'), [ 'networkable' ] );
  assert.deepEqual( lem.only_lemmas('resettability', 'noun'), [ 'resettability' ] );
  assert.deepEqual( lem.only_lemmas('repairability', 'noun'), [ 'repairability' ] );
  assert.deepEqual( lem.only_lemmas('reorganizability', 'noun'), [ 'reorganizability' ] );
  assert.deepEqual( lem.only_lemmas('starts', 'verb'), [ 'start' ] );
  assert.deepEqual( lem.only_lemmas('teaches', 'verb'), [ 'teach' ] );
  assert.deepEqual( lem.only_lemmas('talked', 'verb'), [ 'talk' ] );
  assert.deepEqual( lem.only_lemmas('saved', 'verb'), [ 'save' ] );
  assert.deepEqual( lem.only_lemmas('sitting', 'verb'), [ 'sit' ] );
  assert.deepEqual( lem.only_lemmas('having', 'verb'), [ 'have' ] );
  assert.deepEqual( lem.only_lemmas('talking', 'verb'), [ 'talk' ] );
  assert.deepEqual( lem.only_lemmas('heavier', 'adj'), [ 'heavy' ] );
  assert.deepEqual( lem.only_lemmas('bigger', 'adj'), [ 'bigger', 'big' ] );
  assert.deepEqual( lem.only_lemmas('huger', 'adj'), [ 'huge' ] );
  assert.deepEqual( lem.only_lemmas('lower', 'adj'), [ 'low' ] );
  assert.deepEqual( lem.only_lemmas('writable', 'adj'), [ 'writable' ] );
  assert.deepEqual( lem.only_lemmas('readable', 'adj'), [ 'readable' ] );
  assert.deepEqual( lem.only_lemmas('readability', 'noun'), [ 'readability' ] );
  assert.deepEqual( lem.only_lemmas('writability', 'noun'), [ 'writability' ] );
  assert.deepEqual( lem.only_lemmas('scoreless', 'noun'), [ 'scoreless' ] );
  assert.deepEqual( lem.only_lemmas('dogs', 'noun'), [ 'dog' ] );
  assert.deepEqual( lem.only_lemmas('dishes', 'noun'), [ 'dish' ] );
  assert.deepEqual( lem.only_lemmas('heaviest', 'adj'), [ 'heavy' ] );
  assert.deepEqual( lem.only_lemmas('biggest', 'adj'), [ 'big' ] );
  assert.deepEqual( lem.only_lemmas('hugest', 'adj'), [ 'huge' ] );
  assert.deepEqual( lem.only_lemmas('lowest', 'adj'), [ 'lowest', 'low' ] );
  assert.deepEqual( lem.only_lemmas('heavier', 'adj'), [ 'heavy' ] );
  assert.deepEqual( lem.only_lemmas('bigger', 'adj'), [ 'bigger', 'big' ] );
  assert.deepEqual( lem.only_lemmas('lower', 'adj'), [ 'low' ] );
  assert.deepEqual( lem.only_lemmas('higher', 'adj'), [ 'higher', 'high' ] );
  assert.deepEqual( lem.only_lemmas('leaves', 'noun'), [ 'leave', 'leaf' ] );
  assert.deepEqual( lem.only_lemmas('player', 'noun'), [ 'player' ] );
  assert.deepEqual( lem.only_lemmas('priorities', 'noun'), [ 'priority' ] );
  assert.deepEqual( lem.only_lemmas('matter', 'verb'), [ 'matter' ] );
  assert.deepEqual( lem.only_lemmas('matter', 'noun'), [ 'matter' ] );
  assert.deepEqual( lem.only_lemmas('matter', 'adj'), [ 'matte', 'matt', 'mat' ] );
  assert.deepEqual( lem.only_lemmas('added', 'verb'), [ 'add' ] );
  assert.deepEqual( lem.only_lemmas('opposes', 'verb'), [ 'oppose' ] );
  assert.deepEqual( lem.only_lemmas('singing', 'verb'), [ 'sing' ] );
  assert.deepEqual( lem.only_lemmas('dying', 'verb'), [ 'die' ] );
  assert.deepEqual( lem.only_lemmas('after', 'adv'), [ 'after', 'aft' ] );
  assert.deepEqual( lem.only_lemmas('us', 'noun'), [ 'us' ] );

  // various test without pos
  assert.deepEqual( lem.only_lemmas('goes'), [ 'go' ] );
  assert.deepEqual( lem.only_lemmas('went'), [ 'go' ] );
  assert.deepEqual( lem.only_lemmas('gone'), [ 'go', 'gone' ] );
  assert.deepEqual( lem.only_lemmas('writes'), [ 'write' ] );
  assert.deepEqual( lem.only_lemmas('wrote'), [ 'write' ] );
  assert.deepEqual( lem.only_lemmas('written'), [ 'write', 'written' ] );
  assert.deepEqual( lem.only_lemmas('confirms'), [ 'confirm' ] );
  assert.deepEqual( lem.only_lemmas('confirmed'), [ 'confirm', 'confirmed' ] );
  assert.deepEqual( lem.only_lemmas('confirming'), [ 'confirm', 'confirming' ] );
  assert.deepEqual( lem.only_lemmas('acidless'), [ 'acidless' ] );
  assert.deepEqual( lem.only_lemmas('pizzas'), [ 'pizza' ] );
  assert.deepEqual( lem.only_lemmas('foxes'), [ 'fox' ] );
  assert.deepEqual( lem.only_lemmas('hacked'), [ 'hack' ] );
  assert.deepEqual( lem.only_lemmas('coded'), [ 'code' ] );
  assert.deepEqual( lem.only_lemmas('fitting'), [ 'fit', 'fitting' ] );
  assert.deepEqual( lem.only_lemmas('coding'), [ 'code', 'coding' ] );
  assert.deepEqual( lem.only_lemmas('pirouetting'), [ 'pirouette' ] );
  assert.deepEqual( lem.only_lemmas('hacking'), [ 'hack' ] );
  assert.deepEqual( lem.only_lemmas('earliest'), [ 'earliest', 'early' ] );
  assert.deepEqual( lem.only_lemmas('biggest'), [ 'big' ] );
  assert.deepEqual( lem.only_lemmas('largest'), [ 'large' ] );
  assert.deepEqual( lem.only_lemmas('smallest'), [ 'small' ] );
  assert.deepEqual( lem.only_lemmas('earlier'), [ 'earlier', 'early' ] );
  assert.deepEqual( lem.only_lemmas('bigger'), [ 'big', 'bigger' ] );
  assert.deepEqual( lem.only_lemmas('larger'), [ 'large', 'larger' ] );
  assert.deepEqual( lem.only_lemmas('smaller'), [ 'small', 'smaller' ] );
  assert.deepEqual( lem.only_lemmas('recognizable'), [ 'recognize', 'recognizable' ] );
  assert.deepEqual( lem.only_lemmas('networkable'), [ 'network' ] );
  assert.deepEqual( lem.only_lemmas('resettability'), [ 'reset' ] );
  assert.deepEqual( lem.only_lemmas('repairability'), [ 'repair' ] );
  assert.deepEqual( lem.only_lemmas('reorganizability'), [ 'reorganize' ] );
  assert.deepEqual( lem.only_lemmas('starts'), [ 'start' ] );
  assert.deepEqual( lem.only_lemmas('teaches'), [ 'teach' ] );
  assert.deepEqual( lem.only_lemmas('talked'), [ 'talk' ] );
  assert.deepEqual( lem.only_lemmas('saved'), [ 'save', 'saved' ] );
  assert.deepEqual( lem.only_lemmas('sitting'), [ 'sit', 'sitting' ] );
  assert.deepEqual( lem.only_lemmas('having'), [ 'have' ] );
  assert.deepEqual( lem.only_lemmas('talking'), [ 'talk', 'talking' ] );
  assert.deepEqual( lem.only_lemmas('heavier'), [ 'heavy' ] );
  assert.deepEqual( lem.only_lemmas('bigger'), [ 'big', 'bigger' ] );
  assert.deepEqual( lem.only_lemmas('huger'), [ 'huge' ] );
  assert.deepEqual( lem.only_lemmas('lower'), [ 'lower', 'low' ] );
  assert.deepEqual( lem.only_lemmas('writable'), [ 'write' ] );
  assert.deepEqual( lem.only_lemmas('readable'), [ 'read', 'readable' ] );
  assert.deepEqual( lem.only_lemmas('resettable'), [ 'reset' ] );
  assert.deepEqual( lem.only_lemmas('readability'), [ 'read', 'readability' ] );
  assert.deepEqual( lem.only_lemmas('writability'), [ 'write' ] );
  assert.deepEqual( lem.only_lemmas('scoreless'), [ 'scoreless' ] );
  assert.deepEqual( lem.only_lemmas('dogs'), [ 'dog' ] );
  assert.deepEqual( lem.only_lemmas('dishes'), [ 'dish' ] );
  assert.deepEqual( lem.only_lemmas('heaviest'), [ 'heavy' ] );
  assert.deepEqual( lem.only_lemmas('biggest'), [ 'big' ] );
  assert.deepEqual( lem.only_lemmas('hugest'), [ 'huge' ] );
  assert.deepEqual( lem.only_lemmas('lowest'), [ 'lowest', 'low' ] );
  assert.deepEqual( lem.only_lemmas('heavier'), [ 'heavy' ] );
  assert.deepEqual( lem.only_lemmas('bigger'), [ 'big', 'bigger' ] );
  assert.deepEqual( lem.only_lemmas('lower'), [ 'lower', 'low' ] );
  assert.deepEqual( lem.only_lemmas('higher'), [ 'high', 'higher' ] );
  assert.deepEqual( lem.only_lemmas('leaves'), [ 'leave', 'leaf' ] );
  assert.deepEqual( lem.only_lemmas('player'), [ 'player' ] );
  assert.deepEqual( lem.only_lemmas('priorities'), [ 'priority' ] );
  assert.deepEqual( lem.only_lemmas('matter'), [ 'matter', 'matte', 'matt', 'mat' ] );
  assert.deepEqual( lem.only_lemmas('added'), [ 'add' ] );
  assert.deepEqual( lem.only_lemmas('opposes'), [ 'oppose' ] );
  assert.deepEqual( lem.only_lemmas('singing'), [ 'sing', 'singing' ] );
  assert.deepEqual( lem.only_lemmas('dying'), [ 'die', 'dying' ] );
  assert.deepEqual( lem.only_lemmas('after'), [ 'after', 'aft' ] );
  assert.deepEqual( lem.only_lemmas('us'), [ 'us' ] );
});
