icu4r_19 1.0

data/icu4r.c

@@ -0,0 +1,18 @@
+extern void initialize_ustring(void);
+extern void initialize_calendar(void);
+extern void initialize_uregexp(void);
+extern void initialize_ucore_ext(void);
+extern void initialize_ubundle(void);
+extern void initialize_converter(void);
+extern void initialize_collator(void);
+void Init_icu4r (void) {
+
+ initialize_ustring();
+ initialize_uregexp();
+ initialize_ucore_ext();
+ initialize_ubundle();
+ initialize_calendar();
+ initialize_converter();
+ initialize_collator();
+
+}

data/icu_common.h

@@ -0,0 +1,45 @@
+#include "ruby.h"
+#include <unicode/utypes.h>
+#include <unicode/ustring.h>
+#include <unicode/ustdio.h>
+#include <unicode/uchar.h>
+#include <unicode/uclean.h>
+#include <unicode/uregex.h>
+#include <unicode/unorm.h>
+#include <unicode/ubrk.h>
+#include <unicode/ucnv.h>
+#include <unicode/uset.h>
+#include <unicode/uenum.h>
+#include <unicode/utrans.h>
+#include <unicode/ucol.h>
+#include <unicode/usearch.h>
+#include <unicode/ures.h>
+#include <unicode/unum.h>
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+typedef struct {
+    long len;
+    long capa;
+    UChar *ptr;
+    unsigned char busy;
+} ICUString ;
+#define USTRING(obj) ((ICUString *)DATA_PTR(obj))
+#define UREGEX(obj)  ((ICURegexp *)DATA_PTR(obj))
+#define ICU_PTR(str) USTRING(str)->ptr
+#define ICU_LEN(str) USTRING(str)->len
+#define ICU_CAPA(str) USTRING(str)->capa
+#define ICU_RESIZE(str,capacity)  REALLOC_N(ICU_PTR(str), UChar, (capacity)+1);
+
+typedef struct  {
+    URegularExpression *pattern;
+    int options;
+} ICURegexp;
+
+
+#define  Check_Class(obj, klass)   if(CLASS_OF(obj) != klass)   rb_raise(rb_eTypeError, "Wrong type: expected %s,  got %s", rb_class2name(klass), rb_class2name(rb_obj_class(obj)));
+
+
+#define ICU_RAISE(status) if(U_FAILURE(status)) rb_raise(rb_eRuntimeError, u_errorName(status));
+

data/samples/demo_each.rb

@@ -0,0 +1,23 @@
+require 'icu4r'
+res = {}
+src = <<-EOT
+外国語の勉強と教え
+Изучение и обучение иностранных языков
+Enseñanza y estudio de idiomas
+'læŋɡwidʒ 'lɘr:niŋ ænd 'ti:ʃiŋ
+‭‫ללמוד וללמד את השֵפה
+L'enseignement et l'étude des langues
+Γλωσσική Εκμὰθηση και Διδασκαλία
+เรียนและสอนภาษา
+EOT
+src = src.u
+["line_break", "char", "sentence", "word"].each do |brk|
+	res[brk] = {}
+	["ja",  "en", "th"].each do |loc|
+	  out = []
+	  src.send("each_#{brk}".to_sym, loc) { |s| out << s }
+	  res[brk][loc] = out.join("|")
+	  puts "---------#{brk}-------#{loc}---------"
+	  puts out.join("|")
+	end
+end

data/samples/demo_locales.rb

@@ -0,0 +1,16 @@
+require 'icu4r'
+root = UResourceBundle.open(nil, "en")
+today = Time.now
+UString::list_locales.each do |locale|
+	b = UResourceBundle.open(nil, locale)
+	lang, ctry, var = locale.split '_', 3
+	ctry = var ? var : ctry
+	puts [ 
+		locale, 
+		"("+root["Countries"][ctry].to_s + " : " +	root["Languages"][lang].to_s+")", 
+		"("+b["Countries"][ctry].to_s + " : " +  b["Languages"][lang].to_s+")",
+	 	"[{0,date,long}]({1,number,currency})".u.fmt(locale, today, 123.45),
+		b["ExemplarCharacters"]
+	].join("\t")
+
+end

data/samples/demo_regexp.rb

@@ -0,0 +1,11 @@
+require 'icu4r'
+str = " abcあいうえおアイウエオアイウエオ漢字,0123スクリプト".u
+puts str.inspect_names
+p str=~ ure('[\p{Script=Latin}]+')
+p str=~ ure('[\p{Script=Hiragana}]+')
+p str=~ ure('[\p{Script=Katakana}]+')
+p str=~ ure('[\p{Script=Hiragana}\p{Script=Katakana}]+')
+p str=~ ure('[\p{blk=CJKUnifiedIdeographs}]+')
+p str=~ ure('[\p{L}]+')
+p str=~ ure('\u3042') # あ
+p str.scan(ure('[\p{N}]'))

data/samples/resbundle/demo_bundle.rb

@@ -0,0 +1,4 @@
+require 'icu4r'
+v = UResourceBundle.open(File.expand_path("appmsg"), "ru")
+puts v["icu4r_hello"]
+puts v["icu4r_classes"]

data/samples/resbundle/mkres.sh

@@ -0,0 +1,4 @@
+genrb root.txt
+genrb -e UTF8 ru.txt
+mkdir appmsg
+mv *.res appmsg

data/samples/resbundle/root.txt

@@ -0,0 +1,10 @@
+root {
+   icu4r_hello { "Hello from ICU4R" }
+   icu4r_classes:array {
+	   "UString",
+	   "URegexp",
+	   "UMatch",
+	   "UResourceBundle"
+   }
+   ustring { "{0} - class to work with UTF16-encoded strings" }
+}

data/samples/resbundle/ru.txt

@@ -0,0 +1,4 @@
+ru {
+   icu4r_hello { "Привет от ICU4R" }
+   ustring { "{0} Класс для работы со строками в кодировке UTF16" }
+}

data/test/test_calendar.rb

@@ -0,0 +1,123 @@
+require './icu4r'
+require 'test/unit'
+# these tests are ICU 3.4 dependent
+class UCalendarTest < Test::Unit::TestCase
+	
+	def test_time_zones
+		v = UCalendar.time_zones
+		assert_kind_of(Array, v)
+		assert_kind_of(UString, v[0])
+    assert(v.include?("Europe/Kiev".u))
+	end
+	
+	def test_default
+		v = UCalendar.default_tz
+		UCalendar.default_tz ="Europe/Paris".u
+		assert_equal( "Europe/Paris".u, UCalendar.default_tz)
+		c = UCalendar.new
+    assert_equal( 3_600_000, c[:zone_offset])
+		# assert_equal( "GMT+01:00".u, c.time_zone("root")) # this should work also
+	end
+	
+	def test_dst
+		assert_equal(UCalendar.dst_savings("America/Detroit".u), 3600000)
+		assert_equal(UCalendar.dst_savings("Australia/Lord_Howe".u), 1800000)
+	end
+
+	def test_tz_for_country
+	   zones = %w{Europe/Kiev Europe/Simferopol Europe/Uzhgorod Europe/Zaporozhye}.collect {|s| s.to_u}
+	   assert_equal(zones, UCalendar.tz_for_country("UA"))
+	end
+
+	def test_time_now
+		assert_equal(Time.now.to_i/100, UCalendar.now.to_i/100000)
+	end
+
+	def test_in_daylight
+		t = UCalendar.new
+		t.set_date(2006, 8, 22)
+		t.time_zone = "US/Hawaii".u 
+		assert_equal(false, t.in_daylight_time?)
+		t.time_zone = "Europe/Berlin".u
+		assert_equal(true, t.in_daylight_time?)
+	end
+	def test_set_date
+		t = UCalendar.new
+		t.set_date(2006, 0, 22)
+		assert_equal(2006, t[:year])
+		assert_equal(0,    t[:month])
+		assert_equal(22,   t[:date])
+		t[:year]  = 2007
+		t[:month] = 2
+		t[:date]  = 23
+		assert_equal(2007, t[:year])
+		assert_equal(2,    t[:month])
+		assert_equal(23,   t[:date])
+
+	end
+	
+	def test_set_date_time
+		t = UCalendar.new
+		t.set_date_time(2006, 0, 22, 11, 22, 33)
+		assert_equal(11,  t[:hour])
+		assert_equal(22,  t[:minute])
+		assert_equal(33,  t[:second])
+	end
+
+	def test_millis
+		m = UCalendar.now
+		t = UCalendar.new
+		assert(m <= t.millis)
+		n = Time.now.to_i
+		t.millis = n  * 1000.0
+		assert_equal(n*1000.0, t.millis)
+	end
+	
+	def test_add_time
+		t = UCalendar.new
+		t.set_date_time(2006, 0, 22, 11, 22, 33)
+		t.add(:week_of_year, 1)
+		assert_equal(29, t[:date])
+		t.add(:hour, 48)
+		assert_equal(31, t[:date])
+	end
+	
+	def test_format
+		t = UCalendar.new
+		t.set_date_time(2006, 0, 22, 11, 22, 33)
+		t.time_zone = "Europe/London".u
+		assert_equal("2006/01/22 11:22:33 GMT AD".u,  t.format("yyyy/MM/dd HH:mm:ss z G".u, "en"))
+	end
+
+	def test_clone_and_compare
+		c = UCalendar.new
+		d = c.clone
+		assert(c == d)
+		assert(! (c < d) )
+		assert(! (c > d) )
+		assert(c.eql?(d))
+		c.add(:date, 1)
+		assert(c != d)
+		assert(! (c < d) )
+		assert( (c > d) )
+		assert(!c.eql?(d))
+		d.add(:date, 1)
+		assert(c.eql?(d))
+		d.time_zone = "Europe/Kiev".u
+		assert(!c.eql?(d))
+		assert(c == d)
+	end
+	
+   def test_parse_date
+	UCalendar.default_tz="UTC".u
+        t1 = UCalendar.parse("HH:mm:ss E dd/MM/yyyy z".u, "en", "20:15:01 Fri 13/01/2006 GMT+00".u)
+	assert_equal(2006, t1[:year])
+	assert_equal(0, t1[:month])
+	assert_equal(13, t1[:date])
+	assert_equal(20, t1[:hour_of_day])
+	assert_equal(15, t1[:minute])
+	assert_equal(01, t1[:second])
+    end
+
+
+end

data/test/test_collator.rb

@@ -0,0 +1,33 @@
+require './icu4r'
+require 'test/unit'
+# these tests are ICU 3.4 dependent
+class UCollatorTest < Test::Unit::TestCase
+  def test_strength
+    c = UCollator.new("root")
+    assert_equal(0,  c.strcoll("a".u, "a".u))
+    assert_equal(1,  c.strcoll("A".u, "a".u))
+    c.strength = UCollator::UCOL_SECONDARY
+    assert_equal(0,  c.strcoll("A".u, "a".u))
+  end
+  
+  def test_attrs
+   c = UCollator.new("root")
+   c[UCollator::UCOL_NUMERIC_COLLATION]= UCollator::UCOL_ON
+   ar = %w(100 10 20 30 200 300).map {|a| a.to_u }.sort {|a,b| c.strcoll(a,b)}.map {|s| s.to_s }
+   assert_equal(["10", "20", "30", "100", "200", "300"], ar)
+   c[UCollator::UCOL_NUMERIC_COLLATION]= UCollator::UCOL_OFF
+   ar = %w(100 10 20 30 200 300).map {|a| a.to_u }.sort {|a,b| c.strcoll(a,b)}.map {|s| s.to_s }
+   assert_equal( ["10", "100", "20", "200", "30", "300"], ar)
+  end
+  
+  def test_sort_key
+   c = UCollator.new("root")
+   c[UCollator::UCOL_NUMERIC_COLLATION]= UCollator::UCOL_ON
+   ar = %w(100 10 20 30 200 300).sort_by {|a| c.sort_key(a.to_u) }
+   assert_equal(["10", "20", "30", "100", "200", "300"], ar)
+   c[UCollator::UCOL_NUMERIC_COLLATION]= UCollator::UCOL_OFF
+   ar = %w(100 10 20 30 200 300).sort_by {|a| c.sort_key(a.to_u) }
+   assert_equal( ["10", "100", "20", "200", "30", "300"], ar)
+  end
+
+end

data/test/test_converter.rb

@@ -0,0 +1,72 @@
+require './icu4r'
+require 'test/unit'
+# these tests are ICU 3.4 dependent
+class UConverterTest < Test::Unit::TestCase
+  
+  def test_a_new_and_name
+    c = UConverter.new("UTF8")
+    assert_kind_of( UConverter, c)
+    assert_equal('UTF-8', c.name)
+  end
+
+  def test_b_list_avail
+    a = UConverter.list_available
+    assert_kind_of(Array, a)
+    assert(a.include?("UTF-8"))
+  end
+  
+  def test_c_all_names
+    a = UConverter.all_names
+    assert_kind_of(Array, a)
+    assert(a.include?("UTF-8"))
+  end
+  
+  def test_d_std_names
+    a = UConverter.std_names("koi8r", "MIME")
+    assert_kind_of(Array, a)
+    assert(a.include?("KOI8-R"))
+    a = UConverter.std_names("cp1251", "IANA")
+    assert_kind_of(Array, a)
+    assert(a.include?("windows-1251"))
+  end
+
+  def test_e_convert_class_method
+    a_s = "\357\360\356\342\345\360\352\340 abcd" 
+    u_s = UConverter.convert("utf8", "cp1251", a_s)
+    assert_equal("проверка abcd", u_s)
+    r_s = UConverter.convert("cp1251", "utf8", u_s)
+    assert_equal(r_s, a_s)
+  end
+
+  def test_f_to_from_u
+    c = UConverter.new("cp1251")
+    a_s = "\357\360\356\342\345\360\352\340 abcd" 
+    u_s = c.to_u(a_s)
+    assert_kind_of(UString, u_s)
+    r_s = c.from_u(u_s)
+    assert_equal(r_s, a_s)
+  end
+
+  def test_g_convert_instance_method
+    c1 = UConverter.new("EUC-JP")
+    c2 = UConverter.new("Cp1251")
+    a_s = "\247\322\247\335\247\361!"
+    b_s = a_s * 1000
+    a1 = UConverter.convert("Cp1251", "EUC-JP", b_s)
+    a2 = c1.convert(c2,  b_s)
+    assert_equal(a1.size, a2.size)
+    assert_equal(a2.size, 4 * 1000)
+    assert_equal(a1, a2)
+    assert_equal("\341\353\377!", c1.convert(c2, a_s))
+  end
+
+  def test_h_subst_chars
+    c1 = UConverter.new("US-ASCII")
+    assert_kind_of(String, c1.subst_chars)
+    c1.subst_chars="!"
+    assert_equal( "I!t!rn!ti!n!liz!ti!n", c1.from_u("Iñtërnâtiônàlizætiøn".u))
+    c1.subst_chars=" "
+    assert_equal( "I t rn ti n liz ti n", c1.from_u("Iñtërnâtiônàlizætiøn".u))
+  end
+  
+end

data/test/test_ustring.rb

@@ -0,0 +1,508 @@
+require './icu4r'
+require 'test/unit'
+class UnicodeStringTest < Test::Unit::TestCase
+
+  def test_string
+    a = u("абвг", "utf8")
+    b = u("абвг", "utf8")
+    assert_equal(a,b )
+  end
+  
+  def test_casecmp
+    assert_equal(0, u("Сцуко").casecmp("сЦуКо".u))
+    assert_equal(-1, u("Сцук").casecmp("сЦуКо".u))
+    assert_equal(1, u("Сцуко").casecmp("сЦуК".u))
+  end
+  
+  def test_match
+    assert_match(ure("абвг"), u("абвг"))
+    assert("аавг".u !~ ure("^$"))
+    assert("авб\n".u !~ ure("^$"))
+    assert("абв".u !~ ure("^г*$"))
+    assert_equal("".u, ("абв".u =~ ure("г*$"))[0])
+    assert("".u =~ ure("^$"))
+    assert("абвабв".u =~ ure( ".*а")  )
+    assert("абвабв".u =~ ure( ".*в")  )
+    assert("абвабв".u =~ ure( ".*?а") )
+    assert("абвабв".u =~ ure( ".*?в") )
+    assert(ure("(.|\n)*?\n(б|\n)") =~ u("а\nб\n\n"))
+ end
+ 
+ def test_sub
+    x = "a.gif".u
+    assert_equal("gif".u, x.sub(ure(".*\\.([^\\.]+)$"), "$1".u))
+    assert_equal("b.gif".u, x.sub(ure(".*\\.([^\\.]+)$"), "b.$1".u))
+    assert_equal(x, "a.gif".u)
+    x.sub!(/gif/.U, ''.u)
+    assert_equal(x, "a.".u)
+    x= "1234561234".u
+    x.sub!(/123/.U, "".u)
+    assert_equal(x,  "4561234".u)
+
+ end
+
+ 
+ def test_case_fold
+    assert_equal("А".u, "а".u.upcase!)
+    assert_equal("а".u, ("А".u.downcase!))
+
+    s = "аБв".u
+    s.upcase
+    assert_equal("аБв".u, s)
+    s.upcase!
+    assert_equal("АБВ".u, s)
+    
+    s = "аБв".u
+    s.downcase
+    assert_equal("аБв".u, s)
+    s.downcase!
+    assert_equal("абв".u, s)
+ end
+
+ def test_index
+   assert_equal( "hello".u.rindex('e'.u), 1)            
+   assert_equal( "hello".u.rindex('l'.u) , 3)          
+   assert_equal( "hello".u.rindex('a'.u), nil)
+   assert_equal( "hello".u.index('e'.u),1)              
+   assert_equal( "hello".u.index('lo'.u),3)             
+   assert_equal( "hello".u.index('a'.u), nil)           
+   assert_equal( "hello".u.index(ure('[aeiou]'), -3),  4)
+   assert_equal( "hello".u.rindex(ure('[aeiou]'), -2), 1)
+    
+    assert_equal(1, S("hello").index(S("ell")))
+    assert_equal(2, S("hello").index(/ll./.U))
+
+    assert_equal(3, S("hello").index(S("l"), 3))
+    assert_equal(3, S("hello").index(/l./.U, 3))
+
+    assert_nil(S("hello").index(S("z"), 3))
+    assert_nil(S("hello").index(/z./.U, 3))
+
+    assert_nil(S("hello").index(S("z")))
+    assert_nil(S("hello").index(/z./.U))
+
+ end
+ 
+ def test_insert
+     assert_equal("abcd".u.insert(0, 'X'.u)    , "Xabcd".u)
+     assert_equal("abcd".u.insert(3, 'X'.u)    , "abcXd".u)
+     assert_equal("abcd".u.insert(4, 'X'.u)    , "abcdX".u)
+     assert_equal("abcd".u.insert(-3, 'X'.u)   , "abXcd".u)
+     assert_equal("abcd".u.insert(-1, 'X'.u)   , "abcdX".u)  
+ end
+
+ def test_include
+    assert( "hello".u.include?("lo".u))
+    assert(!("hello".u.include?("ol".u)))
+ end
+
+ def test_init
+   assert_equal( "нах!".u, UString.new("нах!".u))
+   a = "ГНУ!".u
+   a.replace("ФИГНУ!".u)
+   assert_equal(a, "ФИГНУ!".u)
+   assert_equal(a, a.clone)
+ end
+ 
+ def test_aref
+    a = "hello there".u
+    assert_equal('e'.u, a[1])                   #=> 'e'
+    assert_equal('ell'.u, a[1,3])               #=> "ell"
+    assert_equal('ell'.u, a[1..3])                #=> "ell"
+    assert_equal('er'.u, a[-3,2])                #=> "er"
+    assert_equal('her'.u, a[-4..-2])              #=> "her"
+    assert_nil(a[12..-1])              #=> nil
+    assert_equal(''.u, a[-2..-4])      #=> ""
+    assert_equal('ell'.u, a[ure('[aeiou](.)\1')])      #=> "ell"
+    assert_equal('ell'.u, a[ure('[aeiou](.)\1'), 0])   #=> "ell"
+    assert_equal('l'.u,   a[ure('[aeiou](l)\1'), 1])   #=> "l"
+    assert_nil( a[ure('[aeiou](.)$1'), 2])   #=> nil
+    assert_equal('lo'.u, a["lo".u])                #=> "lo"  
+    assert_nil(a["bye".u])               #=> nil   
+  end
+
+  def test_slice_bang
+    string = "this is a string".u
+    assert_equal(string.slice!(2) , 'i'.u)
+    assert_equal(string.slice!(3..6) , " is ".u) 
+    assert_equal(string.slice!(ure("s.*t")) , "sa st".u)
+    assert_equal(string.slice!("r".u) , "r".u)
+    assert_equal(string , "thing".u)
+    a = "test".u
+    a[0] = "BEA".u
+    assert_equal("BEAest".u, a)
+  end
+
+  def test_gsub
+    assert_equal("hello".u.gsub(ure("[aeiou]"), '*'.u)              , "h*ll*".u)
+    assert_equal("hello".u.gsub(ure("([aeiou])"), '<$1>'.u)         , "h<e>ll<o>".u)
+    i = 0 
+    assert_equal("12345".u , "hello".u.gsub(ure(".")) {|s| i+=1; i.to_s})
+    assert_equal("214365".u, "123456".u.gsub(ure("(.)(.)")) {|s| s[2] + s[1] })
+    a = "test".u
+    a.gsub!(/t/.U, a)
+    assert_equal("testestest".u, a)
+  end
+
+  def test_ure_case_eq
+    a = "HELLO".u
+    v = case a
+      when ure("^[a-z]*$"); "Lower case"
+      when ure("^[A-Z]*$"); "Upper case"
+      else;           "Mixed case"
+    end
+    assert_equal('Upper case', v)
+  end
+  
+ #  UString::strcoll("ÆSS".u, "AEß".u, "de", 0)
+ def test_empty
+    assert(! "hello".u.empty?)
+    assert("".empty?)
+    assert("test".u.clear.empty?)
+    assert(" \t\n".u.strip.empty?)
+ end
+
+ def test_clear
+   a = "test".u
+   a.clear
+   assert_equal(0, a.length)
+ end
+ 
+ def test_length
+    assert_equal(10, "12345АБВГД".u.length)
+    assert_equal(0,"".u.length)
+    assert_equal(3,"abc".u.length)
+ end
+ 
+ def test_replace
+    s = "hello".u
+    s.replace("world".u)
+    assert_equal(s, "world".u)
+ end
+ 
+ def test_cmp	
+    assert_equal("абвгде".u <=> "абвгд".u     , 1  )
+    assert_equal("абвгде".u <=> "абвгде".u    , 0  )        	
+    assert_equal("абвгде".u <=> "абвгдеж".u   , -1 )        	
+    assert_equal("абвгде".u <=> "АБВГДЕ".u    , -1  ) # UCA
+ end
+
+ def test_plus
+   assert_equal("сложение".u, "сло".u + "жение".u)
+ end
+
+ def test_times
+   assert_equal("ААААА".u, "А".u * 5)
+ end
+
+ def test_concat
+   assert_equal("сложение".u, "сло".u << "жение".u)
+   assert_equal("сложение".u, "сло".u.concat("жение".u))
+   a = "сло".u
+   a << "жение".u
+   assert_equal("сложение".u, a)
+ end
+ 
+ def test_search
+      a = "A quick brown fox jumped over the lazy fox dancing foxtrote".u                                          	
+      assert_equal(a.search("fox".u) , [14..16, 39..41, 51..53])
+      assert_equal(a.search("FoX".u) , [])
+      assert_equal(a.search("FoX".u, :ignore_case => true) , [14..16, 39..41, 51..53])
+      assert_equal(a.search("FoX".u, :ignore_case => true, :whole_words => true) , [14..16, 39..41])
+      assert_equal(a.search("FoX".u, :ignore_case => true, :whole_words => true, :limit => 1) , [14..16])
+      
+      b = "Iñtërnâtiônàlizætiøn îs cọmpłèx".u.upcase 
+      assert_equal(b, "IÑTËRNÂTIÔNÀLIZÆTIØN ÎS CỌMPŁÈX".u)
+      assert_equal(b.search("nâtiôn".u, :locale => "en") , [])
+      assert_equal(b.search("nation".u) , [])
+      assert_equal(b.search("nation".u, :locale => "en", :ignore_case_accents => true) , [5..10])
+      assert_equal(b.search("nâtiôn".u, :locale => "en", :ignore_case => true) , [5..10])
+      assert_equal(b.search("zaeti".u, :locale => "en" ) , [])
+      assert_equal(b.search("zaeti".u, :locale => "en", :ignore_case => true) , [])
+      assert_equal(b.search("zaeti".u, :locale => "en", :ignore_case_accents => true) , [14..17])
+      assert_equal("İSTANBUL".u.search("istanbul".u, :locale => 'tr', :ignore_case => true), [0..7])
+      assert_equal("ёжий".u.norm_D.search("ЕЖИЙ".u, :locale => 'ru', :canonical => true, :ignore_case_accents => true), [0..4])
+  end
+
+  def test_dollar_sign_regexp
+      assert_equal("te$et".u, "test".u.gsub(/s/.U, '$e'.u))
+  end
+  
+  def test_codepoints
+      a=[0x01234, 0x0434, 0x1D7D9, ?t, ?e, ?s]
+      b=a.pack("U*").u
+      assert_equal(a, b.codepoints)
+      assert_equal(b, a.to_u)
+  end
+
+    def test_chars
+    chr =      ["I", "Ñ", "T", "Ë", "R", "N", "Â", "T", "I", "Ô", "N", "À", "L", "I", "Z", "Æ", "T", "I", "Ø", "N" ]
+    chr = chr.collect {|s| s.to_u.norm_C}
+    assert_equal(chr, "Iñtërnâtiônàlizætiøn".u.upcase.norm_D.chars)
+
+    end
+
+
+    def test_fmt
+      assert_equal("b a".u, "{1} {0}".u.fmt("en", "a".u, "b".u))
+      assert_equal("12,345.56".u, "{0, number}".u.fmt("en", 12345.56))
+      assert_equal("$12,345.56".u, "{0, number, currency}".u.fmt("en_US", 12345.56))
+      assert_equal("20:15:01 13/01/2006".u, "{0,date,HH:mm:ss dd/MM/yyyy}".u.fmt("en", Time.local(2006,"jan",13,20,15,1)))
+    end
+
+    def test_norm
+	  v="Iñtërnâtiônàlizætiøn".u
+	  assert_equal("Iñtërnâtiônàlizætiøn".u,  v.norm_C)
+	  assert_equal("Iñtërnâtiônàlizætiøn".u, 	v.norm_D)
+	  assert_equal("Iñtërnâtiônàlizætiøn".u, 	    v.norm_D.norm_FCD)
+	  assert_equal("Iñtërnâtiônàlizætiøn".u,v.norm_D.norm_KC)
+    end
+
+    def test_scan
+      a = "cruel world".u
+      assert_equal(a.scan(/\w+/.U)        ,["cruel".u , "world".u ])
+      assert_equal(a.scan(/.../.U)        ,["cru".u , "el ".u , "wor".u ])
+      assert_equal(a.scan(/(...)/.U)      ,["cru".u , "el ".u , "wor".u ])
+      assert_equal(a.scan(/(..)(..)/.U)   ,[["cr".u , "ue".u ], ["l ".u , "wo".u ]]	    )
+    end
+    def S(str)
+      str.to_u
+    end
+    def test_split
+		  re = URegexp.new("[,:/]".u)
+		  assert_equal(["split test".u ,  "west".u ,  "best".u ,  "east".u ], re.split("split test,west:best/east".u, nil))
+      assert_equal(["split test".u, "west:best/east".u], re.split("split test,west:best/east".u, 2))
+      assert_equal([S("a"), S("b"), S("c")], S("a   b\t c").split(S("\\s+")))
+      assert_equal([S(" a "), S(" b "), S(" c ")], S(" a | b | c ").split(S("\\|")))
+      assert_equal([S("a"), S("b"), S("c")], S("aXXbXXcXX").split(/X./.U))
+      assert_equal([S("a|b|c")], S("a|b|c").split(S('\|'), 1))
+      assert_equal([S("a"), S("b|c")], S("a|b|c").split(S('\|'), 2))
+      assert_equal([S("a"), S("b"), S("c")], S("a|b|c").split(S('\|'), 3))
+      assert_equal([S("a"), S("b"), S("c")], S("a|b|c|").split(S('\|'), -1))
+      assert_equal([S("a"), S("b"), S("c"), S("") ], S("a|b|c||").split(S('\|'), -1))
+      assert_equal([S("a"), S(""), S("b"), S("c")], S("a||b|c|").split(S('\|'), -1))
+    end
+
+
+    def test_strcoll
+    assert_equal(0,  UString::strcoll("a".u, "a".u))
+    assert_equal(-1, UString::strcoll("y".u, "k".u, "lv"))
+    assert_equal(1,  UString::strcoll("я".u, "а".u))
+    assert_equal(1,  UString::strcoll("я".u, "А".u, "ru"))
+    assert_equal(0,  UString::strcoll("İSTANBUL".u, "istanbul".u, "tr", 0))
+    assert_equal(0,  UString::strcoll("ой её".u, "ОЙ ЕЁ".u, "ru", 1))
+    end
+
+    def test_gsub_block
+    	a = "АБРАКАДАБРА".u
+	r = URegexp.new("(.)(.)(А)".u, URegexp::IGNORECASE)
+	b = a.gsub(r) do |m|
+	  assert_equal("ава".u, "бравада".u.gsub(r) {|v| v[3]} )
+	  m[3] + m[2] + m[1]
+	end
+	assert_equal("ААРБКАДААРБ".u, b)
+    end
+
+    def test_match_range
+    	t = "test\ntext".u
+	m = (t =~ /^.+$/m.U)
+	assert_equal('test'.u, m[0])
+	assert_equal(0..3, m.range(0))
+    end
+
+    def test_resbundle
+    	b = UResourceBundle.open(nil, "en")
+	assert_equal("Russia".u, b["Countries"]["RU"])
+	b = UResourceBundle.open(nil, "ru")
+	assert_equal("Россия".u, b["Countries"]["RU"])
+
+    end
+
+    def test_translit
+    	assert_equal('zees ees A  tfs t'.u, "This is A test".u.translit("null".u, "a>b;b>c;c>d;d>e;e>f;i>ee;[Tt]h>z;t>\\ t".u))
+	assert_equal("matsumoto yukihiro".u.translit("Latin-Hiragana".u), "まつもと ゆきひろ".u)
+    end
+
+    def test_parse_double
+         assert_equal(456, "456".u.to_f)
+    	 assert_equal("123,001".u.to_f("ru"),  123.001)
+	 assert_equal("123,001".u.to_f("en"), 123001.0)
+	 assert_equal("Got 123,001".u.to_f("en", "Got ###,###".u), 123001)
+	 assert_equal(123.45, "١٢٣٫٤٥".u.to_f("ar_YE"))
+    end
+
+    def test_unescape
+	    a = '\u0054\u0068\u0069\u0073\u0020\u0069\u0073\u0020\u0041\u0020\u0074\u0065\u0073\u0074\n!'
+	    assert_equal("This is A test\n!", a.u.unescape.to_s)
+    end
+
+    def test_ranges
+	    v = "\\x{1D7D9}\\x{1d7da}\\x{1d7db}!".u.unescape
+	    assert_equal(7, v.length)
+	    assert_equal(4, v.point_count)
+	    assert_equal(0..0, v.conv_unit_range(0..1))
+	    assert_equal(0..1, v.conv_unit_range(0..2))
+	    assert_equal(0..3, v.conv_unit_range(0..-1))
+	    assert_equal(2..3, v.conv_unit_range(-3..-1))
+	    
+	    assert_equal(0..3, v.conv_point_range(0..1))
+	    assert_equal(0..5, v.conv_point_range(0..2))
+	    assert_equal(0..6, v.conv_point_range(0..-1))
+	    assert_equal(4..6, v.conv_point_range(-2..-1))
+    end
+
+    def test_char_span
+    	v = "ЁРШ ТВОЙУ МЕДДЬ".u.norm_D
+	assert_equal("ЁРШ".u, v.char_span(0,3))
+	assert_equal('\u0415\u0308\u0420'.u.unescape, v[0,3])
+	assert_equal(v.norm_C, v.char_span(0,-1))
+    end
+
+    def test_sentinel_bug
+    	("test" * 10).u.gsub(/e/.U, 'abracadabra'.u)
+    end
+
+    def test_string_change
+    	a = " 123456789Aa ".u 
+	assert_raise(RuntimeError) { 	a.gsub!(/\d/.U) { |m|	a.downcase!; m} }; 
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+	assert_raise(RuntimeError) { 	a.gsub!(/\d/.U) { |m|	a.upcase!; m} }
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+	assert_raise(RuntimeError) { 	a.gsub!(/\d/.U) { |m|	a.lstrip!; m} }
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+	assert_raise(RuntimeError) { 	a.gsub!(/\d/.U) { |m|	a.rstrip!; m} }
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+	assert_raise(RuntimeError) { 	a.gsub!(/\d/.U) { |m|	a.strip!; m} }
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+	assert_raise(RuntimeError) { 	a.gsub!(/\d/.U) { |m|	a.slice!(/Aa/.U); m} }
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+	assert_raise(RuntimeError) { 	a.gsub!(/\d/.U) { |m|	a.slice!("Aa".u); m} }
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+	assert_raise(RuntimeError) { 	a.gsub!(/\d/.U) { |m|	a.slice!(3,5); m} }
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+	assert_raise(RuntimeError) { 	a.gsub!(/\d/.U) { |m|	a.sub!(/Aa/.U, "BUG!".u); m} }
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+	assert_raise(RuntimeError) { 	a.gsub!(/\d/.U) { |m|	a.gsub!(/Aa/.U, "BUG!".u); m} }
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+	assert_raise(RuntimeError) { 	a.scan(/\d/.U) { |m|	a.gsub!(/Aa/.U, "BUG!".u); m} }
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+	assert_raise(RuntimeError) { 	a.each_char { |m|	a[2]= "BUG!".u } }
+	assert_equal(" 123456789Aa ".u , a); 	a = a.clone
+
+    end
+    def test_1_to_u_to_s
+	assert_equal(
+		"\355\350\367\345\343\356 \355\345 \360\340\341\356\362\340\345\362 :( ?".to_u("cp-1251").to_s("utf-8"),
+		"\320\275\320\270\321\207\320\265\320\263\320\276 \320\275\320\265 \321\200\320\260\320\261\320\276\321\202\320\260\320\265\321\202 :( ?")
+   end
+
+   def test_nested_blocks
+   	a = "Модифицируемые строки иногда напрягают :)".u
+	b = "".u
+   	assert_nothing_raised {
+		a.scan(/./.U) { |s|
+			b = a.gsub(ure('и')) { |m| 
+				t = m[0] + "".u
+				a.each_char { |c|
+			       		t << c if c == 'о' .u
+			   	}
+				t
+			}
+		}
+	}
+	assert_equal("Модиооофиоооциоооруемые строкиооо иоооногда напрягают :)".u, b)
+   end
+   
+  def test_AREF # '[]'
+    assert_equal(S("A"),  S("AooBar")[0])
+    assert_equal(S("B"),  S("FooBaB")[-1])
+    assert_equal(nil, S("FooBar")[6])
+    assert_equal(nil, S("FooBar")[-7])
+
+    assert_equal(S("Foo"), S("FooBar")[0,3])
+    assert_equal(S("Bar"), S("FooBar")[-3,3])
+    assert_equal(S(""),    S("FooBar")[6,2])
+    assert_equal(nil,      S("FooBar")[-7,10])
+
+    assert_equal(S("Foo"), S("FooBar")[0..2])
+    assert_equal(S("Foo"), S("FooBar")[0...3])
+    assert_equal(S("Bar"), S("FooBar")[-3..-1])
+    assert_equal(S(""),    S("FooBar")[6..2])
+    assert_equal(nil,      S("FooBar")[-10..-7])
+
+    assert_equal(S("Foo"), S("FooBar")[/^F../.U])
+    assert_equal(S("Bar"), S("FooBar")[/..r$/.U])
+    assert_equal(nil,      S("FooBar")[/xyzzy/.U])
+    assert_equal(nil,      S("FooBar")[/plugh/.U])
+
+    assert_equal(S("Foo"), S("FooBar")[S("Foo")])
+    assert_equal(S("Bar"), S("FooBar")[S("Bar")])
+    assert_equal(nil,      S("FooBar")[S("xyzzy")])
+    assert_equal(nil,      S("FooBar")[S("plugh")])
+
+      assert_equal(S("Foo"), S("FooBar")[/([A-Z]..)([A-Z]..)/.U, 1])
+      assert_equal(S("Bar"), S("FooBar")[/([A-Z]..)([A-Z]..)/.U, 2])
+      assert_equal(nil,      S("FooBar")[/([A-Z]..)([A-Z]..)/.U, 3])
+      assert_equal(S("Bar"), S("FooBar")[/([A-Z]..)([A-Z]..)/.U, -1])
+      assert_equal(S("Foo"), S("FooBar")[/([A-Z]..)([A-Z]..)/.U, -2])
+      assert_equal(nil,      S("FooBar")[ure("([A-Z]..)([A-Z]..)"), -3])
+  end
+  
+  def test_ASET # '[]='
+    s = S("FooBar")
+    s[0] = S('A')
+    assert_equal(S("AooBar"), s)
+
+    s[-1]= S('B')
+    assert_equal(S("AooBaB"), s)
+    assert_raise(IndexError) { s[-7] = S("xyz") }
+    assert_equal(S("AooBaB"), s)
+    s[0] = S("ABC")
+    assert_equal(S("ABCooBaB"), s)
+
+    s = S("FooBar")
+    s[0,3] = S("A")
+    assert_equal(S("ABar"),s)
+    s[0] = S("Foo")
+    assert_equal(S("FooBar"), s)
+    s[-3,3] = S("Foo")
+    assert_equal(S("FooFoo"), s)
+    assert_raise (IndexError) { s[7,3] =  S("Bar") }
+    assert_raise (IndexError) { s[-7,3] = S("Bar") }
+
+    s = S("FooBar")
+    s[0..2] = S("A")
+    assert_equal(S("ABar"), s)
+    s[1..3] = S("Foo")
+    assert_equal(S("AFoo"), s)
+    s[-4..-4] = S("Foo")
+    assert_equal(S("FooFoo"), s)
+    assert_raise (RangeError) { s[7..10]   = S("Bar") }
+    assert_raise (RangeError) { s[-7..-10] = S("Bar") }
+
+    s = S("FooBar")
+    s[/^F../.U]= S("Bar")
+    assert_equal(S("BarBar"), s)
+    s[/..r$/.U] = S("Foo")
+    assert_equal(S("BarFoo"), s)
+    
+      s[/([A-Z]..)([A-Z]..)/.U, 1] = S("Foo")
+      assert_equal(S("FooFoo"), s)
+      s[/([A-Z]..)([A-Z]..)/.U, 2] = S("Bar")
+      assert_equal(S("FooBar"), s)
+      assert_raise (IndexError) { s[/([A-Z]..)([A-Z]..)/.U, 3] = "None" }
+      s[ure("([A-Z]..)([A-Z]..)"), -1] = S("Foo")
+      assert_equal(S("FooFoo"), s)
+      s[/([A-Z]..)([A-Z]..)/.U, -2] = S("Bar")
+      assert_equal(S("BarFoo"), s)
+      #      assert_raise (IndexError) { s[/([A-Z]..)([A-Z]..)/.U, -3] = "None" }
+
+    s = S("FooBar")
+    s[S("Foo")] = S("Bar")
+    assert_equal(S("BarBar"), s)
+
+   s = S("a string")
+    s[0..s.size] = S("another string")
+    assert_equal(S("another string"), s)
+  end
+end