camdict 1.0.3 → 2.0.0

data/test/test_explanation.rb

@@ -1,71 +1,67 @@
-require 'minitest/autorun'
-require 'camdict'
+# frozen_string_literal: true
+require_relative 'helper'
 
 module Camdict
   class ExplanationTest < Minitest::Test
-
     def test_get_level
       html = '<span class="def-info"><span class="epp-xref B1">B1</span>'
       html = Nokogiri::HTML(html)
       exp  = Camdict::Explanation.new(html)
-      assert_equal 'B1', (exp.send :get_level)
+      assert_equal 'B1', exp.level
     end
 
     def test_get_meaning
-      html = '<span class="def">in <a class="query" href="http://cambridge' +
-        '.org/british">agreement </a>with the true facts or with what is ' +
-        'generally accepted:'
+      html = '<span class="def">in <a class="query" href="http://cambridge' \
+             '.org/british">agreement </a>with the true facts or with what ' \
+             'is generally accepted:'
       html = Nokogiri::HTML(html)
       exp  = Camdict::Explanation.new(html)
-      expected = 
+      expected =
         'in agreement with the true facts or with what is generally accepted:'
-      assert_equal expected, (exp.send :get_meaning)
+      assert_equal expected, exp.meaning
     end
 
-    def test_gc
+    def test_code
       # rubber has region, usage, gc
       html = '<span class="def-info"><span class="gcs">U</span>'
       html = Nokogiri::HTML(html)
       exp  = Camdict::Explanation.new(html)
-      assert_equal 'U', exp.gc
+      assert_equal 'U', exp.code
     end
 
     def test_get_sentence
       html = '<span class="eg">a correct answer</span>'
       html = Nokogiri::HTML(html)
-      exp  = Camdict::Explanation::Sentence.new(html)
-      assert_equal 'a correct answer', (exp.send :get_sentence)
+      exp  = Camdict::Sentence.new(html)
+      assert_equal 'a correct answer', exp.sentence
     end
 
     def test_get_examples
-      sent1 = %q(It's not correct to describe them as 'student')
-      sent2 = %q("Your name is Angela Black?""That is correct.")
+      sent1 = %(It's not correct to describe them as 'student')
+      sent2 = %("Your name is Angela Black?""That is correct.")
       html  = "<span class='examp'><span class='eg'>#{sent1}</span></span>"
-      html += "<span class='examp'><span class='eg'>#{sent2}</span>" +
-        '<span class="usage">formal</span>'
+      html += "<span class='examp'><span class='eg'>#{sent2}</span>" \
+              '<span class="usage">formal</span>'
       html = Nokogiri::HTML(html)
-      exp  = Camdict::Explanation.new(html)
-      expected = exp.send :get_examples
-      e1, e2 = expected.flatten
+      e1, e2 = Camdict::Explanation.new(html).examples
       assert_equal sent1, e1.sentence
       assert_equal sent2, e2.sentence
-      assert_equal "formal", e2.usage
+      assert_equal 'formal', e2.usage
     end
 
     def test_get_synonym
       html = '<span class="entry-xref" type="Synonym"><span class="x-h">right'
       html = Nokogiri::HTML(html)
       exp  = Camdict::Explanation.new(html)
-      assert_equal "right", (exp.send :get_synonym)
+      assert_equal 'right', exp.synonym
     end
 
     def test_get_opposite
-      html = 
+      html =
         '<span class="entry-xref" type="Opposite"><span class="x-h">incorrect'
       html = Nokogiri::HTML(html)
       exp  = Camdict::Explanation.new(html)
-      assert_equal "incorrect", (exp.send :get_opposite)
+      assert_equal 'incorrect', exp.opposite
     end
-
   end
 end

data/test/test_http_client.rb

@@ -1,28 +1,42 @@
+# frozen_string_literal: true
 require 'minitest/autorun'
 require 'camdict'
 
 module Camdict
   class HTTPClientTest < Minitest::Test
-    
     def test_get_html
       require 'webrick'
 
-      server = WEBrick::HTTPServer.new(:Port=>0, :BindAddress=>"127.0.0.1", 
-        :Logger=>WEBrick::Log.new(nil,WEBrick::BasicLog::FATAL))
-      Thread.new {
-        res = Proc.new { |r, q|
-          q.body ="hello"
-        }
+      server = WEBrick::HTTPServer.new(
+        Port: 0, BindAddress: '127.0.0.1',
+        Logger: WEBrick::Log.new(nil, WEBrick::BasicLog::FATAL)
+      )
+      start_hello_thread(server)
+      http_hello(server)
+    end
+
+    def test_self_get_html
+      assert Camdict::HTTP::Client.respond_to? :get_html
+      assert Camdict::HTTP::Client.new.respond_to? :get_html
+    end
+
+    def start_hello_thread(server)
+      Thread.new do
+        res = proc do |_r, q|
+          q.body = 'hello'
+        end
         server.mount_proc '/hi', nil, &res
         server.start
-      }
-      Thread.new {
+      end
+    end
+
+    def http_hello(server)
+      Thread.new do
         url = "http://127.0.0.1:#{server.config[:Port]}/hi"
         page = Camdict::HTTP::Client.get_html(url)
-        server.stop 
-        assert_equal "hello", page.text
-      }.join
+        server.stop
+        assert_equal 'hello', page.text
+      end.join
     end
-
   end
 end

data/test/test_string_ext.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+require_relative 'helper'
+
+module Camdict
+  class StringExtTest < Minitest::Test
+    using Camdict::StringExt
+
+    def test_slash_in_middle
+      str = 'blow a kiss to/at sb'
+      expected = ['blow a kiss to sb', 'blow a kiss at sb']
+      assert_equal expected, str.flatten
+    end
+
+    def test_slash_at_first
+      str = 'blow/blew a kiss'
+      expected = ['blow a kiss', 'blew a kiss']
+      assert_equal expected, str.flatten
+    end
+
+    def test_slash_at_last
+      str = 'knock around/about'
+      expected = ['knock around', 'knock about']
+      assert_equal expected, str.flatten
+    end
+
+    def test_two_middle_slashes
+      str = 'not give/budge/move an inch'
+      expected = ['not give an inch', 'not budge an inch', 'not move an inch']
+      assert_equal expected, str.flatten
+    end
+
+    def test_single_quote
+      str = "fall into the/sb's trap"
+      expected = ['fall into the trap', 'fall into sb\'s trap']
+      assert_equal expected, str.flatten
+    end
+
+    def test_question_mark
+      str = 'what is sb/sth?'
+      expected = ['what is sb?', 'what is sth?']
+      assert_equal expected, str.flatten
+    end
+
+    def test_exlamation_mark
+      str = 'look lively/sharp!'
+      expected = ['look lively!', 'look sharp!']
+      assert_equal expected, str.flatten
+    end
+
+    def test_semicolon
+      str = "the like of sb/sth; sb's/sth's like"
+      expected = ['the like of sb', 'the like of sth',
+                  "sb's like", "sth's like"]
+      assert_equal expected, str.flatten
+    end
+
+    def test_middle_parentheses
+      str = 'go (like/down) a bomb'
+      expected = ['go a bomb', 'go like a bomb', 'go down a bomb']
+      assert_equal expected, str.flatten
+    end
+
+    def test_ending_parentheses
+      str = 'the other side/end (of sth)'
+      expected = ['the other side', 'the other end', 'the other side of sth',
+                  'the other end of sth']
+      assert_equal expected, str.flatten
+    end
+
+    def test_slash_means_non_alternative
+      skip 'special cases for flatten'
+      # strs = ['20/20 vision', 'public enemy number one/no. 1']
+      # todo: still have uncovered special cases for flatten
+      # "20/20 vision".flatten => "20/20 vision" no change expected
+      # public enemy number one/no. 1 =>
+      #   public enemy number one
+      #   public enemy no. 1
+      # need more examples to support complex 'or' separators
+      #   sound like/as if/as though
+      #   look on/upon sb/sth as sth
+      #   look at/see sth through rose-coloured/tinted glasses
+      #   give /quote sth/sb chapter and verse
+    end
+
+    def test_ellipsis
+      str = 'the more...the more/less'
+      expected = ['the more...the more', 'the more...the less']
+      assert_equal expected, str.flatten
+    end
+
+    def test_has?
+      assert 'blow your nose'.has?('nose')
+    end
+  end
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: camdict
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Pan Gaoyong
-- "潘高勇"
+- 潘高勇
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-17 00:00:00.000000000 Z
+date: 2017-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -25,6 +25,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.2
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.8.3
 description: Get definitions, pronunciation and example sentences of a word or phrase
   from the online Cambridge dictionaries.
 email: pan.gaoyong@gmail.com
@@ -35,21 +49,35 @@ files:
 - README.md
 - Rakefile
 - lib/camdict.rb
+- lib/camdict/array_ext.rb
 - lib/camdict/client.rb
 - lib/camdict/common.rb
 - lib/camdict/definition.rb
+- lib/camdict/entry.rb
+- lib/camdict/exception.rb
 - lib/camdict/explanation.rb
 - lib/camdict/http_client.rb
+- lib/camdict/ipa.rb
+- lib/camdict/pronunciation.rb
+- lib/camdict/sentence.rb
+- lib/camdict/string_ext.rb
 - lib/camdict/word.rb
 - license
+- test/debug.rb
+- test/helper.rb
 - test/itest_client.rb
 - test/itest_definition.rb
+- test/itest_entry.rb
 - test/itest_explanation.rb
+- test/itest_ipa.rb
+- test/itest_pronunciation.rb
+- test/itest_word.rb
+- test/test_array_ext.rb
 - test/test_client.rb
 - test/test_common.rb
-- test/test_definition.rb
 - test/test_explanation.rb
 - test/test_http_client.rb
+- test/test_string_ext.rb
 homepage: https://github.com/pan/camdict
 licenses:
 - MIT
@@ -62,7 +90,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -70,16 +98,23 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: online Cambridge dictionary client
 test_files:
 - test/itest_explanation.rb
+- test/itest_pronunciation.rb
+- test/test_string_ext.rb
 - test/test_common.rb
 - test/itest_client.rb
 - test/itest_definition.rb
-- test/test_definition.rb
+- test/helper.rb
+- test/itest_entry.rb
 - test/test_http_client.rb
+- test/itest_word.rb
 - test/test_client.rb
+- test/debug.rb
+- test/itest_ipa.rb
+- test/test_array_ext.rb
 - test/test_explanation.rb

data/test/test_definition.rb

@@ -1,345 +0,0 @@
-require 'minitest/autorun'
-require 'camdict'
-
-module Camdict
-  # this word has two derived words
-  PLAGIARIZE = '<h2 class="di-title cdo-section-title-hw">plagiarize</h2>' +
-    '<span class="runon"><span class=runon-title" title="Derived word">' +
-      '<span class="w">plagiarism</span></span>' +
-    '<span class="runon-info"><span class="posgram"><span class="pos">noun' +
-    '</span></span></span></span>' +
-   '<span class="runon"><span class=runon-title" title="Derived word">' +
-      '<span class="w">plagiarist</span></span>'+
-    '<span class="runon-info"><span class="posgram"><span class="pos">noun' +
-    '</span></span></span></span>'
-
-  class DefinitionTest < Minitest::Test
-
-    def test_pos
-      html = '<h2 class="di-title cdo-section-title-hw">favourite</h2>' +
-        '<span class="di-info"><span class="posgram">' + 
-        '<span class="pos" title="A word that ...">noun</span></span>' +
-        '<span class="spellvar"><span class="v" title="Variant form">' +
-        'favorite</span></span></span>'
-      w = Camdict::Definition.new("favourite", :favourite=>html)
-      assert_equal "noun", w.send(:pos)
-      w = Camdict::Definition.new("favorite",  :favourite=>html)
-      assert_equal "noun", w.send(:pos)
-      html = '<h2 class="di-title cdo-section-title-hw">look at sth</h2>' +
-        '<span class="di-info"><span class="anc-info-head"><span class="pos"' +
-        ' title="Verb with an adverb...">phrasal verb</span><span class='+
-        '"posgram">' +
-        '<span class="pos" title="Verb with an adverb...">verb</span></span>'
-      w = Camdict::Definition.new("look at sth","look-at-sth_1" => html)
-      assert_equal "phrasal verb", w.send(:pos) 
-      w = Camdict::Definition.new("plagiarist",:plagiarize => PLAGIARIZE)
-      assert_equal "noun", w.send(:pos)
-      htmli = '<h2 class="di-title cdo-section-title-hw">pass water</h2>' +
-        '<div class="di-body"><div class="idiom-block">' +
-        '<span class="idiom-body">'
-      w = Camdict::Definition.new("pass water","pass-water" => htmli)
-      assert_equal "idiom", w.send(:pos)
-    end
-
-    def test_title_word
-      html = '<h2 class="di-title cdo-section-title-hw">aluminium</h2>'
-      w = Camdict::Definition.new("aluminium",:aluminium=>html)
-      assert_equal "aluminium", w.send(:title_word)
-    end
-
-    def test_derived_words
-      w = Camdict::Definition.new("plagiarize",:plagiarize => PLAGIARIZE)
-      r = w.send :derived_words 
-      assert_equal %w(plagiarism plagiarist), r
-      w = Camdict::Definition.new("mind", :mind=>"<h1>mind</h1>")
-      assert ! (w.send :derived_words) 
-    end
-
-    def test_where?
-      w = Camdict::Definition.new("plagiarize",:plagiarize => PLAGIARIZE)
-      assert_equal "title", w.send(:where?)
-      w = Camdict::Definition.new("plagiarism",:plagiarize => PLAGIARIZE)
-      assert_equal "derived", w.send(:where?)
-      html = '<h2 class="di-title cdo-section-title-hw">knock around/about'
-      w = Camdict::Definition.new("knock about","knock-around-about"=>html) 
-      assert_equal "title", w.send(:where?)
-      w = Camdict::Definition.new("knock around","knock-around-about"=>html) 
-      assert_equal "title", w.send(:where?)
-    end
-
-    def test_get_head_variant
-      html = '<h2 class="di-title cdo-section-title-hw">aluminium</h2>' +
-        '<span class="di-info"><span class="var"><span class="v" ' + 
-        'title="Variant form">aluminum</span></span>'
-      w = Camdict::Definition.new("aluminum",:aluminium=>html)
-      assert_equal "aluminum", w.send(:get_head_variant).first
-    end
-
-    def test_spell_variant
-      html = '<span class="spellvar">'+
-        '<h2 class="di-title cdo-section-title-hw">aluminium</h2>' +
-        '<span class="v" title="Variant form">aluminum</span></span>'
-      w = Camdict::Definition.new("aluminum",:aluminium=>html)
-      assert_equal "aluminum", w.send(:spell_variant)
-    end
-
-    def test_get_phrase
-      phrase = %q(correct me if I'm wrong but...)
-      html = '<h2 class="di-title cdo-section-title-hw">aluminium</h2>' +
-        '<span class="phrase-block"><span class="phrase">' + phrase
-      w = Camdict::Definition.new("correct me",:correct=>html)
-      assert_equal [phrase], w.send(:get_phrase)
-    end
-
-    def test_idiom_explanation
-      word = 'have it out with sb'
-      meaning = 'to talk to someone about something they have done that makes' +
-        ' you angry, in order to try to solve the problem:'
-      html = "<h2 class='di-title cdo-section-title-hw'>#{word}</h2>" +
-        '<span class="idiom-block"><span class="idiom-body">'+
-        "<span class='def-block'><span class='def'>#{meaning}"
-      def1  = Camdict::Definition.new(word, "have-it-out-with-sb"=>html)
-      assert def1.is_idiom
-      assert_equal meaning, def1.explanations.first.meaning
-      def2 = Camdict::Definition.new("have it out", "have-it-out-with-sb"=>html)
-      assert_equal meaning, def2.explanations.first.meaning
-    end
-
-    def test_parse_ipa
-      imagin = %w(26a 2c8 6d e6 64 292 2e 26a 2e 6e).map { |c| 
-        c.to_i 16}.pack 'U*'
-      a = %w(259).map { |c| c.to_i 16}.pack 'U'
-      ry = %w(72 2e 69).map {|c| c.to_i 16}.pack 'U*'
-      html = '<h2 class="di-title cdo-section-title-hw">imaginary</h2>' +
-        "<span class='di-info'><span class='ipa'>#{imagin}<span class='sp'>" +
-        "#{a}</span>#{ry}</span>"
-      w = Camdict::Definition.new("imaginary",:imaginary=>html)
-      node = Nokogiri::HTML(html).css(".ipa")
-      ukipa = w.send :parse_ipa, node
-      actual = {baseipa: ukipa[:baseipa], sindex: ukipa[:sindex]}
-      expected = {baseipa: imagin+a+ry, sindex:[10,1]}
-      assert_equal expected, actual
-    end
-
-    def test_join_ipa
-      html = '<h2 class="di-title cdo-section-title-hw">understand</h2>'
-      w = Camdict::Definition.new("understand",:understand=>html)
-      # head-tail hyphen
-      understand = { 
-        :uk_utf8  => %w(2cc 28c 6e 2e 64 259 2c8 73 74 e6 6e 64),
-        :us_utf8  => %w(2d 64 25a 2d),
-        :expected => %w(2cc 28c 6e 2e 64 25a 2c8 73 74 e6 6e 64),
-        :us_inx   => nil,
-        :uk_inx   => nil,
-        :spiexp   => nil 
-      }
-      imaginary = {
-        :uk_utf8  => %w(26a 2c8 6d e6 64 292 2e 26a 2e 6e 259 72 2e 69),
-        :us_utf8  => %w(2d 259 2e 6e 65 72 2d),
-        :expected => %w(26a 2c8 6d e6 64 292 2e 259 2e 6e 65 72 2e 69),
-        :us_inx   => nil,
-        :uk_inx   => [10,1],
-        :spiexp   => nil 
-      }
-      plagiarism = {
-        :uk_utf8  => %w(2c8 70 6c 65 26a 2e 64 292 259 72 2e 61 26a 7a),
-        :us_utf8  => %w(2d 64 292 259 72 2e 26a 2e 7a 259 6d),
-        :expected => %w(2c8 70 6c 65 26a 2e 64 292 259 72 2e 26a 2e 7a 259 6d),
-        :us_inx   => [3,1,9,1],
-        :uk_inx   => [8,1],
-        :spiexp   => [8,1,14,1]
-      }
-      # left hyphen
-      plagiarize = {
-        :uk_utf8  => %w(2c8 70 6c 65 26a 2e 64 292 259 72 2e 61 26a 7a),
-        :us_utf8  => %w(2d 64 292 259 2e 72 61 26a 7a),
-        :expected => %w(2c8 70 6c 65 26a 2e 64 292 259 2e 72 61 26a 7a),
-        :us_inx   => nil,
-        :uk_inx   => [8,1],
-        :spiexp   => nil 
-      }
-      painting = {
-        :uk_utf8  => %w(2c8 70 65 26a 6e 2e 74 26a 14b),
-        :us_utf8  => %w(2d 74 32c 26a 14b),
-        :expected => %w(2c8 70 65 26a 6e 2e 74 32c 26a 14b),
-        :us_inx   => nil,
-        :uk_inx   => nil,
-        :spiexp   => nil 
-      }
-      dictionary = {
-        :uk_utf8  => %w(2c8 64 26a 6b 2e 283 259 6e 2e 259 72 2e 69),
-        :us_utf8  => %w(2d 65 72 2e 69),
-        :expected => %w(2c8 64 26a 6b 2e 283 259 6e 2e 65 72 2e 69),
-        :us_inx   => nil,
-        :uk_inx   => [6,1, 9,1],
-        :spiexp   => [6,1]
-      }
-      harmfulness = {
-        :uk_utf8  => %w(2c8 68 251 2d0 6d 2e 66 259 6c),
-        :us_utf8  => %w(2d 6e 259 73),
-        :expected => %w(2c8 68 251 2d0 6d 2e 66 259 6c 6e 259 73),
-        :us_inx   => nil,
-        :uk_inx   => [7,1],
-        :spiexp   => [7,1]
-      }
-      # right hyphen
-      toxic = {
-        :uk_utf8  => %w(2c8 74 252 6b 2e 73 26a 6b),
-        :us_utf8  => %w(2c8 74 251 2d0 6b 2d),
-        :expected => %w(2c8 74 251 2d0 6b 73 26a 6b),
-        :us_inx   => nil,
-        :uk_inx   => nil,
-        :spiexp   => nil 
-      }
-      data = [understand, imaginary, plagiarize, plagiarism, painting, 
-        harmfulness, toxic]
-      data.each_with_index { |word, i|
-        full  = word[:uk_utf8].map {|c| c.to_i 16}.pack 'U*'
-        short = word[:us_utf8].map {|c| c.to_i 16}.pack 'U*'
-        full_sp = { baseipa: full, sindex: word[:uk_inx]}
-        short_sp = { baseipa: short, sindex: word[:us_inx]}
-        us = w.send :join_ipa, full_sp, short_sp
-        a = us[:baseipa].unpack 'U*'
-        spind = us[:sindex]
-        actual = a.map { |n| n.to_s 16 }
-        assert_equal word[:expected], actual
-        assert_equal word[:spiexp], spind
-      }
-    end
-
-    def test_mix_spi
-      html = '<h2 class="di-title cdo-section-title-hw">understand</h2>'
-      w = Camdict::Definition.new("understand",:understand=>html)
-      # an IPA is 12 letters long, 012345678901 -345-, 
-      lsp = [2,1, 5,1, 9,2]
-      lrange = 0..3
-      csp = [ 3, 2 ]
-      cn = 3
-      rrang = 8..12
-      expected = [2,1, 6,2, 9,2]
-      actual = w.send :mix_spi,lsp, lrange, csp, cn, lsp, rrang
-      assert_equal expected, actual
-    end
-
-    def test_get_pronunciation
-      title = '<h2 class="di-title cdo-section-title-hw">understand</h2>'
-      ogglink = 'http://cam.org/british/ukunder112.ogg'
-      mp3link = 'http://cam.org/british/ukunder112.mp3'
-      html = title + %q(<span class='di-info'><a class='pron-uk' ) + 
-        "data-src-ogg='#{ogglink}' data-src-mp3='#{mp3link}' href='#'>"
-      w = Camdict::Definition.new("understand",:understand=>html)
-      pron = w.send :get_pronunciation
-      assert_equal mp3link, pron.uk.mp3
-      assert_equal ogglink, pron.uk.ogg
-      assert_nil pron.us.mp3
-      assert_equal mp3link, w.pronunciation.uk.mp3
-    end
-
-    def test_get_region
-      belaughing = { 
-        :word     => 'be laughing',
-        :expected => 'UK',
-        :piece    => ''
-      }
-      favorite = { 
-        :word     => 'favorite',
-        :expected => 'US',
-        :piece    => "<span class='spellvar'><span class='region'>US</span>" +
-          "<span class='v' title='Variant form'>favorite"
-      }
-      aluminum = { 
-        :word     => 'aluminum',
-        :expected => 'US',
-        :piece    => "<span class='var'><span class='region'>US</span>" +
-          "<span class='v' title='Variant form'>aluminum"
-      }
-      data = [belaughing, favorite, aluminum]
-      data.each { |d|
-        title = "<h2 class='di-title cdo-section-title-hw'>#{d[:word]}</h2>"
-        html = title + %q(<span class='di-info'><a class='lab'><span class=) + 
-          "'region'>UK</span><span class='usage'>informal</span>"
-        w = Camdict::Definition.new(d[:word], d[:word]=>html+d[:piece])
-        region = w.send :get_region
-        assert_equal d[:expected], region
-      }
-    end
-
-    def test_gc
-      plagiarize = { 
-        :word     => 'plagiarize',
-        :expected => 'I or T',
-        :piece    => ''
-      }
-      data = [plagiarize]
-      data.each { |d|
-        title = "<h2 class='di-title cdo-section-title-hw'>#{d[:word]}</h2>"
-        html = title + %q(<span class='di-info'><span class='gcs'>) +
-          "<span class='gc'>I</span> or <span class='gc'>T</span>"
-        w = Camdict::Definition.new(d[:word], d[:word]=>html+d[:piece])
-        actual = w.send :get_gc
-        assert_equal d[:expected], actual
-      }
-    end
-
-    def test_get_plural
-      mouse = { 
-        :word     => 'mouse',
-        :expected => 'mice',
-        :piece    => "<span class='inf'>mice</span>"
-      }
-      fish = { 
-        :word     => 'fish',
-        :expected => %w(fish fishes),
-        :piece    => '<span class="inf">fish</span> or <span class="inf">fishes'
-      }
-      data = [mouse, fish]
-      data.each { |d|
-        title = "<h2 class='di-title cdo-section-title-hw'>#{d[:word]}</h2>"
-        html = title + %q(<span class='di-info'><span class='inf-group' ) +
-          "type='plural'>"
-        w = Camdict::Definition.new(d[:word], d[:word]=>html+d[:piece])
-        w.instance_eval { @part_of_speech = 'noun'}
-        actual = w.send :get_plural
-        assert_equal d[:expected], actual
-      }
-    end
-
-    def test_guided_word
-      d = { word: 'rubber', expected: 'SUBSTANCE'}
-      title = "<h2 class='di-title cdo-section-title-hw'>#{d[:word]}</h2>"
-      html = title + %q(<span class='di-info'><strong class='gw'>(SUBSTANCE))
-      w = Camdict::Definition.new(d[:word], d[:word]=>html)
-      actual = w.send :get_guided_word
-      assert_equal d[:expected], actual
-    end
-
-    def test_get_irregular
-      blow = { 
-        :word     => 'blow',
-        :expected => ['blew','blown', nil],
-        :piece    => "><span class='inf'>blew</span></span>,<span class='inf-" +
-          "group'><span class='inf'>blown</span></span>"
-      }
-      bet = { 
-        :word     => 'bet',
-        :expected => %w(bet bet betting),
-        :piece    => 'type="pres_part"><span class="inf">betting</span>' +
-          '</span><span class="inf-group" type="past"><span class="inf">bet'
-      }
-      data = [blow, bet]
-      data.each { |d|
-        title = "<h2 class='di-title cdo-section-title-hw'>#{d[:word]}</h2>"
-        html = title + %q(<span class='di-info'><span class='inf-group' )
-        w = Camdict::Definition.new(d[:word], d[:word]=>html+d[:piece])
-        expected = w.instance_eval { 
-          @part_of_speech = 'verb'
-          sp, pp, pr = d[:expected]
-          Camdict::Definition::Irregular.new(sp, pp, pr)
-        }
-        actual = w.send :get_irregular
-        assert_equal expected, actual
-      }
-    end
-
-  end
-end