test/test-libchise.rb

   1 #!/usr/bin/env ruby
   2 # Copyright (C) 2002-2004 Kouichirou Eto, All rights reserved.
   3
   4 require "common"
   5
   6 class TestRbChise < Test::Unit::TestCase
   7   include CHISE::ChiseValue
   8
   9   def test_rbchise
  10     @ds = CHISE::DataSource.new
  11     assert_instance_of(CHISE::DataSource, @ds)
  12     assert_match(/chise-db\Z/, @ds.location.to_s)
  13
  14     @ct = @ds.get_ccs("=daikanwa")
  15     assert_instance_of(CHISE::CCSTable, @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::FeatureTable, @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("ideographic-structure", char_id)
  31     assert_equal("(?\342\277\260 ?\344\272\273 ?\345\216\266)", value)
  32
  33     @ds.each_feature {|f|
  34       assert_instance_of(String, f)
  35       ft = @ds.get_feature(f)
  36       v = ft.get_value(23383)
  37       ft.close
  38     }
  39
  40     @ft.each {|k, v|
  41       assert_kind_of(Integer, k)
  42       assert_instance_of(String, v)
  43     }
  44
  45     ft = @ds.get_feature("numeric-value")
  46     ft.each {|k, v|
  47       assert_kind_of(Integer, k)
  48       assert_instance_of(String, v)
  49     }
  50   end
  51
  52   def test_each_ccs
  53     @ds = CHISE::DataSource.new
  54     @ds.each_ccs {|ccs|
  55       assert_instance_of(String, ccs)
  56       ct = @ds.get_ccs(ccs)
  57       assert_instance_of(CHISE::CCSTable, ct)
  58     }
  59
  60     ct = @ds.get_ccs("=ucs")
  61     ct.each {|k, v|
  62       assert_kind_of(Integer, k)
  63       assert_kind_of(Integer, v)
  64     }
  65     ct.close
  66   end
  67
  68   def test_error
  69     @ds = CHISE::DataSource.new
  70     @ft = @ds.get_feature("nosuchfeature")
  71     v = @ft.get_value(20175)
  72     assert_equal(nil, v)
  73   end
  74
  75   def test_chisedb
  76     @cd = CHISE::ChiseDB.instance
  77
  78     char_id = @cd.decode_char("=daikanwa", 364)
  79     assert_equal(20175, char_id)
  80
  81     value = @cd.load_feature("ideographic-structure", char_id)
  82     assert_equal("(?\342\277\260 ?\344\272\273 ?\345\216\266)", value)
  83
  84     value = @cd.load_feature("=ucs", char_id)
  85     assert_equal(20175, value)
  86
  87     @cd.each_feature {|f|
  88       assert_instance_of(String, f)
  89     }
  90
  91     ft = @cd.get_feature("numeric-value")
  92     ft.each {|k, v|
  93       assert_kind_of(Integer, k)
  94       assert_instance_of(String, v)
  95     }
  96   end
  97
  98   def test_ascii
  99     @cd = CHISE::ChiseDB.instance
 100     ct = @cd.get_ccs("ascii")
 101     char_id = ct.decode(65)
 102     assert_equal(65, char_id)
 103     assert_equal("A", CHISE::Character.get(char_id).to_s)
 104 #   assert_equal("A", char.to_s)
 105   end
 106
 107   def test_put
 108     @cd = CHISE::ChiseDB.instance
 109     char_id = "字".char.char_id
 110     ft = @cd.get_feature("test")
 111     #assert_equal(nil, ft.get_value(char_id))
 112     ft.set_value(char_id, "test1")
 113     assert_equal("test1", ft.get_value(char_id))
 114     ft.sync
 115
 116     ds = @cd.instance_eval { @ds }
 117     path = ds.location+"character/feature/test"
 118     assert_equal(true, path.exist?)
 119   end
 120
 121   def test_parse_c_string
 122     u8 = "字"
 123 #    assert_equal(23383, u8.u8to_i)
 124     assert_equal(23383, parse_c_string("?"+u8))
 125     assert_equal(0,     parse_c_string("?\\^@"))
 126     assert_equal(9,     parse_c_string("?\t"))
 127     assert_equal(10,    parse_c_string("?\n"))
 128     assert_equal(13,    parse_c_string("?\r"))
 129     assert_equal(94,    parse_c_string("?^\\"))
 130     assert_equal(31,    parse_c_string("?\\^_"))
 131     assert_equal(32,    parse_c_string("?\\ "))
 132     assert_equal(34,    parse_c_string("?\\\""))
 133     assert_equal(126,   parse_c_string("?~"))
 134     assert_equal(127,   parse_c_string("?\\^?\000"))
 135     assert_equal(131,   parse_c_string("?\\^\303\237"))
 136     assert_equal(0x7FF, parse_c_string("?\337\277"))
 137     assert_equal(0xFFFF,        parse_c_string("?\357\277\277"))
 138     assert_equal(0x1FFFFF,      parse_c_string("?\367\277\277\277"))
 139     assert_equal(0x3FFFFFF,     parse_c_string("?\373\277\277\277\277"))
 140     assert_equal(0xFFFFFFF,     parse_c_string("?\374\217\277\277\277\277"))
 141     assert_raise(RuntimeError) { parse_c_string("nosuch") }
 142   end
 143
 144   def test_format_char_id
 145     u8 = "字"
 146 #    assert_equal(u8, CHISE.i_tou8(23383))
 147     assert_equal("?\345\255\227",       format_char_id(23383))
 148     assert_equal("?"+u8,                format_char_id(23383))
 149     assert_equal("?\\^@",       format_char_id(0))
 150     assert_equal("?\t",         format_char_id(?\t))
 151     assert_equal("?\n",         format_char_id(?\n))
 152     assert_equal("?\r",         format_char_id(?\r))
 153     assert_equal("?^\\",        format_char_id(0x1C))
 154     assert_equal("?\\^_",       format_char_id(0x1F))
 155     assert_equal("?\\ ",        format_char_id(?\s))
 156     assert_equal("?\\\"",       format_char_id(?\"))
 157     assert_equal("?~",          format_char_id(0x7E))
 158     assert_equal("?\\^?\000",   format_char_id(0x7F))
 159     assert_equal("?\\^\303\237",        format_char_id(0x9F))
 160     assert_equal("?\337\277",   format_char_id(0x7FF))
 161     assert_equal("?\357\277\277",       format_char_id(0xFFFF))
 162     assert_equal("?\367\277\277\277",   format_char_id(0x1FFFFF))
 163     assert_equal("?\373\277\277\277\277",       format_char_id(0x3FFFFFF))
 164     assert_equal("?\374\217\277\277\277\277",   format_char_id(0xFFFFFFF))
 165   end
 166 end