lingo 1.8.0

data/test/ts_database.rb

@@ -0,0 +1,269 @@
+# encoding: utf-8
+
+require_relative 'test_helper'
+
+class Lingo::Txt2DbmConverter
+  alias_method :original_initialize, :initialize
+  def initialize(id, lingo, verbose = false)
+    original_initialize(id, lingo, verbose)
+  end
+end
+
+class TestDatabase < LingoTestCase
+
+  def setup
+    @lingo = Lingo.new
+
+    @singleword = <<-EOT
+Wort1
+Wort2
+Wort2
+juristische Personen
+höher schneller weiter
+höher schneller weiter größer
+ganz großer und blöder quatsch
+ganz großer und blöder mist
+ganz großer und blöder schwach sinn
+    EOT
+
+    @keyvalue = <<-EOT
+Wort1*Projektion1
+Wort2*Projektion2
+Wort3*Projektion3
+Wort4*
+Wort1*Projektion4
+Wort1 * Projektion5
+Mehr Wort Satz*Pro Jeck Zion 1
+Mehr Wort Satz*Pro Jeck Zion 2
+Albert Einstein*Einstein, Albert
+    EOT
+
+    @wordclass = <<-EOT
+Wort1=Projektion1#h
+Wort2=Projektion2#i
+Wort3=Projektion3#e
+Wort1=Projektion4 #e
+Wort1=#s
+Wort2=
+    EOT
+  end
+
+  def test_singleword
+    compare({
+      'txt-format' => 'SingleWord'
+    }, @singleword, {
+      'wort1'                               => '#s',
+      'wort2'                               => '#s',
+      'juristische personen'                => '#s',
+      'höher schneller weiter'              => '#s',
+      'höher schneller weiter größer'       => '#s',
+      'ganz großer und blöder quatsch'      => '#s',
+      'ganz großer und blöder mist'         => '#s',
+      'ganz großer und blöder schwach sinn' => '#s'
+    })
+  end
+
+  def test_singleword_defwc
+    compare({
+      'txt-format' => 'SingleWord',
+      'def-wc'     => '*'
+    }, @singleword, {
+      'wort1'                               => '#*',
+      'wort2'                               => '#*',
+      'juristische personen'                => '#*',
+      'höher schneller weiter'              => '#*',
+      'höher schneller weiter größer'       => '#*',
+      'ganz großer und blöder quatsch'      => '#*',
+      'ganz großer und blöder mist'         => '#*',
+      'ganz großer und blöder schwach sinn' => '#*'
+    })
+  end
+
+  def test_singleword_defmulwc
+    compare({
+      'txt-format' => 'SingleWord',
+      'def-mul-wc' => 'm'
+    }, @singleword, {
+      'wort1'                               => '#s',
+      'wort2'                               => '#s',
+      'juristische personen'                => '#m',
+      'höher schneller weiter'              => '#m',
+      'höher schneller weiter größer'       => '#m',
+      'ganz großer und blöder quatsch'      => '#m',
+      'ganz großer und blöder mist'         => '#m',
+      'ganz großer und blöder schwach sinn' => '#m'
+    })
+  end
+
+  def test_singleword_uselex
+    compare({
+      'txt-format' => 'SingleWord',
+      'use-lex'    => set_config('lex',
+        'name'       => 'de/lingo-dic.txt',
+        'txt-format' => 'WordClass'
+      )
+    }, @singleword, {
+      'wort1'                           => '#s',
+      'wort2'                           => '#s',
+      'ganz groß und blöd mist'         => 'ganz großer und blöder mist#s',
+      'juristisch person'               => 'juristische personen#s',
+      'hoch schnell weit'               => '*4|höher schneller weiter#s',
+      'ganz groß und blöd quatsch'      => 'ganz großer und blöder quatsch#s',
+      'hoch schnell weit groß'          => 'höher schneller weiter größer#s',
+      'ganz groß und blöd schwach sinn' => 'ganz großer und blöder schwach sinn#s',
+      'ganz groß und'                   => '*5|*6'
+    })
+  end
+
+  def test_singleword_crypt
+    config = {
+      'txt-format' => 'SingleWord',
+      'crypt'      => true
+    }
+
+    compare(config, @singleword, {
+      'd8ac4360a5f707d518212e27dcba9dd42d980f96' => '5116',
+      '81463f9c7e0ad40e329e83d3358232851d50ed9a' => '4d16',
+      '8da4a0c30c912543be2d88da64c0192e577efa9d' => '1107',
+      '2c24b4707e77c74abfb12748317693dc1e43c215' => '5700',
+      '810ff7a76f39febcb1cf67993d4fb29819ce40a6' => '5116',
+      'a28b4ca84ac08aeef4e420445f94f632ad010a30' => '1207',
+      '1496f4febbc647f3ac74b0af11dadbd6322f6732' => '4d1d',
+      'b7501a62cb083be6730a7a179a4ab346d23efe53' => '4b10'
+    })
+
+    compare(config, @singleword) { |dbm| {
+      'wort1'                               => '#s',
+      'wort2'                               => '#s',
+      'juristische personen'                => '#s',
+      'höher schneller weiter'              => '#s',
+      'höher schneller weiter größer'       => '#s',
+      'ganz großer und blöder quatsch'      => '#s',
+      'ganz großer und blöder mist'         => '#s',
+      'ganz großer und blöder schwach sinn' => '#s'
+    }.each { |key, val| assert_equal([val], dbm[key]) } }
+  end
+
+  def test_keyvalue
+    compare({
+      'txt-format' => 'KeyValue'
+    }, @keyvalue, {
+      'wort1'           => 'projektion1#?|projektion4#?|projektion5#?',
+      'wort2'           => 'projektion2#?',
+      'wort3'           => 'projektion3#?',
+      'mehr wort satz'  => 'pro jeck zion 1#?|pro jeck zion 2#?',
+      'albert einstein' => 'einstein, albert#?'
+    })
+  end
+
+  def test_keyvalue_separator
+    compare({
+      'txt-format' => 'KeyValue',
+      'separator'  => '*'
+    }, @keyvalue, {
+      'wort1'           => 'projektion1#?|projektion4#?|projektion5#?',
+      'wort2'           => 'projektion2#?',
+      'wort3'           => 'projektion3#?',
+      'mehr wort satz'  => 'pro jeck zion 1#?|pro jeck zion 2#?',
+      'albert einstein' => 'einstein, albert#?'
+    })
+  end
+
+  def test_keyvalue_defwc
+    compare({
+      'txt-format' => 'KeyValue',
+      'separator'  => '*',
+      'def-wc'     => 's'
+    }, @keyvalue, {
+      'wort1'=>'projektion1#s|projektion4#s|projektion5#s',
+      'wort2'=>'projektion2#s',
+      'wort3'=>'projektion3#s',
+      'mehr wort satz'=>'pro jeck zion 1#s|pro jeck zion 2#s',
+      'albert einstein'=>'einstein, albert#s'
+    })
+  end
+
+  def test_wordclass
+    compare({
+      'txt-format' => 'WordClass',
+      'separator'  => '='
+    }, %q{
+      Wort1=Projektion1#h
+      Wort2=Projektion2#i
+      Wort3=Projektion3#e
+      Wort1=Projektion4 #e
+      Wort1=#s
+      Wort2=
+    }, {
+      'wort1' => 'projektion1#h|projektion4#e',
+      'wort2' => 'projektion2#i',
+      'wort3' => 'projektion3#e'
+    })
+  end
+
+  def test_multivalue
+    compare({
+      'txt-format' => 'MultiValue',
+      'separator'  => ';'
+    }, %q{
+      Hasen;Nasen;Vasen;Rasen
+      Gold;Edelmetall;Mehrwert
+      Rasen;Gras;Grüne Fläche
+      Rasen;Rennen;Wettrennen
+    }, {
+      '^0'           => 'hasen|nasen|rasen|vasen',
+      '^1'           => 'edelmetall|gold|mehrwert',
+      '^2'           => 'gras|grüne fläche|rasen',
+      '^3'           => 'rasen|rennen|wettrennen',
+      'hasen'        => '^0',
+      'nasen'        => '^0',
+      'rasen'        => '^0|^2|^3',
+      'vasen'        => '^0',
+      'edelmetall'   => '^1',
+      'gold'         => '^1',
+      'mehrwert'     => '^1',
+      'gras'         => '^2',
+      'grüne fläche' => '^2',
+      'wettrennen'   => '^3',
+      'rennen'       => '^3'
+    })
+  end
+
+  def test_multikey
+    compare({
+      'txt-format' => 'MultiKey'
+    }, %q{
+      Hasen;Nasen;Vasen;Rasen
+      Gold;Edelmetall;Mehrwert
+    }, {
+      'nasen'      => 'hasen',
+      'vasen'      => 'hasen',
+      'rasen'      => 'hasen',
+      'edelmetall' => 'gold',
+      'mehrwert'   => 'gold',
+    })
+  end
+
+  def compare(config, input, output = nil)
+    FileUtils.mkdir_p(File.dirname(TEST_FILE))
+    File.write(TEST_FILE, input, encoding: Lingo::ENC)
+
+    Lingo::DbmFile.open(set_config('tst', config.merge('name' => TEST_FILE)), @lingo) { |dbm|
+      if block_given?
+        yield dbm
+      else
+        store = dbm.to_h
+        store.delete(Lingo::SYS_KEY)
+
+        assert_equal(output, store)
+      end
+    }
+  ensure
+    cleanup_store
+  end
+
+  def set_config(id, config)
+    "_test_#{id}_".tap { |id| @lingo.config["language/dictionary/databases/#{id}"] = config }
+  end
+
+end

data/test/ts_language.rb

@@ -0,0 +1,396 @@
+# encoding: utf-8
+
+require_relative 'test_helper'
+
+class TestLexicalHash < LingoTestCase
+
+  def setup
+    @lingo = Lingo.new
+    @database_config = @lingo.config['language/dictionary/databases']
+  end
+
+  def teardown
+    cleanup_store
+  end
+
+  def test_params
+    old_stderr, $stderr = $stderr, StringIO.new('')
+
+    # Datenquelle nicht in Konfiguration enthalten
+    assert_raise(SystemExit) { Lingo::LexicalHash.new('nonsens', @lingo) }
+  ensure
+    $stderr = old_stderr
+  end
+
+  # TODO: Crypt testen...
+
+  def test_cache
+    ds = Lingo::LexicalHash.new('sys-dic', @lingo)
+    assert_equal([lx('regen|s'), lx('regen|v'), lx('rege|a')], ds['regen'])
+    assert_equal([lx('regen|s'), lx('regen|v'), lx('rege|a')], ds['regen'])
+    assert_equal([lx('regen|s'), lx('regen|v'), lx('rege|a')], ds['regen'])
+    ds.close
+  end
+
+  def test_report
+    ds = Lingo::LexicalHash.new('tst-syn', @lingo)
+    ds['abwickeln']    # source read
+    ds['abwickeln']    # cache hit
+    ds['regen']      # source read
+    ds['nonesens']    # source read, nothing found
+
+    expect = { \
+      "tst-syn: cache hits" => 1, \
+      "tst-syn: total requests" => 4, \
+      "tst-syn: source reads" => 3, \
+      "tst-syn: data found" => 2
+    }
+
+    assert_equal(expect, ds.report)
+    ds.close
+  end
+
+  def test_auto_create
+    txt_file = @database_config['tst-sgw']['name']
+    sto_file = Lingo.find(:store, txt_file) << '.pag'
+
+    ds = Lingo::LexicalHash.new('tst-sgw', @lingo)
+    assert_equal([lx('substantiv|s')], ds['substantiv'])
+    ds.close
+
+    # Keine Store-Datei vorhanden, nur Text vorhanden
+    File.delete(sto_file)
+    ds = Lingo::LexicalHash.new('tst-sgw', @lingo)
+    assert_equal([lx('substantiv|s')], ds['substantiv'])
+    ds.close
+
+    # Store vorhanden, aber Text ist neuer
+    ds = Lingo::LexicalHash.new('tst-sgw', @lingo)
+    assert_equal([lx('substantiv|s')], ds['substantiv'])
+    ds.close
+  end
+
+  def test_singleword
+    ds = Lingo::LexicalHash.new('tst-sgw', @lingo)
+    assert_equal([lx('substantiv|s')], ds['substantiv'])
+    assert_equal([lx('mehr wort gruppe|s')], ds['mehr wort gruppe'])
+    assert_equal(nil, ds['nicht vorhanden'])
+    ds.close
+  end
+
+  def test_keyvalue
+    ds = Lingo::LexicalHash.new('sys-mul', @lingo)
+    assert_equal([lx('abelscher ring ohne nullteiler|m')], ds['abelscher ring ohne nullteiler'])
+    assert_equal(['*4'], ds['abelscher ring ohne'])
+    assert_equal([lx('alleinreisende frau|m')], ds['alleinreisend frau'])
+    assert_equal([lx('abschaltbarer leistungshalbleiter|m')], ds['abschaltbar leistungshalbleiter'])
+    assert_equal(nil, ds['abschaltbarer leistungshalbleiter'])
+    ds.close
+  end
+
+  def test_wordclass
+    ds = Lingo::LexicalHash.new('sys-dic', @lingo)
+    assert_equal([lx('a-dur|s')], ds['a-dur'])
+    assert_equal([lx('aalen|v'), lx('aalen|e')], ds['aalen'])
+    assert_equal([lx('abarbeitend|a')], ds['abarbeitend'])
+    ds.close
+  end
+
+  def test_case
+    ds = Lingo::LexicalHash.new('sys-dic', @lingo)
+    assert_equal([lx('abänderung|s')], ds['abänderung'])
+    assert_equal([lx('abänderung|s')], ds['Abänderung'])
+    assert_equal([lx('abänderung|s')], ds['ABÄNDERUNG'])
+    ds.close
+  end
+
+  def test_multivalue
+    ds = Lingo::LexicalHash.new('sys-syn', @lingo)
+# assert_equal([lx('abrollen', LA_SYNONYM), lx('abschaffen', LA_SYNONYM), lx('abwickeln', LA_SYNONYM), lx('auflösen (geschäft)','y')], ds['abwickeln'])
+# assert_equal([lx('niederschlag', LA_SYNONYM), lx('regen', LA_SYNONYM), lx('schauer', LA_SYNONYM)], ds['regen'])
+    ds.close
+  end
+
+end
+
+class TestDictionary < LingoTestCase
+
+  def setup
+    @lingo = Lingo.new
+  end
+
+  def test_params
+    # Keine Sprach-Konfiguration angegeben
+    #assert_raise(RuntimeError) { Lingo::Dictionary.new({'source'=>['sys-dic']}, @lingo) }
+    # Keine Parameter angegeben
+    assert_raise(RuntimeError) { Lingo::Dictionary.new(nil, @lingo) }
+    # Falsche Parameter angegeben (Pflichtparameter ohne Defaultwert)
+    assert_raise(RuntimeError) { Lingo::Dictionary.new({'course'=>['sys-dic']}, @lingo) }
+  end
+
+  def test_cache
+    dic = Lingo::Dictionary.new({'source'=>['sys-dic']}, @lingo)
+    assert_equal([lx('nase|s')], dic.select('nase'))
+    assert_equal([lx('nase|s')], dic.select('nase'))
+    assert_equal([lx('nase|s')], dic.select('nase'))
+    dic.close
+  end
+
+  def test_report
+    dic = Lingo::Dictionary.new({'source'=>['sys-dic']}, @lingo)
+    dic.select('abwickeln')    # source read
+    dic.select('abwickeln')    # cache hit
+    dic.select('regen')        # source read
+    dic.select('nonesens')     # source read, nothing found
+
+    expect = {
+      "sys-dic: total requests" => 4,
+      "sys-dic: data found" => 2,
+      "sys-dic: cache hits" => 1,
+      "sys-dic: source reads" => 3
+    }
+
+    assert_equal(expect, dic.report)
+    dic.close
+  end
+
+  def test_select_one_source
+    dic = Lingo::Dictionary.new({'source'=>['sys-dic']}, @lingo)
+    assert_equal([lx('nase|s')], dic.select('nase'))
+    assert_equal([lx('nase|s')], dic.select('NASE'))
+    assert_equal([], dic.select('hasennasen'))
+    dic.close
+  end
+
+  def test_select_two_sources_mode_first
+    dic = Lingo::Dictionary.new({'source'=>['sys-dic', 'tst-dic'], 'mode'=>'first'}, @lingo)
+    # in keiner Quelle vorhanden
+    assert_equal([], dic.select('hasennasen'))
+    # nur in erster Quelle vorhanden
+    assert_equal([lx('knaller|s')], dic.select('knaller'))
+    # nur in zweiter Quelle vorhanden
+    assert_equal([lx('super indexierungssystem|m')], dic.select('lex-lingo'))
+    # in beiden Quellen vorhanden
+    assert_equal([lx('a-dur|s')], dic.select('a-dur'))
+    dic.close
+  end
+
+  def test_select_two_sources_mode_first_flipped
+    dic = Lingo::Dictionary.new({'source'=>['tst-dic','sys-dic'], 'mode'=>'first'}, @lingo)
+    # in keiner Quelle vorhanden
+    assert_equal([], dic.select('hasennasen'))
+    # nur in erster Quelle vorhanden
+    assert_equal([lx('knaller|s')], dic.select('knaller'))
+    # nur in zweiter Quelle vorhanden
+    assert_equal([lx('super indexierungssystem|m')], dic.select('lex-lingo'))
+    # in beiden Quellen vorhanden
+    assert_equal([lx('b-dur|s')], dic.select('a-dur'))
+    dic.close
+  end
+
+  def test_select_two_sources_mode_all
+    dic = Lingo::Dictionary.new({'source'=>['sys-dic','tst-dic'], 'mode'=>'all'}, @lingo)
+    # in keiner Quelle vorhanden
+    assert_equal([], dic.select('hasennasen'))
+    # nur in erster Quelle vorhanden
+    assert_equal([lx('knaller|s')], dic.select('knaller'))
+    # nur in zweiter Quelle vorhanden
+    assert_equal([lx('super indexierungssystem|m')], dic.select('lex-lingo'))
+    # in beiden Quellen vorhanden
+    assert_equal([lx('a-dur|s'), lx('b-dur|s')], dic.select('a-dur'))
+    assert_equal([lx('aas|s')], dic.select('aas'))
+    dic.close
+  end
+
+  def test_select_two_sources_mode_default
+    dic = Lingo::Dictionary.new({'source'=>['sys-dic','tst-dic']}, @lingo)
+    # in keiner Quelle vorhanden
+    assert_equal([], dic.select('hasennasen'))
+    # nur in erster Quelle vorhanden
+    assert_equal([lx('knaller|s')], dic.select('knaller'))
+    # nur in zweiter Quelle vorhanden
+    assert_equal([lx('super indexierungssystem|m')], dic.select('lex-lingo'))
+    # in beiden Quellen vorhanden
+    assert_equal([lx('a-dur|s'), lx('b-dur|s')], dic.select('a-dur'))
+    assert_equal([lx('aas|s')], dic.select('aas'))
+    dic.close
+  end
+
+  def test_suffix_lexicals
+    dic = Lingo::Dictionary.new({'source'=>['sys-dic']}, @lingo)
+    assert_equal([lx('mau|s'), lx('mauer|s')], dic.suffix_lexicals('mauern'))
+    assert_equal([lx('hasen|s'), lx('hasen|v'), lx('hasen|e')], dic.suffix_lexicals('hasens'))
+    assert_equal([lx('schönst|s'), lx('schön|a'), lx('schönst|a')], dic.suffix_lexicals('schönster'))
+    assert_equal([lx('segnen|v'), lx('segneen|v')], dic.suffix_lexicals('segnet'))
+    dic.close
+  end
+
+  def test_infix_lexicals
+    dic = Lingo::Dictionary.new({'source'=>['sys-dic']}, @lingo)
+    assert_equal( [lx('information|s'), lx('information|v'), lx('information|e')], dic.suffix_lexicals('informations'))
+    dic.close
+  end
+
+  def test_select_with_suffix
+    dic = Lingo::Dictionary.new({'source'=>['sys-dic']}, @lingo)
+    assert_equal([lx('mauern|v')], dic.select_with_suffix('mauern'))
+    assert_equal([lx('hase|s')], dic.select_with_suffix('hasen'))
+    assert_equal([lx('schön|a')], dic.select_with_suffix('schönster'))
+    assert_equal([lx('segnen|v')], dic.select_with_suffix('segnet'))
+    dic.close
+  end
+
+  def test_select_with_infix
+    dic = Lingo::Dictionary.new({'source'=>['sys-dic']}, @lingo)
+    assert_equal( [lx('information|s'), lx('information|v'), lx('information|e')], dic.suffix_lexicals('informations'))
+    dic.close
+  end
+
+  def test_find_word
+    dic = Lingo::Dictionary.new({'source'=>['sys-dic']}, @lingo)
+    assert_equal(wd('hasennasen|?'), dic.find_word('hasennasen'))
+    assert_equal(wd('hase|IDF', 'hase|s'), dic.find_word('hase'))
+    assert_equal(wd('haseses|IDF', 'hase|s'), dic.find_word('haseses'))
+    dic.close
+  end
+
+end
+
+class TestGrammar < LingoTestCase
+
+  def setup
+    @lingo = Lingo.new
+  end
+
+  def test_params
+    # Die gleichen Fälle wie bei Dictionary, daher nicht notwendig
+  end
+
+  def test_cache
+    gra = Lingo::Grammar.new({'source'=>['sys-dic']}, @lingo)
+    assert_equal(
+      wd('informationswissenschaften|KOM', 'informationswissenschaft|k', 'information|s+', 'wissenschaft|s+'),
+      gra.find_compositum('informationswissenschaften')
+    )
+    assert_equal(
+      wd('informationswissenschaften|KOM', 'informationswissenschaft|k', 'information|s+', 'wissenschaft|s+'),
+      gra.find_compositum('informationswissenschaften')
+    )
+    assert_equal(
+      wd('informationswissenschaften|KOM', 'informationswissenschaft|k', 'information|s+', 'wissenschaft|s+'),
+      gra.find_compositum('informationswissenschaften')
+    )
+    gra.close
+  end
+
+  def t1est_test_compositum
+    gra = Lingo::Grammar.new({'source'=>['sys-dic']}, @lingo)
+    # hinterer Teil ist ein Wort mit Suffix
+    assert_equal([ [5, 6], [lx('hasenbraten|k'), lx('braten|s'), lx('hase|s'), lx('braten|v')] ],
+      gra.test_compositum('hasen', '', 'braten', 1, false)
+    )
+    # hinterer Teil ist ein Wort mit Infix ohne Schwanz
+    assert_equal([ [5, 7], [lx('nasenlaufen|k'), lx('laufen|s'), lx('nase|s'), lx('laufen|v')] ],
+      gra.test_compositum('nasen', '', 'laufens', 1, false)
+    )
+    # hinterer Teil ist ein Wort mit Infix mit Schwanz
+    assert_equal([ [5, 7], [lx('nasenlaufens|k'), lx('laufen|s'), lx('nase|s'), lx('laufen|v')] ],
+      gra.test_compositum('nasen', '', 'laufens', 1, true)
+    )
+    # hinterer Teil ist ein Kompositum nach Bindestrich
+    assert_equal([ [7, 9, 6], [lx('arrafat-nachfolgebedarf|k'), lx('bedarf|s'), lx('nachfolge|s'), lx('arrafat|x')] ],
+      gra.test_compositum('arrafat', '-', 'nachfolgebedarf', 1, false)
+    )
+    # hinterer Teil ist ein TakeItAsIs nach Bindestrich
+    assert_equal([ [9, 7], [lx('nachfolge-arrafat|k'), lx('nachfolge|s'), lx('arrafat|x')] ],
+      gra.test_compositum('nachfolge', '-', 'arrafat', 1, false)
+    )
+    # vorderer Teil ist ein Wort mit Suffix => siehe Hasenbraten
+    # vorderer Teil ist ein Kompositum
+    assert_equal([ [6, 5, 6], [lx('morgenonkelmantel|k'), lx('mantel|s'), lx('morgen|s'), lx('onkel|s'), lx('morgen|w')] ],
+      gra.test_compositum('morgenonkel', '', 'mantel', 1, false)
+    )
+    # vorderer Teil ist ein TakeItAsIs vor Bindestrich
+    assert_equal([ [7, 10], [lx('arrafat-nachfolger|k'), lx('nachfolger|s'), lx('arrafat|x')] ],
+      gra.test_compositum('arrafat', '-', 'nachfolger', 1, false)
+    )
+    gra.close
+  end
+
+  def t1est_permute_compositum
+    gra = Lingo::Grammar.new({'source'=>['sys-dic']}, @lingo)
+    # bindestrichversion
+    assert_equal([ [7, 10], [lx('arrafat-nachfolger|k'), lx('nachfolger|s'), lx('arrafat|x')] ],
+      gra.permute_compositum('arrafat-nachfolger', 1, false)
+    )
+    # bindestrichversion zwei-teilig
+    assert_equal([ [6, 11], \
+      [  lx('cd-rom-technologie|k'), \
+        lx('cd-rom|s'), \
+        lx('technologie|s')] ], \
+      gra.permute_compositum('cd-rom-technologie', 1, false) \
+    )
+    # bindestrichversion drei-teilig
+    assert_equal([ [6, 7, 11], \
+      [  lx('albert-ludwigs-universität|k'), \
+        lx('universität|s'), \
+        lx('albert|e'), \
+        lx('ludwig|e')] ], \
+      gra.permute_compositum('albert-ludwigs-universität', 1, false) \
+    )
+    # normal mit suggestion
+    assert_equal([ [8, 9], \
+      [  lx('benutzerforschung|k'), \
+        lx('benutzer|s'), \
+        lx('forschung|s')] ], \
+      gra.permute_compositum('benutzerforschung', 1, false) \
+    )
+    gra.close
+  end
+
+  def test_find_compositum
+    gra = Lingo::Grammar.new({'source'=>['sys-dic']}, @lingo)
+    assert_equal(
+      wd('informationswissenschaften|KOM', 'informationswissenschaft|k', 'information|s+', 'wissenschaft|s+'),
+      gra.find_compositum('informationswissenschaften') \
+    )
+    assert_equal(
+      wd('cd-rom-technologie|KOM', 'cd-rom-technologie|k', 'technologie|s+', 'cd-rom|x+'),
+      gra.find_compositum('cd-rom-technologie')
+    )
+    assert_equal(
+      wd('albert-ludwigs-universität|KOM', 'albert-ludwigs-universität|k', 'albert|e+', 'ludwig|e+', 'universität|s+'),
+      gra.find_compositum('albert-ludwigs-universität')
+    )
+    assert_equal(
+      wd('client-server-system|KOM', 'client-server-system|k', 'client|s+', 'server|s+', 'system|s+'),
+      gra.find_compositum('client-server-system')
+    )
+    assert_equal(
+      wd('benutzerforschung|KOM', 'benutzerforschung|k', 'erforschung|s+', 'benutzen|v+'),
+      gra.find_compositum('benutzerforschung')
+    )
+    assert_equal(
+      wd('clustersuche|KOM', 'clustersuche|k', 'cluster|s+', 'suche|s+', 'suchen|v+'),
+      gra.find_compositum('clustersuche')
+    )
+    gra.close
+  end
+
+  def test_min_word_size
+    gra = Lingo::Grammar.new({'source'=>['sys-dic']}, @lingo)
+    assert_equal( wd('undsund|?'), gra.find_compositum('undsund'))
+    gra.close
+  end
+
+  def test_max_parts
+    gra = Lingo::Grammar.new({'source'=>['sys-dic']}, @lingo)
+    assert_equal(
+      wd('baumsbaumsbaum|KOM', 'baumsbaumsbaum|k', 'baum|s+'),
+      gra.find_compositum('baumsbaumsbaum')
+    )
+    assert_equal( Lingo::Word.new('baumsbaumsbaumsbaumsbaumsbaum', Lingo::WA_UNKNOWN), gra.find_compositum('baumsbaumsbaumsbaumsbaumsbaum'))
+    gra.close
+  end
+
+end