llt-form_builder 0.0.1

data/spec/lib/llt/form_builder/noun_builder_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+describe LLT::FormBuilder do
+  include LLT::Helpers::Normalizer
+
+  describe ".build" do
+    def form_builder_strings(args)
+      forms = LLT::FormBuilder.build(*args)
+      forms.map(&:to_s)
+    end
+
+    def with_noun_options(options)
+      args = [{type: :noun, stem: "ros", inflection_class: 1, sexus: :f, options: options }]
+      LLT::FormBuilder.build(*args)
+    end
+
+    context "with nouns" do
+      context "without options" do
+        it "builds all forms of A - nominative need not be given" do
+          args = [{type: :noun, stem: "ros", inflection_class: 1, sexus: :f}]
+          form_builder_strings(args).should == %w(rosa rosae rosae rosam rosa rosa rosae rosarum rosis rosas rosae rosis)
+        end
+
+        it "builds all forms of A - even if nominative is given" do
+          args = [{type: :noun, nominative: "rosa", stem: "ros", inflection_class: 1, sexus: :f}]
+          form_builder_strings(args).should == %w(rosa rosae rosae rosam rosa rosa rosae rosarum rosis rosas rosae rosis)
+        end
+
+        context "O - m " do
+          it "builds all forms when no nominative is given" do
+            args = [{type: :noun, stem: "amic", inflection_class: 2, sexus: :m}]
+            form_builder_strings(args).should == %w(amicus amici amico amicum amice amico amici amicorum amicis amicos amici amicis)
+          end
+
+          it "builds all forms - handles vocative properly when nominative is given" do
+            args = [{type: :noun, nominative: "amicus", stem: "amic", inflection_class: 2, sexus: :m}]
+            form_builder_strings(args).should == %w(amicus amici amico amicum amice amico amici amicorum amicis amicos amici amicis)
+          end
+
+          it "builds all forms - handles vocative for ius forms properly when nominative is given" do
+            args = [{type: :noun, nominative: "filius", stem: "fili", inflection_class: 2, sexus: :m}]
+            form_builder_strings(args).should == %w(filius filii filio filium fili filio filii filiorum filiis filios filii filiis)
+          end
+
+          it "builds all forms - handles vocative for ius forms properly when no nominative is given" do
+            args = [{type: :noun, stem: "fili", inflection_class: 2, sexus: :m}]
+            form_builder_strings(args).should == %w(filius filii filio filium fili filio filii filiorum filiis filios filii filiis)
+          end
+
+          it "segmentizes fili vocative correctly" do
+            args = [{type: :noun, stem: "fili", inflection_class: 2, sexus: :m}]
+            forms = LLT::FormBuilder.build(*args)
+            forms[4].to_s(:segmentized).should == "fili"
+          end
+
+          it "builds all forms with er ending - needs nominative given" do
+            args = [{type: :noun, stem: "puer", inflection_class: 2, sexus: :m, nominative: "puer"}]
+            form_builder_strings(args)[0].should == "puer"
+            form_builder_strings(args)[4].should == "puer"
+          end
+
+          it "builds all forms with er ending - needs nominative given" do
+            args = [{type: :noun, nominative: "magister", stem: "magistr", inflection_class: 2, sexus: :m}]
+            form_builder_strings(args)[0].should == "magister"
+            form_builder_strings(args)[4].should == "magister"
+          end
+
+          it "builds all forms without an ending - needs nominative given (vir)" do
+            args = [{type: :noun, nominative: "vir", stem: "vir", inflection_class: 2, sexus: :m}]
+            strings = form_builder_strings(args)
+            strings.should have(12).items
+            vir = strings.first
+            vir.should == "vir"
+          end
+        end
+
+        it "builds all forms of O - n" do
+          args = [{type: :noun, stem: "templ", inflection_class: 2, sexus: :n}]
+          form_builder_strings(args).should == %w(templum templi templo templum templum templo templa templorum templis templa templa templis)
+        end
+
+        it "builds all forms of C - m" do
+          args = [{type: :noun, nominative: "homo", stem: "homin", inflection_class: 3, sexus: :m}]
+          form_builder_strings(args).should == %w(homo hominis homini hominem homo homine homines hominum hominibus homines homines hominibus)
+        end
+
+        it "builds all forms of C - n" do
+          args = [{type: :noun, nominative: "flumen", stem: "flumin", inflection_class: 3, sexus: :n}]
+          form_builder_strings(args).should == %w(flumen fluminis flumini flumen flumen flumine flumina fluminum fluminibus flumina flumina fluminibus)
+        end
+
+        it "builds all forms of wildly irregular words like bos" do
+          irregular = [["bos", 1, 1], ["boum", 2, 2], ["bubus", 3, 2], ["bubus", 6, 2]]
+          additional =  [["bobus", 3, 2], ["bobus", 6, 2]]
+          args = [{type: :noun, stem: "bov", inflection_class: 3, sexus: :m, irregular_forms: irregular, additional_forms: additional}]
+          form_builder_strings(args).should == %w(bos bovis bovi bovem bos bove boves boum bubus boves boves bubus bobus bobus)
+        end
+
+        it "builds objects with stem and ending separated" do
+          args = [{type: :noun, stem: "ros", inflection_class: 1, sexus: :f}]
+          forms = LLT::FormBuilder.build(*args)
+          # forms.first = all forms of the one stem it was initialized with
+          rosa = forms.first
+          rosa.stem.should == "ros"
+          rosa.ending.should == "a"
+          rosa.sexus.should == :f
+        end
+
+        it "builds objects with stem and ending separated even for irregular forms like bubus" do
+          irregular = [["bos", 1, 1], ["boum", 2, 2], ["bubus", 3, 2], ["bubus", 6, 2]]
+          additional =  [["bobus", 3, 2], ["bobus", 6, 2]]
+          args = [{type: :noun, stem: "bov", inflection_class: 3, sexus: :m, irregular_forms: irregular, additional_forms: additional}]
+          forms = LLT::FormBuilder.build(*args)
+          # forms.first = all forms of the one stem it was initialized with
+          bubus = forms[11] # ablative plural
+          bubus.stem.should == "bu"
+          bubus.ending.should == "bus"
+          bubus.sexus.should == :m
+        end
+      end
+
+
+      context "with options that select a specfic form given in a stem" do
+        it "returns only forms specified in options" do
+          with_noun_options(numerus: 2).should have(6).items
+          with_noun_options(casus: 2).should have(2).items
+          with_noun_options(numerus: 1, casus: 2).should have(1).item
+        end
+
+        it "works with irregulars as well" do
+          irregular = [["bos", 1, 1], ["boum", 2, 2], ["bubus", 3, 2], ["bubus", 6, 2]]
+          additional =  [["bobus", 3, 2], ["bobus", 6, 2]]
+          options = { numerus: 1 }
+          args = [{type: :noun, stem: "bov", inflection_class: 3, sexus: :m,
+            irregular_forms: irregular, additional_forms: additional, options: options}]
+          forms = LLT::FormBuilder.build(*args)
+          forms.should have(6).items
+        end
+
+        context "with special nominatives" do
+          it "homo" do
+            options = { numerus: 1, casus: 1 }
+            args = [{type: :noun, nominative: "hŏmō", stem: "hŏmĭn", inflection_class: 3, sexus: :m, options: options}]
+            forms = LLT::FormBuilder.build(*args)
+            forms.should have(1).item
+          end
+
+          it "magister" do
+            options = { numerus: 1, casus: 1 }
+            args = [{type: :noun, nominative: "magister", stem: "magistr", inflection_class: 1, sexus: :m, options: options}]
+            forms = LLT::FormBuilder.build(*args)
+            forms.should have(1).item
+          end
+
+          it "vir" do
+            options = { numerus: 1, casus: 1 }
+            args = [{type: :noun, nominative: "vir", stem: "vir", inflection_class: 2, sexus: :m, options: options}]
+            forms = LLT::FormBuilder.build(*args)
+            forms.should have(1).item
+          end
+        end
+
+        context "with special vocatives" do
+          it "fili" do
+            options = { casus: 5, numerus: 1}
+            args = { type: :noun, nom: "filius", stem: "fili", itype: 2, sexus: :m, options: options }
+            forms = LLT::FormBuilder.build(args)
+            forms.should have(1).item
+            forms.first.to_s(:segmentized).should == "fili"
+          end
+        end
+      end
+
+      context "with a metrical stem" do
+        it "builds all forms as metrical utf8 strings" do
+          args = [{type: :noun, nominative: "hŏmō", stem: "hŏmĭn", inflection_class: 3, sexus: :m}]
+          form_builder_strings(args).should == %w(hŏmō hŏmĭnĭs hŏmĭnī hŏmĭnĕm hŏmō hŏmĭnĕ hŏmĭnēs hŏmĭnŭm hŏmĭnĭbŭs hŏmĭnēs hŏmĭnēs hŏmĭnĭbŭs)
+        end
+      end
+
+      it "initializes Word objects with inflection class" do
+        args = [{type: :noun, stem: "ros", inflection_class: 1, sexus: :f}]
+        forms = LLT::FormBuilder.build(*args)
+        # forms.first = all forms of the one stem it was initialized with
+        rosa = forms.first
+        rosa.inflection_class.should == 1
+      end
+
+      it "makes use of LLT::Helpers::Normalizer" do
+        args = [{type: :noun, stem: "ros", itype: 1, "gender" => :f}]
+        forms = LLT::FormBuilder.build(*args)
+        forms.map(&:to_s).should == %w(rosa rosae rosae rosam rosa rosa rosae rosarum rosis rosas rosae rosis)
+        rosa = forms.first
+        rosa.sexus.should == :f
+      end
+
+      context "with options that indicate the word's components" do
+        it "builds correct forms only (one possibility)" do
+          res = with_noun_options(ending: "am")
+          res.should have(1).item
+          res.first.casus.should == 4
+          res.first.numerus.should == 1
+        end
+
+        it "builds correct forms only (several possibilities)" do
+          res = with_noun_options(ending: "a")
+          res.should have(3).item
+
+          rosa_nom = res.first
+          rosa_abl = res[2]
+
+          rosa_nom.casus.should == 1
+          rosa_abl.casus.should == 6
+        end
+
+        it "doesn't build incorrect forms" do
+          res = with_noun_options(ending: "um")
+          res.should be_empty
+        end
+
+        context "with special nominatives, where ending is an empty string" do
+          it "homo" do
+            options = { ending: "" }
+            args = [{type: :noun, nominative: "hŏmō", stem: "hŏmĭn", inflection_class: 3, sexus: :m, options: options}]
+            forms = LLT::FormBuilder.build(*args)
+            forms.should have(2).items
+          end
+
+          it "magister" do
+            options = { ending: "" }
+            args = [{type: :noun, nominative: "magister", stem: "magistr", inflection_class: 2, sexus: :m, options: options}]
+            forms = LLT::FormBuilder.build(*args)
+            forms.should have(2).items
+          end
+
+          it "vir" do
+            options = { ending: "" }
+            args = [{type: :noun, nominative: "vir", stem: "vir", inflection_class: 2, sexus: :m, options: options}]
+            forms = LLT::FormBuilder.build(*args)
+            forms.should have(2).item
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/llt/form_builder/personal_pronoun_builder_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  describe ".build" do
+    context "with personal pronouns" do
+      context "builds all forms" do
+        it "of ego" do
+          arg = { type: :personal_pronoun, inflection_class: :ego }
+          forms = LLT::FormBuilder.build(arg)
+          forms.should have(11).items
+          forms.map(&:to_s).should =~ %w{ ego mei mihi me me mecum egomet memet mihimet meimet memet}
+          forms.map(&:numerus).all? { |n| n == 1}.should be_true
+        end
+
+        it "of tu" do
+          arg = { type: :personal_pronoun, inflection_class: :tu }
+          forms = LLT::FormBuilder.build(arg)
+          forms.should have(10).items
+          forms.map(&:to_s).should =~ %w{ tu tui tibi te te tecum tute tete tete tibimet }
+          forms.map(&:numerus).all? { |n| n == 1}.should be_true
+        end
+
+        it "of nos" do
+          arg = { type: :personal_pronoun, inflection_class: :nos }
+          forms = LLT::FormBuilder.build(arg)
+          forms.map(&:to_s).should =~ %w{ nos nostri nostrum nobis nos nobis nobiscum nosmet nosmet nobismet nobismet }
+          forms.map(&:numerus).all? { |n| n == 2}.should be_true
+        end
+
+        it "of vos" do
+          arg = { type: :personal_pronoun, inflection_class: :vos }
+          forms = LLT::FormBuilder.build(arg)
+          forms.should have(11).items
+          forms.map(&:to_s).should =~ %w{ vos vestri vostrum vobis vos vobis vobiscum vosmet vosmet vobismet vobismet }
+          forms.map(&:numerus).all? { |n| n == 2}.should be_true
+        end
+
+        it "of se - sg. & pl." do
+          arg = { type: :personal_pronoun, inflection_class: :se }
+          forms = LLT::FormBuilder.build(arg)
+          forms.should have(14).items
+          forms.map(&:to_s).should =~ %w{ sui sibi se sese se secum sese } * 2
+          forms[0..6] .map(&:numerus).all? { |n| n == 1}.should be_true
+          forms[7..14].map(&:numerus).all? { |n| n == 2}.should be_true
+        end
+      end
+    end
+  end
+end

data/spec/lib/llt/form_builder/ppa_builder_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  include LLT::Helpers::Normalizer
+
+  describe ".build" do
+    def form_builder_strings(args)
+      forms = LLT::FormBuilder.build(*args)
+      forms.map(&:to_s)
+    end
+
+    def with_ppa(options)
+      args = [{type: :ppa, stem: "ama", inflection_class: 1, options: options}]
+      LLT::FormBuilder.build(*args)
+    end
+
+    context "with ppas" do
+      context "build all forms" do
+        it "a conj" do
+          args = [{type: :ppa, stem: "ama", inflection_class: 1, tense: :pr}]
+          form_builder_strings(args).should == %w{ amans amantis amanti amantem amans amante amantes amantium amantibus amantes amantes amantibus
+                                                   amans amantis amanti amantem amans amante amantes amantium amantibus amantes amantes amantibus
+                                                   amans amantis amanti amans amans amante amantia amantium amantibus amantia amantia amantibus }
+        end
+
+        it "e conj" do
+          args = [{type: :ppa, stem: "mone", inflection_class: 2, tense: :pr}]
+          form_builder_strings(args).should == %w{ monens monentis monenti monentem monens monente monentes monentium monentibus monentes monentes monentibus
+                                                   monens monentis monenti monentem monens monente monentes monentium monentibus monentes monentes monentibus
+                                                   monens monentis monenti monens monens monente monentia monentium monentibus monentia monentia monentibus }
+        end
+
+        it "c conj" do
+          args = [{type: :ppa, stem: "leg", inflection_class: 3, tense: :pr}]
+          form_builder_strings(args).should == %w{ legens legentis legenti legentem legens legente legentes legentium legentibus legentes legentes legentibus
+                                                   legens legentis legenti legentem legens legente legentes legentium legentibus legentes legentes legentibus
+                                                   legens legentis legenti legens legens legente legentia legentium legentibus legentia legentia legentibus }
+        end
+
+        it "i conj" do
+          args = [{type: :ppa, stem: "audi", inflection_class: 4, tense: :pr}]
+          form_builder_strings(args).should == %w{ audiens audientis audienti audientem audiens audiente audientes audientium audientibus audientes audientes audientibus
+                                                   audiens audientis audienti audientem audiens audiente audientes audientium audientibus audientes audientes audientibus
+                                                   audiens audientis audienti audiens audiens audiente audientia audientium audientibus audientia audientia audientibus }
+        end
+
+        it "m conj" do
+          args = [{type: :ppa, stem: "cap", inflection_class: 5, tense: :pr}]
+          form_builder_strings(args).should == %w{ capiens capientis capienti capientem capiens capiente capientes capientium capientibus capientes capientes capientibus
+                                                   capiens capientis capienti capientem capiens capiente capientes capientium capientibus capientes capientes capientibus
+                                                   capiens capientis capienti capiens capiens capiente capientia capientium capientibus capientia capientia capientibus }
+        end
+      end
+
+      context "with options that select a specfic form given in a stem" do
+      end
+
+      context "with options that indicate the word's components" do
+        context "builds correct forms only" do
+
+          it "amantis" do
+            res = with_ppa(ending: "is", ppa_fp_or_gerund: "nt")
+            res.should have(3).items
+            amantis1, amantis2, amantis3 = res
+            amantis1.sexus.should == :m
+            amantis2.sexus.should == :f
+            amantis3.sexus.should == :n
+
+            amantis1.modus.should == t.participium
+            amantis1.tempus.should == t.praesens
+
+            amantis1.stem.should == "ama"
+            amantis1.ending.should == "is"
+            amantis1.to_s.should == "amantis"
+            amantis1.to_s(:segmentized).should == "ama-nt-is"
+          end
+
+          context "with validate flag" do
+            it "ama-nt-is" do
+              options = { ending: "is", extension: "nt", validate: true }
+              args = [{type: :ppa, stem: "ama", inflection_class: 1, tense: :pr, options: options}]
+              forms = LLT::FormBuilder.build(*args)
+              forms.should have(3).items
+            end
+
+            context "wrong forms" do
+              it "ama-nt-is - no extension given" do
+                options = { ending: "is", validate: true }
+                args = [{type: :ppa, stem: "ama", inflection_class: 1, tense: :pr, options: options}]
+                forms = LLT::FormBuilder.build(*args)
+                forms.should have(0).items
+              end
+
+              it "*cap-e-nt-is" do
+                options = { thematic: "e", validate: true }
+                args = [{type: :ppa, stem: "cap", inflection_class: 5, tense: :pr, options: options}]
+                forms = LLT::FormBuilder.build(*args)
+                forms.should be_empty
+              end
+
+              it "*cap-nt-is" do
+                options = { ending: "is", validate: true }
+                args = [{type: :ppa, stem: "cap", inflection_class: 5, tense: :pr, options: options}]
+                forms = LLT::FormBuilder.build(*args)
+                forms.should be_empty
+              end
+
+              it "*ama-e-nt-is" do
+                options = { ending: "is", thematic: "e", validate: true }
+                args = [{type: :ppa, stem: "ama", inflection_class: 1, tense: :pr, options: options}]
+                forms = LLT::FormBuilder.build(*args)
+                forms.should be_empty
+              end
+
+              it "*aud-ie-nt-is" do
+                options = { ending: "is", thematic: "ie", validate: true }
+                args = [{type: :ppa, stem: "aud", inflection_class: 1, tense: :pr, options: options}]
+                forms = LLT::FormBuilder.build(*args)
+                forms.should be_empty
+              end
+            end
+          end
+
+          it "audi-e-nt-is" do
+            options = { ending: "is", thematic: "e" }
+            args = [{type: :ppa, stem: "audi", inflection_class: 4, tense: :pr, options: options}]
+            forms = LLT::FormBuilder.build(*args)
+            forms.should have(3).items
+            forms.first.to_s.should == "audientis"
+            forms.first.to_s(:segmentized).should == "audi-e-nt-is"
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/llt/form_builder/ppp_builder_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  include LLT::Helpers::Normalizer
+
+  describe ".build" do
+    def form_builder_strings(args)
+      forms = LLT::FormBuilder.build(*args)
+      forms.map(&:to_s)
+    end
+
+    context "with ppp" do
+      context "build all forms" do
+        it "a conj" do
+          args = [{type: :ppp, stem: "amat", inflection_class: 1, options: { tempus: :pf }}]
+          form_builder_strings(args).should == %w{ amatus amati amato amatum amate amato amati amatorum amatis amatos amati amatis
+                                                   amata amatae amatae amatam amata amata amatae amatarum amatis amatas amatae amatis
+                                                   amatum amati amato amatum amatum amato amata amatorum amatis amata amata amatis }
+        end
+      end
+
+      context "with options that select a specfic form given in a stem" do
+        it "builds correct forms only (several possibilities)" do
+          options = { casus: 3, numerus: 2 }
+          args = [{type: :ppp, stem: "amat", inflection_class: 1, options: options}]
+          forms = LLT::FormBuilder.build(*args)
+
+          forms.should have(6).items # 3 forms ppp, 3 forms fp
+          form = forms.first
+
+          form.casus.should == 3
+          form.numerus.should == 2
+          form.sexus.should == :m
+
+          form.participium?.should be_true
+          form.part?.should be_true
+          form.participle?.should be_true
+
+          form.tempus.should == t.pf
+          form.genus.should  == t.passivum
+        end
+      end
+    end
+  end
+end

data/spec/lib/llt/form_builder/pronoun_builder_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe LLT::FormBuilder do
+  def form_builder_strings(args)
+    forms = LLT::FormBuilder.build(*args)
+    forms.map(&:to_s)
+  end
+
+  context "with hic" do
+    it "builds all forms" do
+      args = [{type: :pronoun, inflection_class: :hic}]
+      form_builder_strings(args).should == %w{ hic huius huic hunc hoc hi horum his hos his
+                                               haec huius huic hanc hac hae harum his has his
+                                               hoc huius huic hoc hoc haec horum his haec his }
+    end
+
+    it "can build specified forms only" do
+      args = {type: :pronoun, inflection_class: :hic, options: { casus: 4 }}
+      forms = LLT::FormBuilder.build(args)
+      forms.should have(6).items
+      forms.first.casus.should == 4
+    end
+
+    it "prints particles as distinct segment" do
+      args = {type: :pronoun, inflection_class: :hic, options: { casus: 4, numerus: 1, sexus: :m }}
+      forms = LLT::FormBuilder.build(args)
+      forms.should have(1).item
+      forms.first.to_s(:segmentized).should == "h-un-c"
+    end
+
+    it "works with morphologizer style options" do
+      args = {type: :pronoun, inflection_class: :hic, options: { ending: "is" }}
+      forms = LLT::FormBuilder.build(args)
+      forms.should have(6).item
+    end
+  end
+
+  context "with ille" do
+    it "builds all forms" do
+      args = [{type: :pronoun, inflection_class: :ille}]
+      form_builder_strings(args).should == %w{ ille illius illi illum illo illi illorum illis illos illis
+                                               illa illius illi illam illa illae illarum illis illas illis
+                                               illud illius illi illud illo illa illorum illis illa illis }
+    end
+  end
+
+  context "with iste" do
+    it "builds all forms" do
+      args = [{type: :pronoun, inflection_class: :iste}]
+      form_builder_strings(args).should == %w{ iste istius isti istum isto isti istorum istis istos istis
+                                               ista istius isti istam ista istae istarum istis istas istis
+                                               istud istius isti istud isto ista istorum istis ista istis }
+    end
+  end
+
+  context "with ipse" do
+    it "builds all forms" do
+      args = [{type: :pronoun, inflection_class: :ipse}]
+      form_builder_strings(args).should == %w{ ipse ipsius ipsi ipsum ipso ipsi ipsorum ipsis ipsos ipsis
+                                               ipsa ipsius ipsi ipsam ipsa ipsae ipsarum ipsis ipsas ipsis
+                                               ipsum ipsius ipsi ipsum ipso ipsa ipsorum ipsis ipsa ipsis }
+    end
+  end
+
+  context "with qui" do
+    it "builds all forms" do
+      args = [{type: :pronoun, inflection_class: :qui}]
+      form_builder_strings(args).should == %w{ qui cuius cui quem quo quocum qui quorum quibus quos quibus quibuscum
+                                               quae cuius cui quam qua quacum quae quarum quibus quas quibuscum quibus
+                                               quod cuius cui quod quo quocum quae quorum quibus quae quibus quibuscum }
+    end
+
+    it "builds only correct forms - qua" do
+      opts = { stem: "qu", ending: "a", validate: true}
+      args = {type: :pronoun, inflection_class: :qui, options: opts}
+      forms = LLT::FormBuilder.build(args)
+      forms.should have(1).item
+      qua = forms.first
+      qua.to_s(:segmentized).should == "qu-a"
+      qua.casus.should == 6
+      qua.numerus.should == 1
+      qua.sexus.should == :f
+    end
+
+    it "builds only correct forms - quibuscum" do
+      opts = { stem: "qu", ending: "ibus", suffix: "cum", validate: true}
+      args = {type: :pronoun, inflection_class: :qui, options: opts}
+      forms = LLT::FormBuilder.build(args)
+      forms.should have(3).item
+      forms.map(&:casus).should == [6] * 3
+      forms.map(&:numerus).should == [2] * 3
+      forms.map(&:sexus).should == %i{ m f n }
+      forms.map { |f| f.to_s(:segmentized) }.should == %w{ qu-ibus-cum } * 3
+    end
+  end
+
+  context "with quisquam" do
+    context "with options" do
+      it "builds only correct forms" do
+        opts = { stem: "qu", ending: "ic", particle: "quam" }
+        args = { type: :pronoun, inflection_class: :quisquam, options: opts}
+        forms = LLT::FormBuilder.build(args)
+        forms.should have(2).items
+        forms.map { |f| f.to_s(true) }.should == %w{ qu-ic-quam } * 2
+      end
+    end
+  end
+
+  context "with quisquis" do
+    context "with options" do
+      it "builds only correct forms" do
+        opts = { stem: "qu", ending: "ic", particle: "quid" }
+        args = { type: :pronoun, inflection_class: :quisquis, options: opts}
+        forms = LLT::FormBuilder.build(args)
+        forms.should have(2).items
+        forms.map { |f| f.to_s(true) }.should == %w{ qu-ic-quid } * 2
+      end
+    end
+  end
+
+  context "with aliqui" do
+    it "builds all forms" do
+      args = [{type: :pronoun, inflection_class: :aliqui}]
+      form_builder_strings(args).should == %w{ aliqui alicuius alicui aliquem aliquo aliqui aliquorum aliquibus aliquos aliquibus
+                                               aliqua alicuius alicui aliquam aliqua aliquae aliquarum aliquibus aliquas aliquibus
+                                               aliquod alicuius alicui aliquod aliquo aliquae aliquorum aliquibus aliquae aliquibus }
+    end
+  end
+
+  context "with quicumque" do
+    it "builds all forms" do
+      args = [{type: :pronoun, inflection_class: :quicumque}]
+      form_builder_strings(args).should == %w{ quicumque cuiuscumque cuicumque quemcumque quocumque quicumque quorumcumque quibuscumque quoscumque quibuscumque
+                                               quaecumque cuiuscumque cuicumque quamcumque quacumque quaecumque quarumcumque quibuscumque quascumque quibuscumque
+                                               quodcumque cuiuscumque cuicumque quodcumque quocumque quaecumque quorumcumque quibuscumque quaecumque quibuscumque }
+    end
+  end
+
+  context "with uterque" do
+    it "builds all forms" do
+      args = [{type: :pronoun, inflection_class: :uterque}]
+      form_builder_strings(args).should == %w{ uterque utriusque utrique utrumque utroque utrique utrorumque utrisque utrosque utrisque
+                                               utraque utriusque utrique utramque utraque utraeque utrarumque utrisque utrasque utrisque
+                                               utrumque utriusque utrique utrumque utroque utraque utrorumque utrisque utraque utrisque }
+    end
+  end
+
+  context "with is" do
+    it "builds all forms" do
+      pending
+      args = [{type: :pronoun, inflection_class: :is}]
+      form_builder_strings(args).should == %w{}
+    end
+
+    it "builds only correct forms" do
+      opts = { stem: "E", ending: "o"}
+      args = [{type: :pronoun, inflection_class: :is, options: opts}]
+      form_builder_strings(args).should include("eo")
+    end
+
+    context "with alternate forms" do
+      def strings_of(stem, ending)
+        opts = { stem: stem, ending: ending, validate: true }
+        args = [{type: :pronoun, inflection_class: :is, options: opts}]
+        form_builder_strings(args)
+      end
+
+      it "works with is, iis and eis" do
+        strings_of("i", "s") .should == %w{ is }  * 7 # nom m as well!
+        strings_of("i", "is").should == %w{ iis } * 6
+        strings_of("e", "is").should == %w{ eis } * 6
+      end
+    end
+  end
+
+  context "with idem" do
+    it "builds all forms" do
+      pending
+      args = [{type: :pronoun, inflection_class: :isdem}]
+      form_builder_strings(args).should == %{}
+    end
+
+    context "with alternating forms" do
+      def strings_of(stem, ending)
+        opts = { stem: stem, ending: ending, particle: "dem", validate: true }
+        args = [{type: :pronoun, inflection_class: :idem, options: opts}]
+        form_builder_strings(args)
+      end
+
+      it "builds only correct forms of is" do
+        strings_of("i", "s").should == %w{ isdem } * 6
+      end
+
+      it "builds only correct forms of eis" do
+        strings_of("e", "is").should == %w{ eisdem } * 6
+      end
+
+      it "builds only correct forms of iis" do
+        strings_of("i", "is").should == %w{ iisdem } * 6
+      end
+    end
+  end
+end