icu4r 0.1.3.2006.01.26

data/docs/UNICODE_REGEXPS

@@ -0,0 +1,204 @@
+This is one-stop reference  on Unicode regular expressions syntax, available in ICU.
+This text is compiled from several sources in ICU userguide and code docs.
+
+===  Regular Expression Metacharacters
+     
+     Character      Description
+     \a     Match a BELL, \u0007
+     \A     Match at the beginning of the input. Differs from ^ in that \A will not match after a new line within the input.
+     \b, outside of a [Set]         Match if the current position is a word boundary. Boundaries occur 
+     at the transitions between word (\w) and non-word (\W) characters, 
+     with combining marks ignored. For better word boundaries, see ICU Boundary Analysis .
+     \b, within a [Set]     Match a BACKSPACE, \u0008.
+     \B     Match if the current position is not a word boundary.
+     \cX    Match a control-X character.
+     \d     Match any character with the Unicode General Category of Nd (Number, Decimal Digit.)
+     \D     Match any character that is not a decimal digit.
+     \e     Match an ESCAPE, \u001B.
+     \E     Terminates a \Q ... \E quoted sequence.
+     \f     Match a FORM FEED, \u000C.
+     \G     Match if the current position is at the end of the previous match.
+     \n     Match a LINE FEED, \u000A.
+     \N{UNICODE CHARACTER NAME}     Match the named character.
+     \p{UNICODE PROPERTY NAME}      Match any character with the specified Unicode Property.
+     \P{UNICODE PROPERTY NAME}      Match any character not having the specified Unicode Property.
+     \Q     Quotes all following characters until \E.
+     \r     Match a CARRIAGE RETURN, \u000D.
+     \s     Match a white space character. White space is defined as [\t\n\f\r\p{Z}].
+     \S     Match a non-white space character.
+     \t     Match a HORIZONTAL TABULATION, \u0009.
+     \uhhhh         Match the character with the hex value hhhh.
+     \Uhhhhhhhh     Match the character with the hex value hhhhhhhh. Exactly eight hex digits must be 
+     provided, even though the largest Unicode code point is \U0010ffff.
+     \w     Match a word character. Word characters are [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}].
+     \W     Match a non-word character.
+     \x{hhhh}       Match the character with hex value hhhh. From one to six hex digits may be supplied.
+     \xhh   Match the character with two digit hex value hh
+     \X     Match a Grapheme Cluster .
+     \Z     Match if the current position is at the end of input, but before the final line terminator, if one exists.
+     \z     Match if the current position is at the end of input.
+     \n     Back Reference. Match whatever the nth capturing group matched. n must be a number > 1 and <  total number 
+            of capture groups in the pattern. Note: Octal escapes, such as \012, are not supported in ICU regular expressions
+     [pattern]      Match any one character from the set. See UnicodeSet for a full description of what may  appear in the pattern
+     .      Match any character.
+     ^      Match at the beginning of a line.
+     $      Match at the end of a line.
+     \      Quotes the following character. Characters that must be quoted to be treated as literals are * ? + [ ( ) { } ^ $ | \ . /
+     
+===   Regular Expression Operators
+     
+     Operator       Description
+     |           Alternation. A|B matches either A or B.
+     *      Match 0 or more times. Match as many times as possible.
+     +      Match 1 or more times. Match as many times as possible.
+     ?      Match zero or one times. Prefer one.
+     {n}    Match exactly n times
+     {n,}   Match at least n times. Match as many times as possible.
+     {n,m}  Match between n and m times. Match as many times as possible, but not more than m.
+     *?     Match 0 or more times. Match as few times as possible.
+     +?     Match 1 or more times. Match as few times as possible.
+     ??     Match zero or one times. Prefer zero.
+     {n}?   Match exactly n times
+     {n,}?  Match at least n times, but no more than required for an overall pattern match
+     {n,m}?         Match between n and m times. Match as few times as possible, but not less than n.
+     *+             Match 0 or more times. Match as many times as possible when first encountered, do not retry with 
+     fewer even if overall match fails (Possessive Match)
+     ++             Match 1 or more times. Possessive match.
+     ?+     Match zero or one times. Possessive match.
+     {n}+   Match exactly n times
+     {n,}+  Match at least n times. Possessive Match.
+     {n,m}+         Match between n and m times. Possessive Match.
+     ( ... )        Capturing parentheses. Range of input that matched the parenthesized subexpression is 
+     available after the match.
+     (?: ... )      Non-capturing parentheses. Groups the included pattern, but does not provide 
+     capturing of matching text. Somewhat more efficient than capturing parentheses.
+     (?> ... )      Atomic-match parentheses. First match of the parenthesized subexpression is the only 
+     one tried; if it does not lead to an overall pattern match, back up the search for a 
+     match to a position before the "(?>"
+     (?# ... )      Free-format comment (?# comment ).
+     (?= ... )      Look-ahead assertion. True if the parenthesized pattern matches at the current input position,
+     but does not advance the input position.
+     (?! ... )      Negative look-ahead assertion. True if the parenthesized pattern does not match at the current 
+     input position. Does not advance the input position.
+     (?<= ... )     Look-behind assertion. True if the parenthesized pattern matches text preceding the current 
+     input position, with the last character of the match being the input character just before 
+     the current position. Does not alter the input position. The length of possible strings matched 
+     by the look-behind pattern must not be unbounded (no * or + operators.)
+     (?<! ... )     Negative Look-behind assertion. True if the parenthesized pattern does not 
+     match text preceding the current input position, with the last character of the 
+     match being the input character just before the current position. Does not alter 
+     the input position. The length of possible strings matched by the look-behind pattern 
+     must not be unbounded (no * or + operators.)
+     (?ismx-ismx: ... )     Flag settings. Evaluate the parenthesized expression with the specified flags enabled or -disabled.
+     (?ismx-ismx)   Flag settings. Change the flag settings. Changes apply to the portion of the pattern 
+     following the setting. For example, (?i) changes to a case insensitive match.
+     
+===   Replacement Text
+     
+The replacement text for find-and-replace operations may contain references to capture-group text from the find. References are of the form $n, where n is the number of the capture group.
+     
+     Character      Descriptions
+     $n     The text of capture group n will be substituted for $n. n must be >= 0 and not 
+     greater than the number of capture groups. A $ not followed by a digit has no special meaning, 
+     and will appear in the substitution text as itself, a $.
+     \      Treat the following character as a literal, suppressing any special meaning. Backslash escaping in 
+     substitution text is only required for '$' and '\', but may be used on any other character without bad effects.
+
+=== UnicodeSet Pattern syntax
+
+These patterns follow a syntax similar to that employed by version 8 regular expression character classes. 
+
+Here are some simple examples:
+
+    [] 	No characters
+    [a] 	The character 'a'
+    [ae] 	The characters 'a' and 'e'
+    [a-e] 	The characters 'a' through 'e' inclusive, in Unicode code point order
+    [\u4E01] 	The character U+4E01
+    [a{ab}{ac}] 	The character 'a' and the multicharacter strings "ab" and "ac"
+    [\p{Lu}] 	All characters in the general category Uppercase Letter
+
+Any character may be preceded by a backslash in order to remove any special meaning. 
+White space characters, are ignored, unless they are escaped.
+
+Property patterns specify a set of characters having a certain property as defined by the 
+Unicode standard. Both the POSIX-like "[:Lu:]" and the Perl-like syntax "\\p{Lu}" are recognized. 
+
+Patterns specify individual characters, ranges of characters, and Unicode property sets. 
+When elements are concatenated, they specify their union. To complement a set, place a '^' 
+immediately after the opening '['. Property patterns are inverted by modifying their delimiters; 
+"[:^foo]" and "\\P{foo}". In any other location, '^' has no special meaning.
+
+Ranges are indicated by placing two a '-' between two characters, as in "a-z". 
+This specifies the range of all characters from the left to the right, in Unicode order. 
+If the left character is greater than or equal to the right character it is a syntax error. 
+If a '-' occurs as the first character after the opening '[' or '[^', or if it occurs as the 
+last character before the closing ']', then it is taken as a literal. Thus "[a\-b]", "[-ab]", 
+and "[ab-]" all indicate the same set of three characters, 'a', 'b', and '-'.
+
+Sets may be intersected using the '&' operator or the asymmetric set difference may be taken using 
+the '-' operator, for example, "[[:L:]&[\\u0000-\\u0FFF]]" indicates the set of all 
+Unicode letters with values less than 4096. Operators ('&' and '|') have equal precedence 
+and bind left-to-right. Thus "[[:L:]-[a-z]-[\\u0100-\\u01FF]]" is equivalent to 
+"[[[:L:]-[a-z]]-[\\u0100-\\u01FF]]". This only really matters for difference; intersection 
+is commutative.
+
+    [a]	The set containing 'a'
+    [a-z]	The set containing 'a' through 'z' and all letters in between, in Unicode order
+    [^a-z]	The set containing all characters but 'a' through 'z', that is, U+0000 through 'a'-1 
+                and 'z'+1 through U+10FFFF
+    [[pat1][pat2]] 	The union of sets specified by pat1 and pat2
+    [[pat1]&[pat2]] 	The intersection of sets specified by pat1 and pat2
+    [[pat1]-[pat2]] 	The asymmetric difference of sets specified by pat1 and pat2
+    [:Lu:] or \p{Lu} 	The set of characters having the specified Unicode property; in this case, Unicode uppercase letters
+    [:^Lu:] or \P{Lu} 	The set of characters not having the given Unicode property
+
+Warning: you cannot add an empty string ("") to a UnicodeSet.
+
+Formal syntax
+
+    pattern      := ('[' '^'? item* ']') | property
+    item         := char | (char '-' char) | pattern-expr
+    pattern-expr := pattern | pattern-expr pattern | pattern-expr op pattern
+    op           := '&' | '-'
+    special      := '[' | ']' | '-'
+    char         := any character that is not special | ('\' any character) | ('\u' hex hex hex hex)
+    hex          := any character for which Character.digit(c, 16) returns a non-negative result
+    property     := a Unicode property set pattern
+
+    Legend:
+    a := b 	  	a may be replaced by b
+    a? 		zero or one instance of a
+    a* 		one or more instances of a
+    a | b 		either a or b
+    'a' 		the literal string between the quotes 
+
+The C/POSIX character classes are also available in UnicodeSet patterns, using patterns like [:graph:] or \p{graph}.
+
+     alpha , lower , upper ,  punct ,  digit , xdigit, alnum , space , blank ,  cntrl ,  graph , print
+    
+=== General Categories
+
+    Lu = Letter, uppercase        Mn = Mark, nonspacing            Nd = Number, decimal digit
+    Ll = Letter, lowercase        Mc = Mark, spacing combining     Nl = Number, letter
+    Lt = Letter, titlecase        Me = Mark, enclosing             No = Number, other
+    Lm = Letter, modifier
+    Lo = Letter, other
+
+    Zs = Separator, space             Cc = Other, control
+    Zl = Separator, line              Cf = Other, format
+    Zp = Separator, paragraph         Cs = Other, surrogate
+                                      Co = Other, private use
+                                      Cn = Other, not assigned (including noncharacters)
+
+    Pc = Punctuation, connector                                                         Sm = Symbol, math
+    Pd = Punctuation, dash                                                              Sc = Symbol, currency
+    Ps = Punctuation, open                                                              Sk = Symbol, modifier
+    Pe = Punctuation, close                                                             So = Symbol, other
+    Pi = Punctuation, initial quote (may behave like Ps or Pe depending on usage)
+    Pf = Punctuation, final quote (may behave like Ps or Pe depending on usage)
+    Po = Punctuation, other
+
+
+See also http://www.unicode.org/Public/UNIDATA/PropertyAliases.txt and 
+http://www.unicode.org/Public/UNIDATA/PropertyValueAliases.txt for additional info.

data/extconf.rb

@@ -0,0 +1,15 @@
+require 'mkmf'
+$LDFLAGS = "-licuuc -licui18n -licudata -lstdc++ "
+$CFLAGS = "-Wall"
+if !have_library('icui18n', 'u_init_3_4')
+  puts "ICU v3.4 required -- not found."
+  exit 1
+end
+create_makefile('icu4r')
+File.open("Makefile", "a") << <<-EOT
+
+check:	$(DLLIB)
+	@$(RUBY) $(srcdir)/test/test_ustring.rb 
+	@$(RUBY) $(srcdir)/test/test_calendar.rb
+
+EOT

data/fmt.cpp

@@ -0,0 +1,150 @@
+#include "ruby.h"
+#include "icu_common.h"
+#include <unicode/msgfmt.h>
+#include <unicode/translit.h>
+#include <unicode/smpdtfmt.h>
+#include <unicode/calendar.h>
+#include <unicode/ucal.h>
+/* This file contains various C-C++ wrappers, to ease my life
+ */
+extern "C" { 
+extern  VALUE rb_cUString;
+extern  VALUE rb_cUCalendar;
+extern  VALUE icu_ustr_new(const UChar * str, long len);
+extern  VALUE icu_ustr_new_set(const UChar * str, long len, long capa);
+
+  VALUE icu_format(UChar * pattern, int32_t len, VALUE args, int32_t arg_len, char * locale)
+{
+  Formattable * arguments = new Formattable[arg_len];
+  int i, is_set;
+  VALUE obj;
+  for(i = 0; i < arg_len; i++){
+    obj = rb_ary_entry(args,i);
+    is_set = 0;
+    switch(TYPE(obj)){
+      case T_FIXNUM:
+      case T_FLOAT:
+        arguments[i].setDouble(rb_num2dbl(obj));
+        is_set = 1;
+        break;
+    }
+    if(! is_set) {
+       if (CLASS_OF(obj) == rb_cUString) {
+          arguments[i].setString(UnicodeString(ICU_PTR(obj), ICU_LEN(obj)));
+       } else 
+         if (CLASS_OF(obj) == rb_cTime) {
+           // ICU expects milliseconds since 01.01.1970
+           arguments[i].setDate(rb_num2dbl(rb_funcall(obj, rb_intern("to_f"), 0))*1000);
+         }
+         else {
+           delete [] arguments;
+           rb_raise(rb_eArgError, "wrong arg type: %s", rb_class2name(CLASS_OF(obj)));
+         }
+    }
+  }
+  UnicodeString patString(pattern,len);
+  UErrorCode status = U_ZERO_ERROR;
+  UnicodeString resultStr;
+  FieldPosition fieldPosition(0);
+  MessageFormat * fmt= new MessageFormat(patString,Locale(locale), status);
+  if( U_FAILURE(status) ){
+  	rb_raise(rb_eArgError, "Can't format: %s", u_errorName(status));
+  }
+  fmt->format(arguments,arg_len,resultStr,fieldPosition,status);
+  if( U_FAILURE(status) ){
+  	rb_raise(rb_eArgError, "Can't format: %s", u_errorName(status));
+  }
+  int32_t blen = resultStr.length();
+  UChar * buf = ALLOC_N(UChar, blen + 1);
+  resultStr.extract(buf, blen, status);
+  VALUE ret = icu_ustr_new( buf, blen);
+  free(buf);
+  delete[] arguments;
+  delete fmt;
+  return ret;
+}
+VALUE icu_date_parse(UChar * str, int32_t str_len, char * locale, UChar * val, int32_t len) 
+{
+   UErrorCode status = U_ZERO_ERROR;
+   SimpleDateFormat formatter(UnicodeString(str, str_len), Locale(locale), status);
+   if( U_FAILURE(status) ) {
+     rb_raise(rb_eArgError, u_errorName(status));
+   }
+   status = U_ZERO_ERROR;
+   UDate p_time = formatter.parse(UnicodeString(val, len), status);
+   if( U_FAILURE(status) ) {
+     rb_raise(rb_eArgError, u_errorName(status));
+   }
+   return rb_time_new( (time_t) (p_time/1000.0), 0);
+}
+VALUE icu_transliterate(UChar * str, int32_t str_len, UChar * id, int32_t id_len, UChar * rules, int32_t rule_len)
+{
+	UErrorCode    status = U_ZERO_ERROR;
+	UParseError   p_error;
+	Transliterator * t  ;
+	if( rules != NULL)  {
+	  t = Transliterator::createFromRules(UnicodeString(id, id_len), UnicodeString(rules, rule_len), 
+	  	UTRANS_FORWARD, p_error, status);
+	} else {
+	  t = Transliterator::createInstance(UnicodeString(id, id_len), UTRANS_FORWARD, p_error, status);
+	}
+	if( U_FAILURE(status) ) 
+	{
+	   rb_raise(rb_eRuntimeError, u_errorName(status));
+	}
+	UnicodeString * src = new UnicodeString(str, str_len);
+	t->transliterate(*src);
+	int32_t blen = src->length();
+	UChar * buf = ALLOC_N(UChar, blen + 1);
+	src->extract(buf, blen, status);
+	VALUE ret = icu_ustr_new_set( buf, blen, blen+1);
+	delete src;
+	delete t;
+	return ret;
+}
+extern void icu4r_cal_free(UCalendar *);
+
+VALUE icu4r_cal_clone(VALUE cal) 
+{
+	Calendar * clon;
+	clon = ((Calendar *)(DATA_PTR(cal)))->clone();
+	return Data_Wrap_Struct(rb_cUCalendar, 0, icu4r_cal_free, clon); 
+}
+#define CPP_CALENDAR(obj)  ((Calendar*)DATA_PTR(obj))
+VALUE icu4r_cal_before(VALUE cal, VALUE obj) 
+{
+	UErrorCode	status = U_ZERO_ERROR;
+	UBool		answer;
+	Check_Class( obj, rb_cUCalendar);
+	Calendar 	*other = CPP_CALENDAR(obj);
+	answer = CPP_CALENDAR(cal)->before(*other, status);
+	if( U_FAILURE(status) )	rb_raise(rb_eArgError,  u_errorName(status));
+	return answer ? Qtrue : Qfalse;	
+}
+
+VALUE icu4r_cal_time_equals(VALUE cal, VALUE obj) 
+{
+	UErrorCode	status = U_ZERO_ERROR;
+	UBool		answer;
+	Check_Class( obj, rb_cUCalendar);
+	Calendar 	*other = CPP_CALENDAR(obj);
+	answer = CPP_CALENDAR(cal)->equals(*other, status);
+	if( U_FAILURE(status) )	rb_raise(rb_eArgError,  u_errorName(status));
+	return answer ? Qtrue : Qfalse;	
+}
+
+VALUE icu4r_cal_after(VALUE cal, VALUE obj) 
+{	
+	Check_Class( obj, rb_cUCalendar);
+	return icu4r_cal_before(obj, cal);
+}
+
+VALUE icu4r_cal_equal(VALUE cal, VALUE obj) 
+{
+	UBool		answer;
+	Check_Class( obj, rb_cUCalendar);
+	answer = (*CPP_CALENDAR(cal)) == (*CPP_CALENDAR(obj));
+	return answer ? Qtrue : Qfalse;	
+}
+}
+

data/icu4r.c

@@ -0,0 +1,14 @@
+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);
+void Init_icu4r (void) {
+
+ initialize_ustring();
+ initialize_uregexp();
+ initialize_ucore_ext();
+ initialize_ubundle();
+ initialize_calendar();
+
+}

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;
+    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,109 @@
+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_equal(v.size, 577)
+		assert_equal( UString, v[0].class)
+		assert_equal("ACT".u, v[0] )
+	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( "GMT+01:00".u, c.time_zone)
+	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
+end