test/test-chisedb.rb

   1 #!/usr/bin/env ruby
   2 # Copyright (C) 2002-2004 Kouichirou Eto, All rights reserved.
   3
   4 require "common"
   5
   6 class TestChiseDB < Test::Unit::TestCase
   7   def test_libchise_r
   8     db_dir = CHISE::DataSource::DB_DIR
   9     assert_match(/chise-db\Z/, db_dir)
  10
  11     @ds = CHISE::DataSource.new(CHISE::DataSource::Berkeley_DB, db_dir, 0, 0755)
  12     assert_instance_of(CHISE::DataSource, @ds)
  13
  14     @ct = @ds.get_ccs("=daikanwa")
  15     assert_instance_of(CHISE::CCS, @ct)
  16     char_id = @ct.decode(364) # get a character by Daikanwa number 364.
  17     assert_equal(20175, char_id)
  18     #str = format_char_id(20175)
  19     #assert_equal("?\344\273\217", str)
  20
  21     char_id = @ds.decode_char("=daikanwa", 364)
  22     assert_equal(20175, char_id)
  23
  24     @ft = @ds.get_feature("ideographic-structure")
  25     assert_instance_of(CHISE::Feature, @ft)
  26     value = @ft.get_value(char_id)
  27     assert_instance_of(String, value)
  28     assert_equal("(?\342\277\260 ?\344\272\273 ?\345\216\266)", value)
  29
  30     value = @ds.load_feature(char_id, "ideographic-structure")
  31     assert_equal("(?\342\277\260 ?\344\272\273 ?\345\216\266)", value)
  32     return
  33
  34     @ds.each_feature_name {|f|
  35       assert_instance_of(String, f)
  36       ft = @ds.get_feature(f)
  37       v = ft.get_value(23383)
  38       #ft.close
  39     }
  40
  41     @ft.each_char {|k, v|
  42       assert_kind_of(Integer, k)
  43       assert_instance_of(String, v)
  44     }
  45
  46     ft = @ds.get_feature("numeric-value")
  47     ft.each {|k, v|
  48       assert_kind_of(Integer, k)
  49       assert_instance_of(String, v)
  50     }
  51   end
  52
  53   def nu_test_each_ccs
  54     @ds = CHISE::DataSource.new
  55     @ds.each_ccs {|ccs|
  56       assert_instance_of(String, ccs)
  57       ct = @ds.get_ccs(ccs)
  58       assert_instance_of(CHISE::CCSTable, ct)
  59     }
  60
  61     ct = @ds.get_ccs("=ucs")
  62     ct.each {|k, v|
  63       assert_kind_of(Integer, k)
  64       assert_kind_of(Integer, v)
  65     }
  66     #ct.close
  67   end
  68
  69   def test_error
  70     db_dir = CHISE::DataSource::DB_DIR
  71     @ds = CHISE::DataSource.new(CHISE::DataSource::Berkeley_DB, db_dir, 0, 0755)
  72     @ft = @ds.get_feature("nosuchfeature")
  73     v = @ft.get_value(20175)
  74     assert_equal(nil, v)
  75   end
  76
  77   def test_chisedb
  78     @cd = CHISE::ChiseDB.instance
  79
  80     char_id = @cd.decode_char("=daikanwa", 364)
  81     assert_equal(20175, char_id)
  82
  83     value = @cd.load_feature(char_id, "ideographic-structure")
  84     assert_equal("(?\342\277\260 ?\344\272\273 ?\345\216\266)", value)
  85
  86     value = @cd.load_feature(char_id, "=ucs")
  87     assert_equal("20175", value)
  88
  89     @cd.each_feature_name {|f|
  90       assert_instance_of(String, f)
  91     }
  92
  93     ft = @cd.get_feature("numeric-value")
  94     ft.each_char {|k, v|
  95       assert_kind_of(Integer, k)
  96       assert_instance_of(String, v)
  97     }
  98   end
  99
 100   def test_ascii
 101     @cd = CHISE::ChiseDB.instance
 102     ct = @cd.get_ccs("ascii")
 103     char_id = ct.decode(65)
 104     assert_equal(65, char_id)
 105     assert_equal("A", CHISE::Character.get(char_id).to_s)
 106 #   assert_equal("A", char.to_s)
 107   end
 108
 109   def test_put
 110     @cd = CHISE::ChiseDB.instance
 111     char_id = "字".char.char_id
 112     ft = @cd.get_feature("test")
 113     ft.setup_db(1)
 114     ft.set_value(char_id, "test1")
 115     assert_equal("test1", ft.get_value(char_id))
 116     ft.sync
 117
 118     ds = @cd.instance_eval { @ds }
 119     path = CHISE::DataSource::DB_DIR.path+"character/feature/test"
 120     assert_equal(true, path.exist?)
 121   end
 122 end