ruby_speech 2.1.0-java

data/spec/ruby_speech/ssml/audio_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+module RubySpeech
+  module SSML
+    describe Audio do
+      its(:name) { should == 'audio' }
+
+      describe "setting options in initializers" do
+        subject { Audio.new :src => 'http://whatever.you-say-boss.com', :content => 'Hello' }
+
+        its(:src)     { should == 'http://whatever.you-say-boss.com' }
+        its(:content) { should == 'Hello' }
+      end
+
+      it 'registers itself' do
+        Element.class_from_registration(:audio).should == Audio
+      end
+
+      describe "from a document" do
+        let(:document) { '<audio src="http://whatever.you-say-boss.com">Hello</audio>' }
+
+        subject { Element.import document }
+
+        it { should be_instance_of Audio }
+
+        its(:src)     { should == 'http://whatever.you-say-boss.com' }
+        its(:content) { should == 'Hello' }
+      end
+
+      describe "#src" do
+        before { subject.src = 'http://whatever.you-say-boss.com' }
+
+        its(:src) { should == 'http://whatever.you-say-boss.com' }
+      end
+
+      describe "#content" do
+        context "with a valid value" do
+          before { subject.content = "Hello" }
+
+          its(:content) { should == "Hello" }
+        end
+      end
+
+      describe "<<" do
+        it "should accept String" do
+          lambda { subject << 'anything' }.should_not raise_error
+        end
+
+        it "should accept Audio" do
+          lambda { subject << Audio.new }.should_not raise_error
+        end
+
+        it "should accept Break" do
+          lambda { subject << Break.new }.should_not raise_error
+        end
+
+        it "should accept Desc" do
+          lambda { subject << Desc.new }.should_not raise_error
+        end
+
+        it "should accept Emphasis" do
+          lambda { subject << Emphasis.new }.should_not raise_error
+        end
+
+        it "should accept Mark" do
+          lambda { subject << Mark.new }.should_not raise_error
+        end
+
+        it "should accept P" do
+          lambda { subject << P.new }.should_not raise_error
+        end
+
+        it "should accept Phoneme" do
+          lambda { subject << Phoneme.new }.should_not raise_error
+        end
+
+        it "should accept Prosody" do
+          lambda { subject << Prosody.new }.should_not raise_error
+        end
+
+        it "should accept SayAs" do
+          lambda { subject << SayAs.new(:interpret_as => :foo) }.should_not raise_error
+        end
+
+        it "should accept Sub" do
+          lambda { subject << Sub.new }.should_not raise_error
+        end
+
+        it "should accept S" do
+          lambda { subject << S.new }.should_not raise_error
+        end
+
+        it "should accept Voice" do
+          lambda { subject << Voice.new }.should_not raise_error
+        end
+
+        it "should raise InvalidChildError with non-acceptable objects" do
+          lambda { subject << 1 }.should raise_error(InvalidChildError, "An Audio can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
+        end
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the content, and src are the same" do
+          Audio.new(:src => "one", :content => "Hello there").should == Audio.new(:src => "one", :content => "Hello there")
+        end
+
+        describe "when the content is different" do
+          it "should not be equal" do
+            Audio.new(:content => "Hello").should_not == Audio.new(:content => "Hello there")
+          end
+        end
+
+        describe "when the src is different" do
+          it "should not be equal" do
+            Audio.new(:src => 'one').should_not == Audio.new(:src => 'two')
+          end
+        end
+      end
+    end # Break
+  end # SSML
+end # RubySpeech

data/spec/ruby_speech/ssml/break_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+module RubySpeech
+  module SSML
+    describe Break do
+      its(:name) { should == 'break' }
+
+      describe "setting options in initializers" do
+        subject { Break.new :strength => :strong, :time => 3.seconds }
+
+        its(:strength)  { should == :strong }
+        its(:time)      { should == 3.seconds }
+      end
+
+      it 'registers itself' do
+        Element.class_from_registration(:break).should == Break
+      end
+
+      describe "from a document" do
+        let(:document) { '<break strength="strong" time="3"/>' }
+
+        subject { Element.import document }
+
+        it { should be_instance_of Break }
+
+        its(:strength)  { should == :strong }
+        its(:time)      { should == 3.seconds }
+      end
+
+      describe "#strength" do
+        before { subject.strength = :strong }
+
+        its(:strength) { should == :strong }
+
+        it "with a valid level" do
+          lambda { subject.strength = :none }.should_not raise_error
+          lambda { subject.strength = :'x-weak' }.should_not raise_error
+          lambda { subject.strength = :weak }.should_not raise_error
+          lambda { subject.strength = :medium }.should_not raise_error
+          lambda { subject.strength = :strong }.should_not raise_error
+          lambda { subject.strength = :'x-strong' }.should_not raise_error
+        end
+
+        it "with an invalid strength" do
+          lambda { subject.strength = :something }.should raise_error(ArgumentError, "You must specify a valid strength (:none, :\"x-weak\", :weak, :medium, :strong, :\"x-strong\")")
+        end
+      end
+
+      describe "#time" do
+        context "with a valid value" do
+          before { subject.time = 3.seconds }
+
+          its(:time) { should == 3.seconds }
+        end
+
+        context "with a negative value" do
+          it do
+            lambda { subject.time = -3.seconds }.should raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
+          end
+        end
+
+        context "with an invalid value" do
+          it do
+            lambda { subject.time = 'blah' }.should raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
+          end
+        end
+      end
+
+      describe "<<" do
+        it "should always raise InvalidChildError" do
+          lambda { subject << 'anything' }.should raise_error(InvalidChildError, "A Break cannot contain children")
+        end
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the content, strength and base uri are the same" do
+          Break.new(:strength => :strong, :time => 1.second, :content => "Hello there").should == Break.new(:strength => :strong, :time => 1.second, :content => "Hello there")
+        end
+
+        describe "when the content is different" do
+          it "should not be equal" do
+            Break.new(:content => "Hello").should_not == Break.new(:content => "Hello there")
+          end
+        end
+
+        describe "when the strength is different" do
+          it "should not be equal" do
+            Break.new(:strength => :strong).should_not == Break.new(:strength => :weak)
+          end
+        end
+
+        describe "when the time is different" do
+          it "should not be equal" do
+            Break.new(:time => 1.second).should_not == Break.new(:time => 2.seconds)
+          end
+        end
+      end
+    end # Break
+  end # SSML
+end # RubySpeech

data/spec/ruby_speech/ssml/desc_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module RubySpeech
+  module SSML
+    describe Desc do
+      its(:name) { should == 'desc' }
+
+      describe "setting options in initializers" do
+        subject { Desc.new :language => 'foo' }
+
+        its(:language) { should == 'foo' }
+      end
+
+      it 'registers itself' do
+        Element.class_from_registration(:desc).should == Desc
+      end
+
+      describe "from a document" do
+        let(:document) { '<desc xml:lang="en"/>' }
+
+        subject { Element.import document }
+
+        it { should be_instance_of Desc }
+
+        its(:language) { should == 'en' }
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the content and language are the same" do
+          Desc.new(:language => 'jp', :content => "Hello there").should == Desc.new(:language => 'jp', :content => "Hello there")
+        end
+
+        describe "when the content is different" do
+          it "should not be equal" do
+            Desc.new(:content => "Hello").should_not == Desc.new(:content => "Hello there")
+          end
+        end
+
+        describe "when the language is different" do
+          it "should not be equal" do
+            Desc.new(:language => 'jp').should_not == Desc.new(:language => 'en')
+          end
+        end
+      end
+
+      describe "<<" do
+        it "should accept String" do
+          lambda { subject << 'anything' }.should_not raise_error
+        end
+
+        it "should raise InvalidChildError with non-acceptable objects" do
+          lambda { subject << Voice.new }.should raise_error(InvalidChildError, "A Desc can only accept Strings as children")
+        end
+      end
+    end # Desc
+  end # SSML
+end # RubySpeech

data/spec/ruby_speech/ssml/emphasis_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+module RubySpeech
+  module SSML
+    describe Emphasis do
+      its(:name) { should == 'emphasis' }
+
+      describe "setting options in initializers" do
+        subject { Emphasis.new :level => :strong }
+
+        its(:level) { should == :strong }
+      end
+
+      it 'registers itself' do
+        Element.class_from_registration(:emphasis).should == Emphasis
+      end
+
+      describe "from a document" do
+        let(:document) { '<emphasis level="strong"/>' }
+
+        subject { Element.import document }
+
+        it { should be_instance_of Emphasis }
+
+        its(:level) { should == :strong }
+      end
+
+      describe "#level" do
+        before { subject.level = :strong }
+
+        its(:level) { should == :strong }
+
+        it "with a valid level" do
+          lambda { subject.level = :strong }.should_not raise_error
+          lambda { subject.level = :moderate }.should_not raise_error
+          lambda { subject.level = :none }.should_not raise_error
+          lambda { subject.level = :reduced }.should_not raise_error
+        end
+
+        it "with an invalid level" do
+          lambda { subject.level = :something }.should raise_error(ArgumentError, "You must specify a valid level (:strong, :moderate, :none, :reduced)")
+        end
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the content and level are the same" do
+          Emphasis.new(:level => :strong, :content => "Hello there").should == Emphasis.new(:level => :strong, :content => "Hello there")
+        end
+
+        describe "when the content is different" do
+          it "should not be equal" do
+            Emphasis.new(:content => "Hello").should_not == Emphasis.new(:content => "Hello there")
+          end
+        end
+
+        describe "when the level is different" do
+          it "should not be equal" do
+            Emphasis.new(:level => :strong).should_not == Emphasis.new(:level => :reduced)
+          end
+        end
+      end
+
+      describe "<<" do
+        it "should accept String" do
+          lambda { subject << 'anything' }.should_not raise_error
+        end
+
+        it "should accept Audio" do
+          lambda { subject << Audio.new }.should_not raise_error
+        end
+
+        it "should accept Break" do
+          lambda { subject << Break.new }.should_not raise_error
+        end
+
+        it "should accept Emphasis" do
+          lambda { subject << Emphasis.new }.should_not raise_error
+        end
+
+        it "should accept Mark" do
+          lambda { subject << Mark.new }.should_not raise_error
+        end
+
+        it "should accept Phoneme" do
+          lambda { subject << Phoneme.new }.should_not raise_error
+        end
+
+        it "should accept Prosody" do
+          lambda { subject << Prosody.new }.should_not raise_error
+        end
+
+        it "should accept SayAs" do
+          lambda { subject << SayAs.new(:interpret_as => :foo) }.should_not raise_error
+        end
+
+        it "should accept Sub" do
+          lambda { subject << Sub.new }.should_not raise_error
+        end
+
+        it "should accept Voice" do
+          lambda { subject << Voice.new }.should_not raise_error
+        end
+
+        it "should raise InvalidChildError with non-acceptable objects" do
+          lambda { subject << 1 }.should raise_error(InvalidChildError, "An Emphasis can only accept String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, Voice as children")
+        end
+      end
+    end # Emphasis
+  end # SSML
+end # RubySpeech

data/spec/ruby_speech/ssml/mark_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module RubySpeech
+  module SSML
+    describe Mark do
+      its(:node_name) { should == 'mark' }
+
+      describe "setting options in initializers" do
+        subject { Mark.new :name => 'foo' }
+
+        its(:name)  { should == 'foo' }
+      end
+
+      it 'registers itself' do
+        Element.class_from_registration(:mark).should == Mark
+      end
+
+      describe "from a document" do
+        let(:document) { '<mark name="foo"/>' }
+
+        subject { Element.import document }
+
+        it { should be_instance_of Mark }
+
+        its(:name)  { should == 'foo' }
+      end
+
+      describe "#name" do
+        before { subject.name = 'foo' }
+
+        its(:name) { should == 'foo' }
+      end
+
+      describe "<<" do
+        it "should always raise InvalidChildError" do
+          lambda { subject << 'anything' }.should raise_error(InvalidChildError, "A Mark cannot contain children")
+        end
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the name is the same" do
+          Mark.new(:name => "foo").should == Mark.new(:name => "foo")
+        end
+
+        describe "when the name is different" do
+          it "should not be equal" do
+            Mark.new(:name => "foo").should_not == Mark.new(:name => "bar")
+          end
+        end
+      end
+    end # Mark
+  end # SSML
+end # RubySpeech

data/spec/ruby_speech/ssml/p_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module RubySpeech
+  module SSML
+    describe P do
+      its(:name) { should == 'p' }
+
+      describe "setting options in initializers" do
+        subject { P.new :language => 'jp' }
+
+        its(:language) { should == 'jp' }
+      end
+
+      it 'registers itself' do
+        Element.class_from_registration(:p).should == P
+      end
+
+      describe "from a document" do
+        let(:document) { '<p>foo</p>' }
+
+        subject { Element.import document }
+
+        it { should be_instance_of P }
+        its(:content) { should == 'foo' }
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the content and language are the same" do
+          P.new(:language => 'jp', :content => "Hello there").should == P.new(:language => 'jp', :content => "Hello there")
+        end
+
+        describe "when the content is different" do
+          it "should not be equal" do
+            P.new(:content => "Hello").should_not == P.new(:content => "Hello there")
+          end
+        end
+
+        describe "when the language is different" do
+          it "should not be equal" do
+            P.new(:language => 'jp').should_not == P.new(:language => 'en')
+          end
+        end
+      end
+
+      describe "<<" do
+        it "should accept String" do
+          lambda { subject << 'anything' }.should_not raise_error
+        end
+
+        it "should accept Audio" do
+          lambda { subject << Audio.new }.should_not raise_error
+        end
+
+        it "should accept Break" do
+          lambda { subject << Break.new }.should_not raise_error
+        end
+
+        it "should accept Emphasis" do
+          lambda { subject << Emphasis.new }.should_not raise_error
+        end
+
+        it "should accept Mark" do
+          lambda { subject << Mark.new }.should_not raise_error
+        end
+
+        it "should accept Phoneme" do
+          lambda { subject << Phoneme.new }.should_not raise_error
+        end
+
+        it "should accept Prosody" do
+          lambda { subject << Prosody.new }.should_not raise_error
+        end
+
+        it "should accept SayAs" do
+          lambda { subject << SayAs.new(:interpret_as => :foo) }.should_not raise_error
+        end
+
+        it "should accept Sub" do
+          lambda { subject << Sub.new }.should_not raise_error
+        end
+
+        it "should accept S" do
+          lambda { subject << S.new }.should_not raise_error
+        end
+
+        it "should accept Voice" do
+          lambda { subject << Voice.new }.should_not raise_error
+        end
+
+        it "should raise InvalidChildError with non-acceptable objects" do
+          lambda { subject << 1 }.should raise_error(InvalidChildError, "A P can only accept String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
+        end
+      end
+    end # P
+  end # SSML
+end # RubySpeech

data/spec/ruby_speech/ssml/phoneme_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module RubySpeech
+  module SSML
+    describe Phoneme do
+      its(:name) { should == 'phoneme' }
+
+      describe "setting options in initializers" do
+        subject { Phoneme.new :alphabet => 'foo', :ph => 'bar' }
+
+        its(:alphabet) { should == 'foo' }
+        its(:ph)       { should == 'bar' }
+      end
+
+      it 'registers itself' do
+        Element.class_from_registration(:phoneme).should == Phoneme
+      end
+
+      describe "from a document" do
+        let(:document) { '<phoneme alphabet="foo" ph="bar"/>' }
+
+        subject { Element.import document }
+
+        it { should be_instance_of Phoneme }
+
+        its(:alphabet) { should == 'foo' }
+        its(:ph)       { should == 'bar' }
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the content, ph and alphabet are the same" do
+          Phoneme.new(:alphabet => 'jp', :ph => 'foo', :content => "Hello there").should == Phoneme.new(:alphabet => 'jp', :ph => 'foo', :content => "Hello there")
+        end
+
+        describe "when the content is different" do
+          it "should not be equal" do
+            Phoneme.new(:content => "Hello").should_not == Phoneme.new(:content => "Hello there")
+          end
+        end
+
+        describe "when the ph is different" do
+          it "should not be equal" do
+            Phoneme.new(:ph => 'jp').should_not == Phoneme.new(:ph => 'en')
+          end
+        end
+
+        describe "when the alphabet is different" do
+          it "should not be equal" do
+            Phoneme.new(:alphabet => 'jp').should_not == Phoneme.new(:alphabet => 'en')
+          end
+        end
+      end
+
+      describe "<<" do
+        it "should accept String" do
+          lambda { subject << 'anything' }.should_not raise_error
+        end
+
+        it "should raise InvalidChildError with non-acceptable objects" do
+          lambda { subject << Voice.new }.should raise_error(InvalidChildError, "A Phoneme can only accept Strings as children")
+        end
+      end
+    end # Desc
+  end # SSML
+end # RubySpeech