weft-qda 0.9.6

data/test/002-category.rb

@@ -0,0 +1,138 @@
+require 'english'
+
+$:.push('../lib/')
+
+require 'weft/category'
+require 'test/unit'
+
+class TestDocument < Test::Unit::TestCase
+  def setup
+
+  end
+  
+  def test_basic
+	c = QDA::Category.new('The Title',nil)
+	assert_equal('The Title', c.name,
+				 'Set title at initialisation')
+	assert_equal(0, c.children.length,
+				 'Empty at initialisation')
+
+	c2 = QDA::Category.new('Child Node',c)
+	assert_equal(1, c.children.length,
+				 'Added a child')
+  end
+
+  def test_memo
+	c = QDA::Category.new('The Title',nil, 'My Memo')
+	assert_equal('My Memo', c.memo,
+				 'Set memo at initialisation')
+
+	c2 = QDA::Category.new('Child Node',c)
+	assert_equal('', c2.memo,
+				 'Default memo = ""')
+
+	c2.memo = 'Foo'
+	assert_equal('Foo', c2.memo,
+				 'Set memo with accessor')
+  end
+
+  def test_code
+    a = QDA::Code.new(1, 0, 5)
+    assert( a.include?(0), "Code#include?")
+    assert( a.include?(1), "Code#include?")
+    assert( a.include?(4), "Code#include?")
+    assert_equal(false, a.include?(5), "Code#include?")
+    assert_equal(false, a.include?(9), "Code#include?")
+  end
+  
+  def test_do_code
+	c = QDA::Category.new('The Title',nil)
+    # create an initial code
+    c.code(2, 0, 20)
+    assert_equal(1, c.num_of_docs,
+                 'Have coded one document')
+    assert_equal(1, c.num_of_codes,
+                   'Have added one code')
+    assert_equal(0, c.codes[2][0].offset,
+                 'Have set code offset')
+    assert_equal(20, c.codes[2][0].length,
+                 'Have set code length')
+    assert_equal(20, c.num_of_chars,
+                   'Have calculated total chars')
+
+    # create a separate code of the same document
+    c.code(2, 90, 10)
+    assert_equal(1, c.num_of_docs,
+                 'Have still coded one document')
+    assert_equal(2, c.num_of_codes,
+                 'Have added one code')
+    assert_equal(30, c.num_of_chars,
+                 'Have increased total chars')
+
+    # code a region which partiall overlaps and extends the first code
+    c.code(2, 10, 15)
+    assert_equal(1, c.num_of_docs,
+                 'Have done joint coding')
+    assert_equal(2, c.num_of_codes,
+                 'Have done joint coding')
+    assert_kind_of(QDA::Code, c.codes[2][0],
+                   'Have done joint one code')
+    assert_equal(0, c.codes[2][0].offset,
+                 'Have updated code offset')
+    assert_equal(25, c.codes[2][0].length,
+                 'Have updated code length')
+    assert_equal(35, c.num_of_chars,
+                   'Have increased total chars')
+
+    # code another region that is distinct and between the first two
+    c.code(2, 30, 30)
+    assert_equal(1, c.num_of_docs,
+                 'Have done discrete coding')
+    assert_equal(3, c.num_of_codes,
+                 'Have done discrete coding')
+    assert_kind_of(QDA::Code, c.codes[2][1],
+                   'Have done discrete one code')
+    assert_equal(30, c.codes[2][1].offset,
+                 'Have updated code offset')
+    assert_equal(30, c.codes[2][1].length,
+                 'Have updated code length')
+    assert_equal(65, c.num_of_chars,
+                   'Have increased total chars')
+
+    # code another document
+    c.code(1, 120, 100)
+    assert_equal(2, c.num_of_docs,
+                 'Have increased documents with new document')
+    assert_equal(4, c.num_of_codes,
+                 'Have increased codes with new document')
+
+    # uncode a portion of first code
+    c.uncode(2, 5, 15)
+    assert_equal(2, c.num_of_docs,
+                 'Have done split uncoding')
+    assert_equal(4, c.codes[2].length,
+                 'Have done split uncoding')
+    assert_kind_of(QDA::Code, c.codes[2][0],
+                   'Have done split uncode')
+    assert_equal(0, c.codes[2][0].offset,
+                 'Have updated code offset')
+    assert_equal(5, c.codes[2][0].length,
+                 'Have updated code length')
+
+    assert_kind_of(QDA::Code, c.codes[2][1],
+                   'Have done split uncode')
+    assert_equal(20, c.codes[2][1].offset,
+                 'Have updated code offset')
+    assert_equal(5, c.codes[2][1].length,
+                 'Have updated code length')
+
+    assert_kind_of(QDA::Code, c.codes[2][2],
+                   'Have done split uncode')
+    assert_equal(30, c.codes[2][2].offset,
+                 'Have updated code offset')
+    assert_equal(30, c.codes[2][2].length,
+                 'Have updated code length')
+
+    # more tests ? ... seems to be all OK, not
+  end
+end

data/test/003-code.rb

@@ -0,0 +1,370 @@
+require 'english'
+
+$:.push('../lib/')
+
+require 'weft'
+require 'test/unit'
+
+class TestCode < Test::Unit::TestCase
+  include QDA
+
+  def setup
+
+  end
+
+  def test_basic
+    c_1 = Code.new(3, 0, 4)
+	assert_equal(3, c_1.docid,
+				 'Set docid at initialization')
+	assert_equal(0, c_1.offset,
+				 'Set offset at initialization')
+	assert_equal(4, c_1.length,
+				 'Set length at initialization')
+
+    c_1 << Code.new(3, 4, 5)
+	assert_equal(0, c_1.offset,
+				 '<< other')
+	assert_equal(9, c_1.length,
+				 '<< other.length')
+    
+  end
+
+  def test_basic_codeset
+    # this shouldn work
+    q = CodeSet[ '11' ]
+    assert_kind_of(CodeSet, q)
+
+    assert_raises(ArgumentError) { CodeSet.new([ '11' ]) }
+    # boring constructor
+    q = CodeSet.new [ [4, 5, 6] ]
+    assert_equal(1, q.length)
+    assert_kind_of(Code, q[0])
+    c = q[0]
+    assert_equal(4, c.docid)
+    assert_equal(5, c.offset)
+    assert_equal(6, c.length)
+  end
+
+  def test_addition
+    c_1 = Code.new(3, 0, 3)
+    c_2 = Code.new(3, 2, 4)
+    c_3 = c_1 + c_2
+	assert_equal(6, c_3.length,
+				 'Overlapping addition')
+	assert_equal(0, c_3.offset,
+				 'Overlapping offset of first element')
+
+    c_1 = Code.new(3, 2, 6)
+    c_2 = Code.new(3, 2, 6)
+    c_3 = c_1 + c_2
+	assert_equal(6, c_3.length,
+				 'Identical addition')
+	assert_equal(2, c_3.offset,
+				 'Identical addition offset of first element')
+    
+    c_1 = Code.new(3, 2, 6)
+    c_2 = Code.new(3, 2, 4)
+    c_3 = c_1 + c_2
+	assert_equal(6, c_3.length,
+				 'Identical addition')
+	assert_equal(2, c_3.offset,
+				 'Identical addition offset of first element')
+    
+    
+    
+    c_1 = Code.new(3, 0, 2)
+    c_2 = Code.new(3, 4, 4)
+    c_3 = c_1 + c_2
+	assert_equal(2, c_3.length,
+				 'Disjoint addition')
+	assert_equal(0, c_3[0].offset,
+				 'Disjoint addition first element offset')
+	assert_equal(2, c_3[0].length,
+				 'Disjoint addition first element length')
+	assert_equal(4, c_3[1].offset,
+				 'Disjoint addition second element offset')
+	assert_equal(4, c_3[1].length,
+				 'Disjoint addition second element length')
+
+    c_1 = Code.new(3, 0, 2)
+    c_2 = Code.new(3, 4, 4)
+    c_3 = c_2 + c_1
+	assert_equal(2, c_3.length,
+				 'Disjoint addition')
+	assert_equal(0, c_3[0].offset,
+				 'Disjoint addition first element offset')
+	assert_equal(2, c_3[0].length,
+				 'Disjoint addition first element length')
+	assert_equal(4, c_3[1].offset,
+				 'Disjoint addition second element offset')
+	assert_equal(4, c_3[1].length,
+				 'Disjoint addition second element length')
+
+  end
+
+
+  def test_comparison
+    c_1 = Code.new(3, 0, 7)
+    c_2 = Code.new(3, 0, 7)
+    c_3 = Code.new(3, 5, 7)
+    c_4 = Code.new(3, 0, 19)
+	assert(c_1 == c_1, 'Identity Equality')
+	assert(c_1 == c_2, 'Equivalence Equality')
+	assert(c_1 != c_3, 'Offset inequality')
+	assert(c_1 != c_4, 'Length inequality')
+
+    c_1 = Code.new(3, 0, 7)
+    c_2 = Code.new(3, 2, 9)
+    assert(c_1.overlap?(c_2), 'Overlap 1/2')
+    assert(c_2.overlap?(c_1), 'Overlap 1/1')
+    assert(c_1.touch?(c_2), 'Touch 1/1')
+    assert(c_2.touch?(c_1), 'Touch 1/2')
+
+    c_1 = Code.new(3, 0, 7)
+    c_2 = Code.new(3, 7, 9)
+    assert(! c_1.overlap?(c_2), 'Overlap 2/2')
+    assert(! c_2.overlap?(c_1), 'Overlap 2/1')
+    assert(c_1.touch?(c_2), 'Touch 2/1')
+    assert(c_2.touch?(c_1), 'Touch 2/2')
+
+    c_1 = Code.new(3, 0, 7)
+    c_2 = Code.new(3, 8, 9)
+    assert(! c_1.overlap?(c_2), 'Overlap 3/2')
+    assert(! c_2.overlap?(c_1), 'Overlap 3/1')
+    assert(! c_1.touch?(c_2), 'Touch 3/1')
+    assert(! c_2.touch?(c_1), 'Touch 3/2')
+
+  end
+
+  def test_subtraction
+    c_1 = Code.new(3, 0, 7)
+    c_2 = Code.new(3, 2, 2)
+    c_3 = c_1 - c_2
+	assert_equal(2, c_3.length,
+				 'Disjoint subtraction')
+	assert_equal(0, c_3[0].offset,
+				 'Disjoint subtraction first element offset')
+	assert_equal(2, c_3[0].length,
+				 'Disjoint subtraction first element length')
+	assert_equal(4, c_3[1].offset,
+				 'Disjoint subtraction second element offset')
+	assert_equal(3, c_3[1].length,
+				 'Disjoint subtraction second element length')
+
+    c_1 = Code.new(3, 0, 4)
+    c_2 = Code.new(3, 2, 2)
+    c_3 = c_1 - c_2
+	assert_equal(1, c_3.length,
+				 'Tail subtraction')
+	assert_equal(0, c_3[0].offset,
+				 'Tail subtraction first element offset')
+	assert_equal(2, c_3[0].length,
+				 'Tail subtraction first element length')
+
+    c_1 = Code.new(3, 2, 4)
+    c_2 = Code.new(3, 0, 4)
+    c_3 = c_1 - c_2
+	assert_equal(1, c_3.length,
+				 'Head subtraction')
+	assert_equal(4, c_3[0].offset,
+				 'Tail subtraction first element offset')
+	assert_equal(2, c_3[0].length,
+				 'Tail subtraction first element length')
+
+    c_1 = Code.new(3, 12, 10)
+    c_2 = Code.new(3, 10, 20)
+    c_3 = c_1 - c_2
+	assert_equal(0, c_3.length,
+				 'Erase subtraction')
+
+    c_1 = Code.new(3, 5, 5)
+    c_2 = Code.new(3, 10, 20)
+    c_3 = c_1 - c_2
+	assert_equal(1, c_3.length,
+				 'Null subtraction')
+	assert_equal(5, c_3[0].offset,
+				 'Null subtraction first element offset')
+	assert_equal(5, c_3[0].length,
+				 'Null subtraction first element length')
+
+    c_1 = Code.new(3, 30, 30)
+    c_2 = Code.new(3, 5, 15)
+    c_3 = c_1 - c_2
+	assert_equal(1, c_3.length,
+				 'Null subtraction')
+	assert_equal(30, c_3[0].offset,
+				 'Null subtraction first element offset')
+	assert_equal(30, c_3[0].length,
+				 'Null subtraction first element length')
+
+  end
+
+  def test_intersection
+    c_1 = Code.new(3, 0, 7)
+    c_2 = Code.new(3, 2, 2)
+    c_3 = c_1 % c_2
+	assert_equal(2, c_3.length,
+				 'Island intersection')
+	assert_equal(2, c_3.offset,
+				 'Island intersection')
+
+    c_1 = Code.new(3, 5, 8)
+    c_2 = Code.new(3, 8, 20)
+    c_3 = c_1 % c_2
+	assert_equal(5, c_3.length,
+				 'Overlap intersection')
+	assert_equal(8, c_3.offset,
+				 'overlap intersection')
+
+    c_1 = Code.new(3, 0, 5)
+    c_2 = Code.new(3, 10, 5)
+    c_3 = c_1 % c_2
+	assert_nil(c_3, 'Disjoint intersection')
+
+    c_1 = Code.new(3, 0, 5)
+    c_2 = Code.new(3, 5, 10)
+    c_3 = c_1 % c_2
+	assert_nil(c_3, 'Adjacent intersection')
+  end
+
+  def test_set_intersect
+    cs_2 = CodeSet[ Code.new(3, 0, 5),
+                         Code.new(3, 10, 10) ]
+
+    cs_1 = CodeSet[ Code.new(3, 3, 9) ]
+
+    intersect = cs_1.intersect(cs_2)
+
+	assert_equal(Code.new(3, 3, 2), intersect[0], 
+                 'Overlap intersection')
+
+	assert_equal(Code.new(3, 10, 2), intersect[1], 
+                 'Overlap intersection')
+  
+    cs_2 = CodeSet[ Code.new(3, 2, 7) ]
+    cs_1 = CodeSet[ Code.new(3, 9, 5) ]
+
+    intersect = cs_1.intersect(cs_2)
+	assert([], 'Adjacent intersection')
+
+    cs_2 = CodeSet[ Code.new(3, 0, 4) ]
+    cs_1 = CodeSet[ Code.new(3, 9, 5) ]
+    intersect = cs_1.intersect(cs_2)
+	assert([], 'Disjoint intersection')
+  end
+
+  def test_set_union
+    cs_2 = CodeSet[  Code.new(3, 0, 5),
+                          Code.new(3, 10, 10)]
+
+    cs_1 = CodeSet[ Code.new(3, 3, 9) ]
+
+    union = cs_1.union(cs_2)
+	assert_equal(Code.new(3, 0, 20), union[0], 
+                 'Overlap set union')
+  
+    cs_2 = CodeSet[ Code.new(3, 2, 7) ]
+    cs_1 = CodeSet[ Code.new(3, 9, 5) ]
+    union = cs_1.union(cs_2)
+
+	assert_equal(Code.new(3, 2, 12), union[0], 
+                 'Adjacent set union')
+
+    cs_2 = CodeSet[ Code.new(3, 0, 4), Code.new(3, 20, 8) ]
+    cs_1 = CodeSet[ Code.new(3, 9, 5) ]
+    union = cs_1.union(cs_2)
+
+	assert_equal(Code.new(3, 0, 4), union[0],
+                 'Disjoint set union')
+	assert_equal(Code.new(3, 9, 5), union[1], 
+                 'Disjoint set union')
+	assert_equal(Code.new(3, 20, 8), union[2], 
+                 'Disjoint set union')
+  end
+
+  def test_set_exclude
+    cs_2 = CodeSet[ Code.new(3, 0, 5), Code.new(3, 10, 10) ]
+    cs_1 = CodeSet[ Code.new(3, 3, 9), Code.new(3, 25, 5) ]
+
+    exclusion = cs_2.exclude(cs_1)
+	assert_equal(Code.new(3, 0, 3), exclusion[0], 
+                 'Overlap set exclusion')
+	assert_equal(Code.new(3, 12, 8), exclusion[1], 
+                 'Overlap set exclusion')
+
+    exclusion = cs_1.exclude(cs_2)
+	assert_equal(Code.new(3, 5, 5), exclusion[0], 
+                 'Overlap set exclusion')
+	assert_equal(Code.new(3, 25, 5), exclusion[1], 
+                 'Overlap set exclusion')
+  
+    cs_2 = CodeSet[ Code.new(3, 2, 7) ]
+    cs_1 = CodeSet[ Code.new(3, 9, 5) ]
+
+
+    exclusion = cs_2.exclude(cs_1)
+	assert_equal(Code.new(3, 2, 7), exclusion[0], 
+                 'Adjacent set exclusion')
+
+    cs_2 = CodeSet[ Code.new(3, 0, 4), Code.new(3, 22, 8) ]
+    cs_1 = CodeSet[ Code.new(3, 9, 5) ]
+
+    exclusion = cs_2.exclude(cs_1)
+
+	assert_equal(Code.new(3, 0, 4), exclusion[0],
+                 'Disjoint set exclusion')
+	assert_equal(Code.new(3, 22, 8), exclusion[1], 
+                 'Disjoint set exclusion')
+  end
+  
+  def test_code_plus_fragment
+    fs = CodeSet[ Fragment.new('weft is nice', 'title', 5, 1) ]
+    cs = CodeSet[ Code.new(1, 13, 8) ]
+
+    isect = fs.intersect(cs)
+    first = isect[0]
+    assert_kind_of(Code, first)
+    assert_equal(13, first.offset)
+    assert_equal(4, first.length)
+    assert_equal(1, first.docid)
+  end
+
+  def test_codetable
+    tbl = CodingTable.new()
+    tbl.add( Code.new(3, 5, 6) )
+    assert_equal(1, tbl.num_of_docs)
+    assert_equal(6, tbl.num_of_chars)
+    assert_equal(1, tbl.num_of_codes)
+  end
+
+  def test_fragment_table
+    ft = FragmentTable.new()
+    ft.add( Fragment.new('the text', 'title', 6, 2) )
+
+    assert_equal(1, ft.num_of_docs)
+    assert_equal(8, ft.num_of_chars)
+    assert_equal(1, ft.num_of_codes)
+    ft.each_title do | title, codes |
+      assert_equal('title', title)
+      assert_equal(1, codes.length)
+    end
+
+
+    ct = ft.to_codingtable()
+    assert_equal(1, ct.num_of_docs)
+    assert_equal(8, ct.num_of_chars)
+    assert_equal(1, ct.num_of_codes)
+    assert_equal(Code, ct[2][0].class)
+  end
+
+  def test_codetable_plus_fragmenttable
+    ft = FragmentTable.new()
+    ft.add( Fragment.new('the text', 'title', 6, 2) )
+    ct = CodingTable.new()
+    ct.add( Code.new(2, 8, 10) )
+
+    out = ft.dup
+    ft.merge(ct)
+    ft.add( Fragment.new('something', 'xxx', 10, 1) )
+  end
+end