linkparser 1.0.3

data/rake/testing.rb

@@ -0,0 +1,202 @@
+# 
+# Rake tasklib for testing tasks
+# $Id: testing.rb 80 2008-12-20 19:50:19Z deveiant $
+# 
+# Authors:
+# * Michael Granger <ged@FaerieMUD.org>
+# 
+
+unless defined?( COVERAGE_MINIMUM )
+	if ENV['COVVERAGE_MINIMUM']
+		COVERAGE_MINIMUM = Float( ENV['COVERAGE_MINIMUM'] )
+	else
+		COVERAGE_MINIMUM = 85.0 
+	end
+end
+SPEC_FILES       = [] unless defined?( SPEC_FILES )
+TEST_FILES       = [] unless defined?( TEST_FILES )
+
+COMMON_SPEC_OPTS = ['-Du', '-b'] unless defined?( COMMON_SPEC_OPTS )
+
+COVERAGE_TARGETDIR = BASEDIR + 'coverage' unless defined?( COVERAGE_TARGETDIR )
+RCOV_EXCLUDES      = 'spec,tests,/Library/Ruby,/var/lib,/usr/local/lib' unless
+	defined?( RCOV_EXCLUDES )
+
+
+desc "Run all defined tests"
+task :test do
+	unless SPEC_FILES.empty?
+		log "Running specs"
+		Rake::Task['spec:quiet'].invoke
+	end
+	
+	unless TEST_FILES.empty?
+		log "Running unit tests"
+		Rake::Task[:unittests].invoke 
+	end
+end
+
+
+### RSpec specifications
+begin
+	gem 'rspec', '>= 1.1.3'
+
+	require 'spec'
+	require 'spec/rake/spectask'
+
+	### Task: spec
+	task :spec => 'spec:doc'
+
+	namespace :spec do
+		desc "Run rspec every time there's a change to one of the files"
+		task :autotest do
+			require 'autotest/rspec'
+
+			autotester = Autotest::Rspec.new
+			autotester.run
+		end
+
+		desc "Generate regular color 'doc' spec output"
+		Spec::Rake::SpecTask.new( :doc ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 's', '-c']
+		end
+
+		desc "Generate spec output with profiling"
+		Spec::Rake::SpecTask.new( :profile ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 'o']
+		end
+
+		desc "Generate quiet non-colored plain-text output"
+		Spec::Rake::SpecTask.new( :quiet ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 'p']
+		end
+
+		desc "Generate HTML output"
+		Spec::Rake::SpecTask.new( :html ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = COMMON_SPEC_OPTS + ['-f', 'h']
+		end
+
+	end
+rescue LoadError => err
+	task :no_rspec do
+		$stderr.puts "Specification tasks not defined: %s" % [ err.message ]
+	end
+
+	task :spec => :no_rspec
+	namespace :spec do
+		task :autotest => :no_rspec
+		task :doc => :no_rspec
+		task :profile => :no_rspec
+		task :quiet => :no_rspec
+		task :html => :no_rspec
+	end
+end
+
+
+### Test::Unit tests
+begin
+	require 'rake/testtask'
+	
+	Rake::TestTask.new( :unittests ) do |task|
+		task.libs += [LIBDIR]
+		task.test_files = TEST_FILES
+		task.verbose = true
+	end
+
+rescue LoadError => err
+	task :no_test do
+		$stderr.puts "Test tasks not defined: %s" % [ err.message ]
+	end
+
+	task :unittests => :no_rspec
+end
+
+	
+### RCov (via RSpec) tasks
+begin
+	gem 'rcov'
+	gem 'rspec', '>= 1.1.3'
+
+	require 'spec'
+	require 'rcov'
+
+	### Task: coverage (via RCov)
+	desc "Build test coverage reports"
+	unless SPEC_FILES.empty?
+		Spec::Rake::SpecTask.new( :coverage ) do |task|
+			task.spec_files = SPEC_FILES
+			task.libs += [LIBDIR]
+			task.spec_opts = ['-f', 'p', '-b']
+			task.rcov_opts = RCOV_OPTS
+			task.rcov = true
+		end
+	end
+# 	unless TEST_FILES.empty?
+# 		require 'rcov/rcovtask'
+
+# 		Rcov::RcovTask.new do |task|
+# 			task.libs += [LIBDIR]
+# 			task.test_files = TEST_FILES
+# 			task.verbose = true
+# 			task.rcov_opts = RCOV_OPTS
+# 		end
+# 	end
+
+
+	### Task: rcov
+	task :rcov => :coverage
+
+	### Other coverage tasks
+	namespace :coverage do
+		desc "Generate a detailed text coverage report"
+		Spec::Rake::SpecTask.new( :text ) do |task|
+			task.spec_files = SPEC_FILES
+			task.rcov_opts = RCOV_OPTS + ['--text-report']
+			task.rcov = true
+		end
+
+		desc "Show differences in coverage from last run"
+		Spec::Rake::SpecTask.new( :diff ) do |task|
+			task.spec_files = SPEC_FILES
+			task.spec_opts = ['-f', 'p', '-b']
+			task.rcov_opts = RCOV_OPTS - ['--save'] + ['--text-coverage-diff']
+			task.rcov = true
+		end
+
+		### Task: verify coverage
+		desc "Build coverage statistics"
+		VerifyTask.new( :verify => :rcov ) do |task|
+			task.threshold = COVERAGE_MINIMUM
+		end
+
+		desc "Run RCov in 'spec-only' mode to check coverage from specs"
+		Spec::Rake::SpecTask.new( :speconly ) do |task|
+			task.spec_files = SPEC_FILES
+			task.rcov_opts = ['--exclude', RCOV_EXCLUDES, '--text-report', '--save']
+			task.rcov = true
+		end
+	end
+
+	CLOBBER.include( COVERAGE_TARGETDIR )
+
+rescue LoadError => err
+	task :no_rcov do
+		$stderr.puts "Coverage tasks not defined: RSpec+RCov tasklib not available: %s" %
+		[ err.message ]
+	end
+
+	task :coverage => :no_rcov
+	task :clobber_coverage
+	task :rcov => :no_rcov
+	namespace :coverage do
+		task :text => :no_rcov
+		task :diff => :no_rcov
+	end
+	task :verify => :no_rcov
+end
+
+

data/rake/verifytask.rb

@@ -0,0 +1,64 @@
+#####################################################################
+###	S U B V E R S I O N   T A S K S   A N D   H E L P E R S
+#####################################################################
+
+require 'rake/tasklib'
+
+#
+# Work around the inexplicable behaviour of the original RDoc::VerifyTask, which 
+# errors if your coverage isn't *exactly* the threshold.
+# 
+
+# A task that can verify that the RCov coverage doesn't
+# drop below a certain threshold. It should be run after
+# running Spec::Rake::SpecTask.
+class VerifyTask < Rake::TaskLib
+	
+	COVERAGE_PERCENTAGE_PATTERN = 
+		%r{<tt class='coverage_code'>(\d+\.\d+)%</tt>}
+	
+	# Name of the task. Defaults to :verify_rcov
+	attr_accessor :name
+
+	# Path to the index.html file generated by RCov, which
+	# is the file containing the total coverage.
+	# Defaults to 'coverage/index.html'
+	attr_accessor :index_html
+
+	# Whether or not to output details. Defaults to true.
+	attr_accessor :verbose
+
+	# The threshold value (in percent) for coverage. If the 
+	# actual coverage is not equal to this value, the task will raise an 
+	# exception. 
+	attr_accessor :threshold
+
+	def initialize( name=:verify )
+		@name = name
+		@index_html = 'coverage/index.html'
+		@verbose = true
+		yield self if block_given?
+		raise "Threshold must be set" if @threshold.nil?
+		define
+	end
+
+	def define
+		desc "Verify that rcov coverage is at least #{threshold}%"
+
+		task @name do
+			total_coverage = nil
+			if match = File.read( index_html ).match( COVERAGE_PERCENTAGE_PATTERN )
+				total_coverage = Float( match[1] )
+			else
+				raise "Couldn't find the coverage percentage in #{index_html}"
+			end
+
+			puts "Coverage: #{total_coverage}% (threshold: #{threshold}%)" if verbose
+			if total_coverage < threshold
+				raise "Coverage must be at least #{threshold}% but was #{total_coverage}%"
+			end
+		end
+	end
+end
+
+# vim: set nosta noet ts=4 sw=4:

data/spec/bugfixes_spec.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/ruby -w
+#
+# Specification for various bugfixes to the LinkParser binding
+# $Id: bugfixes_spec.rb 48 2008-12-19 18:30:33Z deveiant $
+#
+# See the LICENSE file in the distribution for information about copyright and licensing.
+#
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent
+	
+	libdir = basedir + 'lib'
+	extdir = basedir + 'ext'
+	
+	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
+	$LOAD_PATH.unshift( extdir.to_s ) unless $LOAD_PATH.include?( extdir.to_s )
+}
+
+require 'spec/runner'
+require 'linkparser'
+
+# @dict = LinkParser::Dictionary.new( :verbosity => 0 )
+# s = LinkParser::Sentence.new('The cat runs.',@dict)
+# puts s.linkages.first.verb  #  "cat.n" !?!?!
+describe %{bugfix for #3: The first linkage for "The cat runs."} do
+	before( :each ) do
+		@dict = LinkParser::Dictionary.new( :verbosity => 0 )
+		@sentence = @dict.parse( "The cat runs." )
+		@linkage = @sentence.linkages.first
+	end
+	
+
+	it "thinks cat is the subject" do
+		@linkage.subject.should == "cat"
+	end
+
+	it "thinks runs is the verb" do
+		@linkage.verb.should == "runs"
+	end
+end
+

data/spec/linkparser/dictionary_spec.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/ruby -w
+#
+# Specification for the LinkParser::Dictionary class
+# $Id: dictionary_spec.rb 48 2008-12-19 18:30:33Z deveiant $
+#
+# See the LICENSE file in the distribution for information about copyright and licensing.
+#
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+	
+	libdir = basedir + 'lib'
+	extdir = basedir + 'ext'
+	
+	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
+	$LOAD_PATH.unshift( extdir.to_s ) unless $LOAD_PATH.include?( extdir.to_s )
+}
+
+require 'spec/runner'
+require 'linkparser'
+
+
+describe LinkParser::Dictionary do
+	it "can be instantiated using all default values" do
+		lambda { LinkParser::Dictionary.new }.should_not raise_error()
+	end
+
+	it "can be instantiated with an options hash" do
+		LinkParser::Dictionary.new( :verbosity => 2 ).options[:verbosity].should == 2
+	end
+
+	it "raises an error when created with an bad number of arguments" do
+		lambda {
+			LinkParser::Dictionary.new( "foo", "bar", "baz" )
+		}.should raise_error(ArgumentError)
+	end
+
+	it "can be instantiated with a language argument" do
+		lambda {LinkParser::Dictionary.new( 'en' )}.should_not raise_error()
+	end
+
+	it "can be instantiated with both a language and an options hash" do
+		LinkParser::Dictionary.new('en', :verbosity => 2).options[:verbosity].should == 2
+	end
+
+	it "raises an exception if created with unknown dictionaries" do
+		lambda {
+			LinkParser::Dictionary.new('foo', 'bar', 'baz', 'bim')
+		}.should raise_error( LinkParser::Error )
+	end
+
+	it "raises an exception if created with an unknown language" do
+		lambda {
+			LinkParser::Dictionary.new('zz')
+		}.should raise_error( LinkParser::Error )
+	end
+
+end
+
+describe "An instance of LinkParser::Dictionary" do
+
+	TEST_SENTENCE = "The dog plays with the ball."
+
+	before( :each ) do
+		@dict = LinkParser::Dictionary.new( 
+			:verbosity => 0,
+			:max_null_count => 18,
+			:echo_on => true
+		  )
+	end
+	
+
+	it "knows what the total cost of its linkages are" do
+		@dict.max_cost.should be_an_instance_of(Fixnum)
+	end
+
+	it "can parse a sentence" do
+		@dict.parse( TEST_SENTENCE ).
+			should be_an_instance_of( LinkParser::Sentence )
+	end
+	
+	it "passes on its options to the sentences it parses" do
+		sentence = @dict.parse( TEST_SENTENCE )
+		sentence.options.max_null_count.should == 18
+		sentence.options.verbosity.should == 0
+		sentence.options.echo_on?.should == true
+	end
+end
+

data/spec/linkparser/linkage_spec.rb

@@ -0,0 +1,434 @@
+#!/usr/bin/ruby -w
+#
+# Specification for the LinkParser::Linkage class
+# $Id: linkage_spec.rb 48 2008-12-19 18:30:33Z deveiant $
+#
+# See the LICENSE file in the distribution for information about copyright and licensing.
+#
+
+BEGIN {
+	require 'pathname'
+	basedir = Pathname.new( __FILE__ ).dirname.parent.parent
+	
+	libdir = basedir + 'lib'
+	extdir = basedir + 'ext'
+	
+	$LOAD_PATH.unshift( libdir.to_s ) unless $LOAD_PATH.include?( libdir.to_s )
+	$LOAD_PATH.unshift( extdir.to_s ) unless $LOAD_PATH.include?( extdir.to_s )
+}
+
+require 'spec/runner'
+require 'linkparser'
+
+
+describe LinkParser::Linkage do
+
+	before( :all ) do
+		@dict = LinkParser::Dictionary.new( :verbosity => 0 )
+	end
+
+	before( :each ) do
+		@sentence = @dict.parse( "The flag was wet." )
+		@linkage = @sentence.linkages.first
+	end
+	
+
+	#     +-------------Xp-------------+
+	#     +-----Wd-----+               |
+	#     |      +--Ds-+--Ss-+--Pa-+   |
+	#     |      |     |     |     |   |
+	# LEFT-WALL the flag.n was.v wet.a .
+	it "can build a diagram string for a sentence" do
+		@linkage.diagram.should =~ /LEFT-WALL/
+		@linkage.diagram.should =~ /the/
+		@linkage.diagram.should =~ /flag\.n/
+		@linkage.diagram.should =~ /was\.v/
+		@linkage.diagram.should =~ /wet\.a/
+		
+		@linkage.diagram.should =~ /-Xp-/
+		@linkage.diagram.should =~ /-Wd-/
+		@linkage.diagram.should =~ /-Ds-/
+		@linkage.diagram.should =~ /-Ss-/
+		@linkage.diagram.should =~ /-Pa-/
+	end
+	
+
+	 #       LEFT-WALL      Xp      <---Xp---->  Xp        .
+	 # (m)   LEFT-WALL      Wd      <---Wd---->  Wd        flag.n
+	 # (m)   the            D       <---Ds---->  Ds        flag.n
+	 # (m)   flag.n         Ss      <---Ss---->  Ss        was.v
+	 # (m)   was.v          Pa      <---Pa---->  Pa        wet.a
+	 #       .              RW      <---RW---->  RW        RIGHT-WALL
+	it "can build a 'links and domains' diagram" do
+		@linkage.links_and_domains.should =~ /LEFT-WALL/
+		@linkage.links_and_domains.should =~ /the/
+		@linkage.links_and_domains.should =~ /flag\.n/
+		@linkage.links_and_domains.should =~ /was\.v/
+		@linkage.links_and_domains.should =~ /wet\.a/
+
+		@linkage.links_and_domains.should =~ /-Xp-/
+		@linkage.links_and_domains.should =~ /-Wd-/
+		@linkage.links_and_domains.should =~ /-Ds-/
+		@linkage.links_and_domains.should =~ /-Ss-/
+		@linkage.links_and_domains.should =~ /-Pa-/
+	end
+
+
+	it "knows how many words are in the sentence" do
+		# LEFT-WALL + words + '.' + RIGHT-WALL = 7
+		@linkage.num_words.should == 7
+	end
+
+
+	it "can return a list of the tokenized words" do
+		@linkage.words.should include("LEFT-WALL")
+		@linkage.words.should include("the")
+		@linkage.words.should include("flag.n")
+		@linkage.words.should include("was.v")
+		@linkage.words.should include("wet.a")
+		@linkage.words.should include(".")
+		@linkage.words.should include("RIGHT-WALL")
+	end
+	
+	
+	it "knows how many links are in the sentence" do
+		@linkage.num_links.should == 6
+	end
+
+
+	it "can return the left word for any of its links" do
+	 	#       LEFT-WALL      Xp      <---Xp---->  Xp        .
+		@linkage.link_lword( 0 ).should == @linkage.words.index('LEFT-WALL')
+
+		# (m)   LEFT-WALL      Wd      <---Wd---->  Wd        flag.n
+		@linkage.link_lword( 1 ).should == @linkage.words.index('LEFT-WALL')
+
+		# (m)   the            D       <---Ds---->  Ds        flag.n
+		@linkage.link_lword( 2 ).should == @linkage.words.index('the')
+
+		# (m)   flag.n         Ss      <---Ss---->  Ss        was.v
+		@linkage.link_lword( 3 ).should == @linkage.words.index('flag.n')
+
+		# (m)   was.v          Pa      <---Pa---->  Pa        wet.a
+		@linkage.link_lword( 4 ).should == @linkage.words.index('was.v')
+
+		#       .              RW      <---RW---->  RW        RIGHT-WALL
+		@linkage.link_lword( 5 ).should == @linkage.words.index('.')
+
+	end
+	
+	it "can return the right word for any of its links" do
+	 	#       LEFT-WALL      Xp      <---Xp---->  Xp        .
+		@linkage.link_rword( 0 ).should == @linkage.words.index('.')
+
+		# (m)   LEFT-WALL      Wd      <---Wd---->  Wd        flag.n
+		@linkage.link_rword( 1 ).should == @linkage.words.index('flag.n')
+
+		# (m)   the            D       <---Ds---->  Ds        flag.n
+		@linkage.link_rword( 2 ).should == @linkage.words.index('flag.n')
+
+		# (m)   flag.n         Ss      <---Ss---->  Ss        was.v
+		@linkage.link_rword( 3 ).should == @linkage.words.index('was.v')
+
+		# (m)   was.v          Pa      <---Pa---->  Pa        wet.a
+		@linkage.link_rword( 4 ).should == @linkage.words.index('wet.a')
+
+		#       .              RW      <---RW---->  RW        RIGHT-WALL
+		@linkage.link_rword( 5 ).should == @linkage.words.index('RIGHT-WALL')
+
+	end
+
+
+	it "can return the length of any of its links" do
+		@linkage.link_length( 0 ).should == 5 
+		@linkage.link_length( 1 ).should == 2
+		@linkage.link_length( 2 ).should == 1
+		@linkage.link_length( 3 ).should == 1
+		@linkage.link_length( 4 ).should == 1
+		@linkage.link_length( 5 ).should == 1
+
+		# Out-of-bounds just returns -1
+		@linkage.link_length( 7 ).should == -1
+	end
+	
+	
+	it "can return labels for any of its links" do
+		@linkage.link_label( 0 ).should == "Xp"
+		@linkage.link_label( 1 ).should == "Wd"
+		@linkage.link_label( 2 ).should == "Ds"
+		@linkage.link_label( 3 ).should == "Ss"
+		@linkage.link_label( 4 ).should == "Pa"
+		@linkage.link_label( 5 ).should == "RW"
+
+		@linkage.link_label( 7 ).should be_nil
+	end
+	
+
+	it "can return left labels for any of its links" do
+		@linkage.link_llabel( 0 ).should == "Xp"
+		@linkage.link_llabel( 1 ).should == "Wd"
+		@linkage.link_llabel( 2 ).should == "D"
+		@linkage.link_llabel( 3 ).should == "Ss"
+		@linkage.link_llabel( 4 ).should == "Pa"
+		@linkage.link_llabel( 5 ).should == "RW"
+
+		@linkage.link_llabel( 7 ).should be_nil
+	end
+	
+
+	it "can return labels for any of its links" do
+		@linkage.link_rlabel( 0 ).should == "Xp"
+		@linkage.link_rlabel( 1 ).should == "Wd"
+		@linkage.link_rlabel( 2 ).should == "Ds"
+		@linkage.link_rlabel( 3 ).should == "Ss"
+		@linkage.link_rlabel( 4 ).should == "Pa"
+		@linkage.link_rlabel( 5 ).should == "RW"
+
+		@linkage.link_rlabel( 7 ).should be_nil
+	end
+	
+	
+	it "can return the number of domains for any link" do
+		@linkage.link_num_domains( 0 ).should == 0
+		1.upto(4) do |i|
+			@linkage.link_num_domains( i ).should == 1
+		end
+		@linkage.link_num_domains( 5 ).should == 0
+
+		@linkage.link_num_domains( 112 ).should == -1
+	end
+	
+	
+	it "can return the names of the domains of any of its links" do
+		@linkage.link_domain_names( 0 ).should be_an_instance_of( Array )
+		@linkage.link_domain_names( 0 ).should be_empty
+		
+		1.upto(4) do |i|
+			@linkage.link_domain_names( i ).should be_an_instance_of( Array )
+			@linkage.link_domain_names( i ).should == ["m"]
+		end
+		
+		@linkage.link_domain_names( 5 ).should be_an_instance_of( Array )
+		@linkage.link_domain_names( 5 ).should be_empty
+		
+		@linkage.link_domain_names( 12 ).should be_an_instance_of( Array )
+		@linkage.link_domain_names( 12 ).should be_empty
+	end
+
+	
+	it "can report on the various cost metrics of the parse" do
+		@linkage.unused_word_cost.should be_an_instance_of( Fixnum )
+		@linkage.disjunct_cost.should be_an_instance_of( Fixnum )
+		@linkage.and_cost.should be_an_instance_of( Fixnum )
+		@linkage.link_cost.should be_an_instance_of( Fixnum )
+	end
+
+
+	### :FIXME: I don't know what these do/mean yet, so for now just test to 
+	### make sure they're implemented. They should really be tested with
+	### sentences that have predictable results.
+	it "implements Link Grammar predicate methods" do
+		@linkage.should respond_to( :canonical? )
+		@linkage.should respond_to( :improper? )
+		@linkage.should respond_to( :has_inconsistent_domains? )
+		@linkage.should respond_to( :violation_name )
+	end
+
+
+	 #       LEFT-WALL      Xp      <---Xp---->  Xp        .
+	 # (m)   LEFT-WALL      Wd      <---Wd---->  Wd        flag.n
+	 # (m)   the            D       <---Ds---->  Ds        flag.n
+	 # (m)   flag.n         Ss      <---Ss---->  Ss        was.v
+	 # (m)   was.v          Pa      <---Pa---->  Pa        wet.a
+	 #       .              RW      <---RW---->  RW        RIGHT-WALL
+	it "contains link structs describing the linkage" do
+		@linkage.should have(6).links
+		@linkage.links.should be_an_instance_of( Array )
+		
+		@linkage.links.each do |link|
+			link.should be_a_kind_of( Struct )
+		end
+
+		@linkage.links.first.lword.should == 'LEFT-WALL'
+		@linkage.links.first.label.should == 'Xp'
+		@linkage.links.last.rword.should == 'RIGHT-WALL'
+		@linkage.links.last.label.should == 'RW'
+		@linkage.links[3].lword.should == 'flag.n'
+		@linkage.links[3].rword.should == 'was.v'
+		@linkage.links[3].label.should == 'Ss'
+	end
+
+
+	it "knows what word is the verb in the sentence" do
+		@linkage.verb.should == "was"
+	end
+
+
+	it "knows when the sentence doesn't have a direct object" do
+		@linkage.object.should be_nil()
+	end
+	
+
+	MODE1_C_TREE_STRING = "(S (NP The flag)\n   (VP was\n       (ADJP wet))\n   .)\n"
+	MODE2_C_TREE_STRING = "[S [NP The flag NP] [VP was [ADJP wet ADJP] VP] . S] \n"
+	MODE3_C_TREE_STRING = "(S (NP The flag) (VP was (ADJP wet)) .)\n"
+
+	it "returns an indented sexps for the constituent tree string by default (mode 1)" do
+		@linkage.constituent_tree_string.should == MODE1_C_TREE_STRING
+	end
+	
+
+	it "returns indented sexps for the constituent tree string if fetched with explicit mode '1'" do
+		@linkage.constituent_tree_string( 1 ).should == MODE1_C_TREE_STRING
+	end
+	
+	it "returns bracketed constituents if constituent tree string is fetched in mode 2" do
+		@linkage.constituent_tree_string( 2 ).should == MODE2_C_TREE_STRING
+	end
+	
+	it "returns unindented sexps for the constituent tree string if constituent tree string " +
+	   "is fetched in mode 3" do
+		@linkage.constituent_tree_string( 3 ).should == MODE3_C_TREE_STRING
+	end
+	
+	it "raises an exception for any numeric constituent tree string mode greater than 3" do
+		lambda {
+			@linkage.constituent_tree_string( 4 )
+		}.should raise_error( ArgumentError, /illegal mode 4/i )
+	end
+	
+	it "raises an exception for any numeric constituent tree string mode less than 1" do
+		lambda {
+			@linkage.constituent_tree_string( 0 )
+		}.should raise_error( ArgumentError, /illegal mode 0/i )
+	end
+
+
+	it "raises an exception when a non-numeric constituent tree string mode is given" do
+		lambda {
+			@linkage.constituent_tree_string( 'glarg' )
+		}.should raise_error( TypeError )
+	end
+	
+	it "returns an Array of CTree structs for its constituent tree" do
+		rval = @linkage.constituent_tree
+		
+		rval.should be_an_instance_of( Array )
+		rval.should have(1).members
+		rval.first.should be_a_kind_of( Struct )
+		rval.first.label.should == 'S'
+		rval.first.children.should have(3).members
+		rval.first.children.collect {|n| n.label }.should include( 'NP', 'VP', '.' )
+	end
+	
+	it "returns 0 as the number of the current sublinkage since it has no conjunctions" do
+	    @linkage.current_sublinkage.should == 0 
+	end
+
+
+	it "returns an informational string when inspected" do
+		@linkage.inspect.should =~ /Linkage:0x[[:xdigit:]]+: sublinkage 0: \[\d+ links\]/
+	end
+	
+	
+	describe "from a simple sentence with a direct object" do
+		before( :each ) do
+			@sentence = @dict.parse( "The dog ran home." )
+			@linkage = @sentence.linkages.first
+		end
+
+
+		it "doesn't have any sublinkages" do
+			@linkage.num_sublinkages.should == 1
+		end
+	
+		it "doesn't change after computing its union" do
+			lambda {
+				@linkage.compute_union
+			}.should_not change( @linkage, :num_sublinkages )
+		end
+
+
+		it "knows what word is the object in the sentence" do
+			@linkage.object.should == 'home'
+		end
+	
+	end
+
+
+	it "knows that it doesn't have any conjunctions" do
+		@linkage.should_not have_conjunction()
+	end
+	
+
+	describe "from a sentence with a conjunction" do
+		before( :each ) do
+			@sentence = 
+				@dict.parse( "The ball rolled down the hill and bumped the curb." )
+			@linkage = @sentence.linkages.first
+		end
+
+
+		it "knows that it has a conjunction" do
+			@linkage.should have_conjunction()
+		end
+	
+		it "has two sublinkages" do
+			@linkage.num_sublinkages.should == 2
+		end
+	
+
+		it "adds a sublinkage after computing its union" do
+			lambda {
+				@linkage.compute_union
+			}.should change( @linkage, :num_sublinkages ).from(2).to(3)
+		end
+
+
+		it "knows what word is the verb in the current sublinkage" do
+			@linkage.verb.should == 'rolled'
+			@linkage.current_sublinkage = 1
+			@linkage.verb.should == 'bumped'
+		end
+	
+
+		it "knows what word is the object in the current sublinkage" do
+			@linkage.object.should == 'hill'
+			@linkage.current_sublinkage = 1
+			@linkage.object.should == 'curb'
+		end
+	
+	end
+
+
+	it "should know that it's not an imperative sentence" do
+		@linkage.imperative?.should be_false()
+	end
+	
+
+	describe "from an imperative sentence" do
+		before( :each ) do
+			@sentence = @dict.parse( "Go to the store!" )
+			@linkage = @sentence.linkages.first
+		end
+
+
+		it "knows that it's an imperative sentence" do
+			@linkage.imperative?.should be_true()
+		end
+		
+		
+	end
+
+
+	describe "bugfixes" do
+		
+		it "also strips off the '.p' from the subject and object when they are plural" do
+			sent = @dict.parse( 'People like goats.' )
+			sent.subject.should_not =~ /people\.p/i
+			sent.object.should_not =~ /goats\.p/i
+		end
+		
+	end
+
+end