open_ehr 0.6.1

data/spec/lib/open_ehr/am/archetype/constraint_model/cardinality_spec.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe Cardinality do
+  before(:each) do
+    interval = Interval.new(:upper => 1, :lower => 0)
+    @cardinality = Cardinality.new(:is_ordered => true,
+                                   :is_unique => true,
+                                   :interval => interval)
+  end
+
+  it 'should be an instance of Cardinality' do
+    @cardinality.should be_an_instance_of Cardinality
+  end
+
+  it 'is_ordered should be assigned properly' do
+    @cardinality.should be_ordered
+  end
+
+  it 'is_ordered should be false' do
+    @cardinality.is_ordered = false
+    @cardinality.should_not be_ordered
+  end
+
+  it 'is_unique should be assigned properly' do
+    @cardinality.should be_unique
+  end
+
+  it 'is_unique should not be true' do
+    @cardinality.is_unique = false
+    @cardinality.should_not be_unique
+  end
+
+  it 'interval should be assigned properly' do
+    @cardinality.interval.upper.should be_equal 1
+  end
+
+  it 'is_set represent not ordered and unique' do
+    @cardinality.should_not be_set
+  end
+
+  it 'is_set should be true' do
+    @cardinality.is_unique = true
+    @cardinality.is_ordered = false
+    @cardinality.should be_set
+  end
+
+  it 'is_list represent ordered and not unique' do
+    @cardinality.is_ordered = true
+    @cardinality.is_unique = false
+    @cardinality.should be_list
+  end
+
+  it 'is_list should not be true' do
+    @cardinality.should_not be_list
+  end
+
+  it 'is_bag represent not ordered and not unique' do
+    @cardinality.is_ordered = false
+    @cardinality.is_unique = false
+    @cardinality.should be_bag
+  end
+
+  it 'is_bag? should not be true' do
+    @cardinality.should_not be_bag
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/constraint_ref_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel
+include OpenEHR::AssumedLibraryTypes
+
+describe ConstraintRef do
+  before(:each) do
+    occurrences = Interval.new(:lower => 0, :upper => 1)
+    @constraint_ref =
+      ConstraintRef.new(:path => '/event/[at0001]/',
+                        :rm_type_name => 'DV_TIME',
+                        :node_id => 'ac0001',
+                        :occurrences => occurrences,
+                        :reference => 'ac0002')
+  end
+
+  it 'should be an instance of ConstraintRef' do
+    @constraint_ref.should be_an_instance_of ConstraintRef
+  end
+
+  it 'reference should be assigned properly' do
+    @constraint_ref.reference.should == 'ac0002'
+  end
+
+  it 'should raise ArgumentError when reference is nil' do
+    lambda {
+      @constraint_ref.reference = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/primitive/c_boolean_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel::Primitive
+include OpenEHR::RM::DataTypes::Basic
+
+describe CBoolean do
+  before(:each) do
+    default_value = DvBoolean.new(:value => true)
+    @c_boolean = CBoolean.new(:default_value => true,
+                              :true_valid => true,
+                              :false_valid => true)
+  end
+
+  it 'should be_an_instance_of CBoolean' do
+    @c_boolean.should be_an_instance_of CBoolean
+  end
+
+  it 'true_valid should be assigned properly' do
+    @c_boolean.should be_true_valid
+  end
+
+  it 'false_valid should be assigned properly' do
+    @c_boolean.should be_false_valid
+  end
+
+  it 'should raise ArgumentError when both true_valid and false_valid are false' do
+    lambda {
+      @c_boolean.true_valid = false
+      @c_boolean.false_valid = false
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError if both false_valid and true_valid  are false' do
+    lambda {
+      @c_boolean.false_valid = false
+      @c_boolean.true_valid = false
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError if default_value is false and false_valid is false' do
+    lambda {
+      @c_boolean.false_valid = false
+      @c_boolean.default_value = false
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError if default_value is true and true_valid is false' do
+    lambda {
+      @c_boolean.true_valid = false
+      @c_boolean.default_value = true
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/primitive/c_date_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::AM::Archetype
+include OpenEHR::AM::Archetype::ConstraintModel::Primitive
+include OpenEHR::AssumedLibraryTypes
+
+describe CDate do
+  before(:each) do
+    default_value = ISO8601Date.new('2010-01-18')
+    assumed_value = ISO8601Date.new('2007-02-19')
+    range = Interval.new(:lower => ISO8601Date.new('2001-01-01'),
+                         :upper => ISO8601Date.new('2010-12-31'))
+    @c_date = CDate.new(:default_value => default_value,
+                        :assumed_value => assumed_value,
+                        :range => range,
+                        :month_validity => ValidityKind::MANDATORY,
+                        :day_validity => ValidityKind::OPTIONAL,
+                        :timezone_validity => ValidityKind::DISALLOWED)
+  end
+
+  it 'should be an instance of CDate' do
+    @c_date.should be_an_instance_of CDate
+  end
+
+  it 'range should be assigned properly' do
+    @c_date.range.upper.month.should be_equal 12
+  end
+
+  it 'month_validity should be assigned properly by constructor' do
+    @c_date.month_validity.should be_equal ValidityKind::MANDATORY
+  end
+
+  it 'validity_is_range should be true if range is assigned' do
+    @c_date.should be_validity_is_range
+  end
+
+  it 'validity_is_range should not be true if range is nil' do
+    @c_date.range = nil
+    @c_date.should_not be_validity_is_range
+  end
+
+  it 'day_validity should be assigned properly by constructor' do
+    @c_date.day_validity.should be_equal ValidityKind::OPTIONAL
+  end
+
+  it 'timezone should be assigned properly' do
+    @c_date.timezone_validity.should be_equal ValidityKind::DISALLOWED
+  end
+
+  describe 'method' do
+    it 'month_validity should be assigned by method properly' do
+      @c_date.month_validity = ValidityKind::OPTIONAL
+      @c_date.month_validity.should be_equal ValidityKind::OPTIONAL
+    end
+
+    it 'day_validity should be assigned by method properly' do
+      @c_date.day_validity = ValidityKind::MANDATORY
+      @c_date.day_validity.should be_equal ValidityKind::MANDATORY
+    end
+
+    it 'should raise ArgumentError if month_validity is optional and day validity is mandatory' do
+      @c_date.day_validity = ValidityKind::MANDATORY
+      lambda {
+        @c_date.month_validity = ValidityKind::OPTIONAL
+      }.should raise_error ArgumentError
+    end
+
+    it 'should raise ArgumentError if month_validity is disallowed and day_validity is mandatory' do
+      @c_date.day_validity = ValidityKind::MANDATORY
+      lambda {
+        @c_date.month_validity = ValidityKind::DISALLOWED
+      }.should raise_error ArgumentError
+    end
+
+    it 'should raise ArgumentError if month_validity is disallowed and day_validity is optional' do
+      lambda {
+        @c_date.month_validity = ValidityKind::DISALLOWED
+      }.should raise_error ArgumentError
+    end
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/primitive/c_date_time_spec.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::AssumedLibraryTypes
+include OpenEHR::AM::Archetype
+include OpenEHR::AM::Archetype::ConstraintModel::Primitive
+
+describe CDateTime do
+  before(:each) do
+    default_value = ISO8601DateTime.new('2010-01-25T01:23:45.1')
+    assumed_value = ISO8601DateTime.new('2001-12-23T22:02:33.2')
+    range = Interval.new(:lower => ISO8601DateTime.new('1995-04-19T01:01:22'),
+                         :upper => ISO8601DateTime.new('2022-12-31T23:55:59'))
+    @c_date_time =
+      CDateTime.new(:default_value => default_value,
+                    :assumed_value => assumed_value,
+                    :range => range,
+                    :month_validity => ValidityKind::MANDATORY,
+                    :day_validity => ValidityKind::MANDATORY,
+                    :hour_vaildity => ValidityKind::MANDATORY,
+                    :minute_validity => ValidityKind::MANDATORY,
+                    :second_validity => ValidityKind::OPTIONAL,
+                    :millisecond_validity => ValidityKind::DISALLOWED,
+                    :timezone_validity => ValidityKind::OPTIONAL)
+  end
+
+  it 'should be an instance of CDateTime' do
+    @c_date_time.should be_an_instance_of CDateTime
+  end
+
+  it 'hour_validity should be assigned properly' do
+    @c_date_time.hour_validity.should be_equal ValidityKind::MANDATORY
+  end
+
+  it 'should raise ArgumentError if hour_validity is DISALLOWED and minute_validity is not DISALLOWED' do
+    lambda {
+      @c_date_time.hour_validity = ValidityKind::DISALLOWED
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError if hour_validity is DISALLOWED and minute_validity is DISALLOWED' do
+    @c_date_time.second_validity = ValidityKind::DISALLOWED
+    @c_date_time.minute_validity = ValidityKind::DISALLOWED
+    lambda {
+      @c_date_time.hour_validity = ValidityKind::DISALLOWED
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError if hour_validity is OPTIONAL and minute_validity is MANDATORY' do
+    lambda {
+      @c_date_time.hour_validity = ValidityKind::OPTIONAL
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError if hour_validity is OPTIONAL and minute_validity is OPTIONAL' do
+    @c_date_time.minute_validity = ValidityKind::OPTIONAL
+    lambda {
+      @c_date_time.hour_validity = ValidityKind::OPTIONAL
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should not raise Argument Error if hour_validity is OPTIONAL and minute_validity is DISALLOWED' do
+    @c_date_time.second_validity = ValidityKind::DISALLOWED
+    @c_date_time.minute_validity = ValidityKind::DISALLOWED
+    lambda {
+      @c_date_time.hour_validity = ValidityKind::OPTIONAL
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError if day_validity is DISALLOWED and hour_validity is not DISALLOWED' do
+    lambda {
+      @c_date_time.day_validity = ValidityKind::DISALLOWED
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError if day_validity is DISALLOWED and hour_validity is DISALLOWED' do
+    @c_date_time.second_validity = ValidityKind::DISALLOWED
+    @c_date_time.minute_validity = ValidityKind::DISALLOWED
+    @c_date_time.hour_validity = ValidityKind::DISALLOWED
+    lambda {
+      @c_date_time.day_validity = ValidityKind::DISALLOWED
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError if day_validity is OPTIONAL and hour_validity is MANDATORY' do
+    lambda {
+      @c_date_time.day_validity = ValidityKind::OPTIONAL
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError if day_validity OPTIONAL and hour_validity is OPTIONAL' do
+    @c_date_time.second_validity = ValidityKind::DISALLOWED
+    @c_date_time.minute_validity = ValidityKind::DISALLOWED
+    @c_date_time.hour_validity = ValidityKind::OPTIONAL
+    lambda {
+      @c_date_time.day_validity = ValidityKind::OPTIONAL
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError if day_validity OPTIONAL and hour_validity is DISALLOWED' do
+    @c_date_time.second_validity = ValidityKind::DISALLOWED
+    @c_date_time.minute_validity = ValidityKind::DISALLOWED
+    @c_date_time.hour_validity = ValidityKind::DISALLOWED
+    lambda {
+      @c_date_time.day_validity = ValidityKind::OPTIONAL
+    }.should_not raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/primitive/c_duration_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::AssumedLibraryTypes
+include OpenEHR::AM::Archetype
+include OpenEHR::AM::Archetype::ConstraintModel::Primitive
+
+describe CDuration do
+  before(:each) do
+    assumed_value = stub(ISO8601Duration, :year => 2)
+    default_value = stub(ISO8601Duration, :month => 3)
+    range = stub(Interval, :upper => assumed_value, :lower => default_value)
+    @c_duration = CDuration.new(:assumed_value => assumed_value,
+                                :default_value => default_value,
+                                :range => range,
+                                :years_allowed => true,
+                                :months_allowed => false,
+                                :weeks_allowed => true,
+                                :days_allowed => false,
+                                :hours_allowed => true,
+                                :minutes_allowed => false,
+                                :seconds_allowed => true,
+                                :fractional_seconds_allowed => false)
+  end
+
+  it 'should be an instance of CDuration' do
+    @c_duration.should be_an_instance_of CDuration
+  end
+
+  it 'years_allowed should be assigned properly' do
+    @c_duration.years_allowed.should be_true
+  end
+
+  it 'months_allowed should be assigned properly' do
+    @c_duration.months_allowed.should be_false
+  end
+
+  it 'weeks_allowed should be assigned properly' do
+    @c_duration.weeks_allowed.should be_true
+  end
+
+  it 'days_allowed should be assigned properly' do
+    @c_duration.days_allowed.should be_false
+  end
+
+  it 'hours_allowed should be assigned properly' do
+    @c_duration.hours_allowed.should be_true
+  end
+
+  it 'minutes_allowed should be assigned properly' do
+    @c_duration.minutes_allowed.should be_false
+  end
+
+  it 'seconds_allowed should be assigned properly' do
+    @c_duration.seconds_allowed.should be_true
+  end
+
+  it 'fractional_seconds_allowed should be assigned properly' do
+    @c_duration.fractional_seconds_allowed.should be_false
+  end
+
+  it 'should raise ArgumentError if range is nil and all parameters are not allowed' do
+    @c_duration.years_allowed = false
+    @c_duration.weeks_allowed = false
+    @c_duration.hours_allowed = false
+    @c_duration.seconds_allowed = false
+    lambda {
+      @c_duration.range = nil
+    }.should raise_error ArgumentError
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/primitive/c_integer_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel::Primitive
+include OpenEHR::AssumedLibraryTypes
+
+describe CInteger do
+  before(:each) do
+    @c_integer = CInteger.new(:default_value => 3,
+                              :assumed_value => 2,
+                              :list => [1,2])
+  end
+
+  it 'should be an instance of CInteger' do
+    @c_integer.should be_an_instance_of CInteger
+  end
+
+  it 'should raise ArgumentError if both range and list are nil' do
+    lambda {
+      @c_integer.list = nil
+    }.should raise_error ArgumentError
+  end
+
+  describe 'list method' do
+    it 'constructor should assign list properly' do
+      @c_integer.list.should == [1,2]
+    end
+
+    it 'list method should re-assign properly' do
+      @c_integer.list = [2,3]
+      @c_integer.list.should == [2,3]
+    end
+
+    it 'should be raise ArgumentError if both list and range are not nil' do
+      lambda {
+        @c_integer.range = Interval.new(:lower => 1,:upper =>3)
+      }.should raise_error ArgumentError
+    end
+  end
+
+  describe 'range mathod' do
+    before(:each) do
+      @c_integer =
+        CInteger.new(:default_value => 2,
+                     :assumed_value => 3,
+                     :range => Interval.new(:lower => 0, :upper => 5))
+    end
+
+    it 'constructor should assign range properly' do
+      @c_integer.range.lower.should be_equal 0
+    end
+
+    it 'range method should re-assigne properly' do
+      @c_integer.range = Interval.new(:lower => 20)
+      @c_integer.range.lower.should be_equal 20
+    end
+
+    it 'should raise ArgumentError if bhot range and list are not nil' do
+      lambda {
+        @c_integer.list = [10,100]
+      }.should raise_error ArgumentError
+    end
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/primitive/c_primitive_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel::Primitive
+include OpenEHR::RM::DataTypes::Text
+
+describe CPrimitive do
+  before(:each) do
+    default = DvText.new(:value => 'DEFAULT')
+    assumed = DvText.new(:value => 'ASSUMED')
+    @c_primitive = CPrimitive.new(:default_value => default,
+                                  :assumed_value => assumed)
+  end
+
+  it 'should be an instance of CPrimitive' do
+    @c_primitive.should be_an_instance_of CPrimitive
+  end
+
+  it 'default value should be assigned properly' do
+    @c_primitive.default_value.value.should == 'DEFAULT'
+  end
+
+  it 'should raise ArgumentError when default_value is nil' do
+    lambda {
+      @c_primitive.default_value = nil
+    }.should raise_error ArgumentError
+  end
+
+  it 'assumed_value should be assigned properly' do
+    @c_primitive.assumed_value.value.should == 'ASSUMED'
+  end
+
+  it 'should be true when assumed_value is assigned' do
+    @c_primitive.should have_assumed_value
+  end
+
+  it 'should not be true when assumed_value is not assigned' do
+    @c_primitive.assumed_value = nil
+    @c_primitive.should_not have_assumed_value
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/primitive/c_real_spec.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel::Primitive
+
+describe CReal do
+  before(:each) do
+    @c_real = CReal.new(:default_value => 1.5,
+                              :assumed_value => 2.3,
+                              :list => [-1.5,20.3])
+  end
+
+  it 'should be an instance of CReal' do
+    @c_real.should be_an_instance_of CReal
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/primitive/c_string_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::AM::Archetype::ConstraintModel::Primitive
+include OpenEHR::RM::DataTypes::Text
+
+describe CString do
+  before(:each) do
+    @default_value = DvText.new(:value => 'default')
+    @c_string = CString.new(:default_value => @default_value,
+                            :assumed_value => 'assumed',
+                            :pattern => 't[a-z]st')
+  end
+
+  it 'should be an instance of CString' do
+    @c_string.should be_an_instance_of CString
+  end
+
+  it 'default should be assigned properly' do
+    @c_string.default_value.value.should == 'default'
+  end
+
+  it 'assumed_value should be assigned properly' do
+    @c_string.assumed_value.should == 'assumed'
+  end
+
+  it 'pattern should be assigned properly by constructor' do
+    @c_string.pattern.should == 't[a-z]st'
+  end
+
+  it 'pattern should be assigned properly by method' do
+    @c_string.pattern = '.*'
+    @c_string.pattern.should == '.*'
+  end
+
+  it 'should raise ArgumentError if either list or pattern is not nil' do
+    lambda {
+      @c_string.list = ['test','driven']
+    }.should raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError if both list and pattern are nil' do
+    lambda {
+      @c_string.pattern = nil
+    }.should raise_error ArgumentError
+  end
+
+  describe 'list attribute' do
+    before(:each) do
+      @default_value = DvText.new(:value => 'default')
+      @c_string = CString.new(:default_value => @default_value,
+                              :assumed_value => 'assumed',
+                              :list => ['test', 'behavior'])
+    end
+
+    it 'list should be assigned properly by constructor' do
+      @c_string.list.should == ['test', 'behavior']
+    end
+
+    it 'list shoudl be assigned properly by method' do
+      @c_string.list = ['spec']
+      @c_string.list.should == ['spec']
+    end
+
+    it 'should raise ArgumentError if both pattern and list is not nil' do
+      lambda {
+        @c_string.pattern = 'file.*'
+      }.should raise_error ArgumentError
+    end
+  end
+end

data/spec/lib/open_ehr/am/archetype/constraint_model/primitive/c_time_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/../../../../../../spec_helper'
+include OpenEHR::AssumedLibraryTypes
+include OpenEHR::AM::Archetype
+include OpenEHR::AM::Archetype::ConstraintModel::Primitive
+
+describe CTime do
+  before(:each) do
+    default_value = ISO8601Time.new('01:23:45')
+    assumed_value = ISO8601Time.new('22:02:33')
+    range = Interval.new(:lower => ISO8601Time.new('01:01:22'),
+                         :upper => ISO8601Time.new('23:55:59'))
+    @c_time = CTime.new(:default_value => default_value,
+                        :assumed_value => assumed_value,
+                        :range => range,
+                        :minute_validity => ValidityKind::MANDATORY,
+                        :second_validity => ValidityKind::OPTIONAL,
+                        :millisecond_validity => ValidityKind::DISALLOWED)
+  end
+
+  it 'should be an instance of CTime' do
+    @c_time.should be_an_instance_of CTime
+  end
+
+  it 'minute_validity should be assigned' do
+    @c_time.minute_validity.should be_equal ValidityKind::MANDATORY
+  end
+
+  it 'seconds_validity should be assigned properly' do
+    @c_time.second_validity.should be_equal ValidityKind::OPTIONAL
+  end
+
+  it 'millisecond_validity should be assigned properly' do
+    @c_time.millisecond_validity.should be_equal ValidityKind::DISALLOWED
+  end
+
+  it 'should be true if range is not nil' do
+    @c_time.should be_validity_is_range
+  end
+
+  it 'second_validity should not be MANDATORY if minute_validity is optional' do
+    @c_time.second_validity = ValidityKind::MANDATORY
+    lambda {
+      @c_time.minute_validity = ValidityKind::OPTIONAL
+    }.should raise_error ArgumentError
+  end
+
+  it 'second_validity should be DISALLOWED if minute_validity is DISALLOWED' do
+    lambda {
+      @c_time.minute_validity = ValidityKind::DISALLOWED
+    }.should raise_error ArgumentError
+  end
+
+  it 'should not raise ArgumentError if minute_validity and second_validity are DISALLOWED' do
+    @c_time.second_validity = ValidityKind::DISALLOWED
+    lambda {
+      @c_time.minute_validity = ValidityKind::DISALLOWED
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'millisecond_validity should not be MANDATORY if second_validity is optional' do
+    @c_time.millisecond_validity = ValidityKind::MANDATORY
+    lambda {
+      @c_time.second_validity = ValidityKind::OPTIONAL
+    }.should raise_error ArgumentError
+  end
+
+  it 'millisecond_validity should be DISALLOWED if second_validity is DISALLOWED' do
+    lambda {
+      @c_time.second_validity = ValidityKind::DISALLOWED
+    }.should_not raise_error ArgumentError
+  end
+
+  it 'should raise ArgumentError if second_validity is DISALLOWED and millisecond_validity is OPTIONAL' do
+    @c_time.millisecond_validity = ValidityKind::OPTIONAL
+    lambda {
+      @c_time.second_validity = ValidityKind::DISALLOWED
+    }.should raise_error ArgumentError
+  end
+end