[191] | 1 | require 'test/unit'
|
---|
| 2 | require 'set'
|
---|
| 3 |
|
---|
| 4 | class RM_Data_Types_Basic_Test < Test::Unit::TestCase
|
---|
| 5 | def setup
|
---|
| 6 | assert_nothing_raised(Exception){@dv_boolean = OpenEhr::RM::DataTypes::Basic::DvBoolean.new("TRUE")}
|
---|
| 7 | @terminology_id = OpenEhr::RM::Support::Identification::TerminologyId.new('openEHR(1.0.2)')
|
---|
| 8 | @code_phrase = OpenEhr::RM::DataTypes::Text::CodePhrase.new('PROPOSED', @terminology_id)
|
---|
| 9 | @dv_coded_text = OpenEhr::RM::DataTypes::Text::DvCodedText.new("Blood examination", @code_phrase)
|
---|
| 10 | assert_nothing_raised(Exception){@dv_state = OpenEhr::RM::DataTypes::Basic::DvState.new(@dv_coded_text, false)}
|
---|
| 11 | assert_nothing_raised(Exception){@dv_identifier = OpenEhr::RM::DataTypes::Basic::DvIdentifier.new("Ruby Hospital","0123456-0", "Information office", "personal id")}
|
---|
| 12 | end
|
---|
| 13 |
|
---|
| 14 | def test_init
|
---|
| 15 | assert_instance_of OpenEhr::RM::DataTypes::Basic::DvBoolean, @dv_boolean
|
---|
| 16 | assert_instance_of OpenEhr::RM::DataTypes::Basic::DvState, @dv_state
|
---|
| 17 | assert_instance_of OpenEhr::RM::DataTypes::Basic::DvIdentifier, @dv_identifier
|
---|
| 18 | end
|
---|
| 19 |
|
---|
| 20 | def test_constant
|
---|
| 21 | assert_equal("\r", OpenEhr::RM::DataTypes::Basic::DataValue::CR)
|
---|
| 22 | assert_equal("\n", OpenEhr::RM::DataTypes::Basic::DataValue::LF)
|
---|
| 23 | end
|
---|
| 24 |
|
---|
| 25 | def test_dv_boolean
|
---|
| 26 | assert @dv_boolean.value?
|
---|
| 27 | @dv_boolean.value = false
|
---|
| 28 | assert !@dv_boolean.value?
|
---|
| 29 | # inv: Value_exists
|
---|
| 30 | assert_raise(ArgumentError){@dv_boolean.value=nil}
|
---|
| 31 | assert_raise(ArgumentError){OpenEhr::RM::DataTypes::Basic::DvBoolean.new(nil)}
|
---|
| 32 | end
|
---|
| 33 |
|
---|
| 34 | def test_dv_state
|
---|
| 35 | assert_equal 'Blood examination', @dv_state.value.value
|
---|
| 36 | assert_equal 'PROPOSED', @dv_state.value.defining_code.code_string
|
---|
| 37 | assert_equal 'openEHR', @dv_state.value.defining_code.terminology_id.name
|
---|
| 38 | assert_equal '1.0.2', @dv_state.value.defining_code.terminology_id.version_id
|
---|
| 39 | assert !@dv_state.is_terminal?
|
---|
| 40 | assert_nothing_raised(Exception){@dv_state.value.defining_code.code_string = "COMPLETED"}
|
---|
| 41 | assert_nothing_raised(Exception){@dv_state.is_terminal = true}
|
---|
| 42 | assert_equal 'COMPLETED', @dv_state.value.defining_code.code_string
|
---|
| 43 | assert @dv_state.is_terminal?
|
---|
[216] | 44 | assert_raise(ArgumentError) {OpenEHR::RM::DataTypes::Basic::DvState.new(nil,nil)}
|
---|
[191] | 45 | assert_raise(ArgumentError) {@dv_state.value=nil}
|
---|
| 46 | assert_raise(ArgumentError) {@dv_state.is_terminal=nil}
|
---|
| 47 | end
|
---|
| 48 |
|
---|
| 49 | def test_dv_identifier
|
---|
| 50 | assert_equal("Ruby Hospital", @dv_identifier.assigner)
|
---|
| 51 | assert_equal("0123456-0", @dv_identifier.id)
|
---|
| 52 | assert_equal("Information office", @dv_identifier.issuer)
|
---|
| 53 | assert_equal("personal id", @dv_identifier.type)
|
---|
| 54 | @dv_identifier.assigner = "Test Hospital"
|
---|
| 55 | assert_equal("Test Hospital", @dv_identifier.assigner)
|
---|
| 56 | @dv_identifier.id = "TEST-0987"
|
---|
| 57 | assert_equal("TEST-0987", @dv_identifier.id)
|
---|
| 58 | @dv_identifier.issuer = "Security office"
|
---|
| 59 | assert_equal("Security office", @dv_identifier.issuer)
|
---|
| 60 | @dv_identifier.type = "test id"
|
---|
| 61 | assert_equal("test id", @dv_identifier.type)
|
---|
[216] | 62 | assert_raise(ArgumentError) {OpenEHR::RM::DataTypes::Basic::DvIdentifier.new(nil, nil, nil, nil)}
|
---|
[191] | 63 | end
|
---|
| 64 | end
|
---|
| 65 |
|
---|
| 66 | # fixed
|
---|
| 67 | class RM_Data_Types_URI_Test < Test::Unit::TestCase
|
---|
| 68 | def setup
|
---|
[216] | 69 | @dv_uri = OpenEHR::RM::DataTypes::Uri::DvUri.new("http://www.openehr.jp/changeset/test?cmd=93#file0")
|
---|
| 70 | @dv_ehr_uri = OpenEHR::RM::DataTypes::Uri::DvEhrUri.new("ehr://1234567/87284370-2D4B-4e3d-A3F3-F303D2F4F34B@2005-08-02T04:30:00")
|
---|
[191] | 71 | end
|
---|
| 72 |
|
---|
| 73 | def test_init
|
---|
[216] | 74 | assert_instance_of OpenEHR::RM::DataTypes::Uri::DvUri, @dv_uri
|
---|
| 75 | assert_instance_of OpenEHR::RM::DataTypes::Uri::DvEhrUri, @dv_ehr_uri
|
---|
[191] | 76 | end
|
---|
| 77 |
|
---|
| 78 | def test_dv_uri
|
---|
| 79 | assert_equal("file0", @dv_uri.fragment_id)
|
---|
| 80 | assert_equal("/changeset/test", @dv_uri.path)
|
---|
| 81 | assert_equal("cmd=93", @dv_uri.query)
|
---|
| 82 | assert_equal("http", @dv_uri.scheme)
|
---|
| 83 | assert_equal("http://www.openehr.jp/changeset/test?cmd=93#file0", @dv_uri.value)
|
---|
| 84 | @dv_uri.value="svn://www.openehr.jp/openehr-jp/"
|
---|
| 85 | assert_equal("svn://www.openehr.jp/openehr-jp/", @dv_uri.value)
|
---|
| 86 | assert_equal("/openehr-jp/", @dv_uri.path)
|
---|
| 87 | end
|
---|
| 88 |
|
---|
| 89 | def test_dv_ehr_uri
|
---|
| 90 | assert_equal("ehr", @dv_ehr_uri.scheme)
|
---|
| 91 | assert_raise(ArgumentError){
|
---|
| 92 | @dv_ehr_uri.value="svn://www.openehr.jp/openehr-jp/" }
|
---|
| 93 | end
|
---|
| 94 | end
|
---|
| 95 |
|
---|
| 96 | class RM_Data_Types_Text_Test < Test::Unit::TestCase
|
---|
| 97 | def setup
|
---|
[216] | 98 | assert_nothing_raised(Exception){@dv_text = OpenEHR::RM::DataTypes::Text::DvText.new("valid value")}
|
---|
| 99 | @terminology_id = OpenEHR::RM::Support::Identification::TerminologyId.new('ICD10')
|
---|
[191] | 100 |
|
---|
[216] | 101 | assert_nothing_raised(Exception){@code_phrase = OpenEHR::RM::DataTypes::Text::CodePhrase.new('C92.0', @terminology_id)}
|
---|
| 102 | assert_nothing_raised(Exception){@dv_coded_text = OpenEHR::RM::DataTypes::Text::DvCodedText.new("Acute Myeloid Leukemia", @code_phrase)}
|
---|
| 103 | @dv_paragraph = OpenEHR::RM::DataTypes::Text::DvParagraph.new(Set.new(["test1", "test2"]))
|
---|
| 104 | @term_mapping = OpenEHR::RM::DataTypes::Text::TermMapping.new('=',@dv_coded_text,"TEST")
|
---|
[191] | 105 | end
|
---|
| 106 |
|
---|
| 107 | def test_init
|
---|
[216] | 108 | assert_instance_of OpenEHR::RM::DataTypes::Text::DvText, @dv_text
|
---|
| 109 | assert_instance_of OpenEHR::RM::DataTypes::Text::CodePhrase, @code_phrase
|
---|
| 110 | assert_instance_of OpenEHR::RM::DataTypes::Text::DvCodedText, @dv_coded_text
|
---|
| 111 | assert_instance_of OpenEHR::RM::DataTypes::Text::TermMapping, @term_mapping
|
---|
[191] | 112 | end
|
---|
| 113 |
|
---|
| 114 | def test_dv_text
|
---|
| 115 | assert_equal("valid value", @dv_text.value)
|
---|
| 116 | assert_raise(ArgumentError){@dv_text.value = "not valid value\n"}
|
---|
| 117 | assert_raise(ArgumentError){@dv_text.value = nil }
|
---|
| 118 | assert_raise(ArgumentError){@dv_text.value = "" }
|
---|
| 119 | assert_raise(ArgumentError){@dv_text.formatting = "" }
|
---|
| 120 | assert_raise(ArgumentError){@dv_text.encoding = ""}
|
---|
| 121 | assert_raise(ArgumentError){@dv_text.language = ""}
|
---|
| 122 | assert_raise(ArgumentError){@dv_text.mappings = Set.new}
|
---|
| 123 | assert_raise(ArgumentError){@dv_text.mappings = ""}
|
---|
| 124 | assert_raise(ArgumentError){@dv_text.language = ""}
|
---|
| 125 | end
|
---|
| 126 |
|
---|
| 127 | def test_code_phrase
|
---|
| 128 | assert_equal 'C92.0', @code_phrase.code_string
|
---|
| 129 | assert_equal 'ICD10', @code_phrase.terminology_id.value
|
---|
| 130 | assert_nothing_raised(Exception){@code_phrase.code_string = 'C93.0'}
|
---|
| 131 | assert_equal 'C93.0', @code_phrase.code_string
|
---|
| 132 | end
|
---|
| 133 |
|
---|
| 134 | def test_dv_coded_text
|
---|
| 135 | assert_equal("Acute Myeloid Leukemia", @dv_coded_text.value)
|
---|
| 136 | assert_equal("ICD10", @dv_coded_text.defining_code.terminology_id.name)
|
---|
| 137 | assert_raise(ArgumentError){@dv_coded_text.defining_code=nil}
|
---|
| 138 | end
|
---|
| 139 |
|
---|
| 140 | def test_dv_paragraph
|
---|
| 141 | assert_equal((Set.new ["test1", "test2"]), @dv_paragraph.items)
|
---|
| 142 | assert_raise(ArgumentError){@dv_paragraph.items=Set.new}
|
---|
| 143 | end
|
---|
| 144 |
|
---|
| 145 | def test_term_mapping
|
---|
| 146 | assert_equal '=', @term_mapping.match
|
---|
[216] | 147 | assert OpenEHR::RM::DataTypes::Text::TermMapping.is_valid_mach_code?('>')
|
---|
| 148 | assert OpenEHR::RM::DataTypes::Text::TermMapping.is_valid_mach_code?('=')
|
---|
| 149 | assert OpenEHR::RM::DataTypes::Text::TermMapping.is_valid_mach_code?('<')
|
---|
| 150 | assert OpenEHR::RM::DataTypes::Text::TermMapping.is_valid_mach_code?('?')
|
---|
| 151 | assert !OpenEHR::RM::DataTypes::Text::TermMapping.is_valid_mach_code?('!')
|
---|
[191] | 152 | assert_equal @dv_coded_text, @term_mapping.purpose
|
---|
| 153 | assert_equal "TEST", @term_mapping.target
|
---|
[216] | 154 | assert_raise(ArgumentError){OpenEHR::RM::DataTypes::Text::TermMapping.new}
|
---|
| 155 | assert_raise(ArgumentError){OpenEHR::RM::DataTypes::Text::TermMapping.new('!',@dv_coded_text, "invalid case")}
|
---|
| 156 | assert_raise(ArgumentError){OpenEHR::RM::DataTypes::Text::TermMapping.new('=',nil , "invalid case")}
|
---|
| 157 | assert_raise(ArgumentError){OpenEHR::RM::DataTypes::Text::TermMapping.new('=',@dv_coded_text, nil)}
|
---|
[191] | 158 | end
|
---|
| 159 | end
|
---|
| 160 |
|
---|
| 161 | class QuantityTest < Test::Unit::TestCase
|
---|
| 162 | def setup
|
---|
| 163 | assert_nothing_raised(Exception){
|
---|
[216] | 164 | @dv_ordered = OpenEHR::RM::DataTypes::Quantity::DvOrdered.new }
|
---|
[191] | 165 | assert_nothing_raised(Exception){
|
---|
[216] | 166 | terminology = OpenEHR::RM::Support::Identification::TerminologyId.new('urine')
|
---|
| 167 | code_phrase = OpenEHR::RM::DataTypes::Text::CodePhrase.new('protein',terminology)
|
---|
| 168 | urinary_protein = OpenEHR::RM::DataTypes::Text::DvCodedText.new('+', code_phrase)
|
---|
| 169 | @dv_ordinal1 = OpenEHR::RM::DataTypes::Quantity::DvOrdinal.new(1, urinary_protein)
|
---|
| 170 | code_phrase = OpenEHR::RM::DataTypes::Text::CodePhrase.new('protein',terminology)
|
---|
| 171 | urinary_protein = OpenEHR::RM::DataTypes::Text::DvCodedText.new('+++', code_phrase)
|
---|
| 172 | @dv_ordinal2 = OpenEHR::RM::DataTypes::Quantity::DvOrdinal.new(3, urinary_protein)}
|
---|
[191] | 173 | assert_nothing_raised(Exception){
|
---|
[216] | 174 | @dv_interval = OpenEHR::RM::DataTypes::Quantity::DvInterval.new(@dv_ordinal1, @dv_ordinal2)}
|
---|
| 175 | meaning = OpenEHR::RM::DataTypes::Text::DvText.new('normal')
|
---|
[191] | 176 | assert_nothing_raised(Exception){
|
---|
[216] | 177 | @reference_range = OpenEHR::RM::DataTypes::Quantity::ReferenceRange.new(meaning, @dv_interval)}
|
---|
[191] | 178 | assert_nothing_raised(Exception){
|
---|
[216] | 179 | @dv_quantified = OpenEHR::RM::DataTypes::Quantity::DvQuantified.new(1,'=')}
|
---|
[191] | 180 | assert_nothing_raised(Exception){
|
---|
[216] | 181 | @dv_amount = OpenEHR::RM::DataTypes::Quantity::DvAmount.new(2,'<')}
|
---|
[191] | 182 | assert_nothing_raised(Exception){
|
---|
[216] | 183 | @dv_quantity = OpenEHR::RM::DataTypes::Quantity::DvQuantity.new(3, 'mg', '~')}
|
---|
[191] | 184 | assert_nothing_raised(Exception){
|
---|
[216] | 185 | @dv_count = OpenEHR::RM::DataTypes::Quantity::DvCount.new(1)}
|
---|
[191] | 186 | assert_nothing_raised(Exception){
|
---|
[216] | 187 | @dv_proportion = OpenEHR::RM::DataTypes::Quantity::DvProportion.new(2,3,0)}
|
---|
[191] | 188 | assert_nothing_raised(Exception){
|
---|
[216] | 189 | @dv_absolute_quantity = OpenEHR::RM::DataTypes::Quantity::DvAbsoluteQuantity.new(7,'=')}
|
---|
[191] | 190 | end
|
---|
| 191 |
|
---|
| 192 | def test_init
|
---|
[216] | 193 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::DvOrdered, @dv_ordered
|
---|
| 194 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::DvQuantified, @dv_quantified
|
---|
| 195 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::DvInterval, @dv_interval
|
---|
| 196 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::ReferenceRange, @reference_range
|
---|
| 197 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::DvOrdinal, @dv_ordinal1
|
---|
| 198 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::DvOrdinal, @dv_ordinal2
|
---|
| 199 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::DvQuantified, @dv_quantified
|
---|
| 200 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::DvAmount, @dv_amount
|
---|
| 201 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::DvQuantity, @dv_quantity
|
---|
| 202 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::DvCount, @dv_count
|
---|
| 203 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::DvProportion, @dv_proportion
|
---|
| 204 | assert_instance_of OpenEHR::RM::DataTypes::Quantity::DvAbsoluteQuantity, @dv_absolute_quantity
|
---|
[191] | 205 | end
|
---|
| 206 |
|
---|
| 207 | def test_dv_ordered
|
---|
| 208 | assert !@dv_ordered.is_normal?
|
---|
| 209 | assert_nil @dv_ordered.normal_status
|
---|
| 210 | assert_nil @dv_ordered.normal_range
|
---|
| 211 | assert_nil @dv_ordered.other_refference_ranges
|
---|
| 212 | assert @dv_ordered.is_simple?
|
---|
| 213 | assert_raise(NotImplementedError){@dv_ordered<=>1}
|
---|
[216] | 214 | openehr_terminology_id = OpenEHR::RM::Support::Identification::TerminologyId.new('openEHR')
|
---|
| 215 | normal_code = OpenEHR::RM::DataTypes::Text::CodePhrase.new('N', openehr_terminology_id)
|
---|
[191] | 216 | assert_equal 'N', normal_code.code_string
|
---|
| 217 | assert_nothing_raised(Exception){
|
---|
| 218 | @dv_ordered.normal_status = normal_code }
|
---|
| 219 | assert @dv_ordered.is_normal?
|
---|
[216] | 220 | other = OpenEHR::RM::DataTypes::Quantity::DvOrdered.new
|
---|
[191] | 221 | assert_raise(NotImplementedError){
|
---|
| 222 | @dv_ordered.is_strictly_comparable_to?(other)}
|
---|
| 223 | end
|
---|
| 224 |
|
---|
| 225 | def test_dv_interval
|
---|
| 226 | assert @dv_interval.lower < @dv_interval.upper
|
---|
| 227 | end
|
---|
| 228 |
|
---|
| 229 | def test_reference_range
|
---|
| 230 | assert_equal 'normal', @reference_range.meaning.value
|
---|
| 231 | assert_equal 1, @reference_range.range.lower.value
|
---|
[216] | 232 | terminology = OpenEHR::RM::Support::Identification::TerminologyId.new('urine')
|
---|
| 233 | code_phrase = OpenEHR::RM::DataTypes::Text::CodePhrase.new('protein',terminology)
|
---|
| 234 | urinary_protein = OpenEHR::RM::DataTypes::Text::DvCodedText.new('++', code_phrase)
|
---|
| 235 | dv_ordinal = OpenEHR::RM::DataTypes::Quantity::DvOrdinal.new(2, urinary_protein)
|
---|
[191] | 236 | assert @reference_range.is_in_range?(dv_ordinal)
|
---|
| 237 | dv_ordinal.value = 6
|
---|
| 238 | assert !@reference_range.is_in_range?(dv_ordinal)
|
---|
| 239 | end
|
---|
| 240 |
|
---|
| 241 | def test_dv_quantified
|
---|
| 242 | assert_equal 1, @dv_quantified.magnitude
|
---|
| 243 | assert_equal '=', @dv_quantified.magnitude_status
|
---|
[216] | 244 | assert !OpenEHR::RM::DataTypes::Quantity::DvQuantified.valid_magnitude_status?('*')
|
---|
| 245 | assert OpenEHR::RM::DataTypes::Quantity::DvQuantified.valid_magnitude_status?('>')
|
---|
| 246 | assert OpenEHR::RM::DataTypes::Quantity::DvQuantified.valid_magnitude_status?('<')
|
---|
| 247 | assert OpenEHR::RM::DataTypes::Quantity::DvQuantified.valid_magnitude_status?('>=')
|
---|
| 248 | assert OpenEHR::RM::DataTypes::Quantity::DvQuantified.valid_magnitude_status?('<=')
|
---|
| 249 | assert OpenEHR::RM::DataTypes::Quantity::DvQuantified.valid_magnitude_status?('~')
|
---|
[191] | 250 | assert_nothing_raised(Exception){@dv_quantified.magnitude = 0}
|
---|
| 251 | assert_equal 0, @dv_quantified.magnitude
|
---|
| 252 | assert_nothing_raised(Exception){@dv_quantified.magnitude_status = nil}
|
---|
| 253 | assert_equal '=', @dv_quantified.magnitude_status
|
---|
| 254 | end
|
---|
| 255 |
|
---|
| 256 | def test_dv_absolute_quantity
|
---|
| 257 | assert_equal 7, @dv_absolute_quantity.magnitude
|
---|
| 258 | assert @dv_absolute_quantity.accuracy_unknown?
|
---|
| 259 | assert_nothing_raised(Exception){@dv_absolute_quantity.accuracy = 0.5}
|
---|
| 260 | assert_equal 0.5, @dv_absolute_quantity.accuracy
|
---|
| 261 | assert !@dv_absolute_quantity.accuracy_unknown?
|
---|
| 262 | end
|
---|
| 263 |
|
---|
| 264 | def test_dv_amount
|
---|
| 265 | assert_equal 2, @dv_amount.magnitude
|
---|
| 266 | assert_equal '<', @dv_amount.magnitude_status
|
---|
| 267 | assert @dv_amount.accuracy_unknown?
|
---|
| 268 | assert_nothing_raised(Exception){@dv_amount.set_accuracy(50,true)}
|
---|
| 269 | assert_equal 50, @dv_amount.accuracy
|
---|
| 270 | assert @dv_amount.accuracy_is_percent?
|
---|
| 271 | assert_nothing_raised(Exception){@dv_amount.set_accuracy(0.3, false)}
|
---|
| 272 | assert_equal 0.3, @dv_amount.accuracy
|
---|
| 273 | assert !@dv_amount.accuracy_is_percent?
|
---|
| 274 | assert !@dv_amount.accuracy_unknown?
|
---|
| 275 | end
|
---|
| 276 |
|
---|
| 277 | def test_dv_ordinal
|
---|
| 278 | assert_equal 1, @dv_ordinal1.value
|
---|
| 279 | assert_equal '+', @dv_ordinal1.symbol.value
|
---|
| 280 | assert_raise(ArgumentError){@dv_ordinal1.symbol = nil}
|
---|
| 281 | assert_raise(ArgumentError){@dv_ordinal1.value = nil}
|
---|
| 282 | assert @dv_ordinal1.is_strictly_comparable_to?(@dv_ordinal2)
|
---|
| 283 | assert @dv_ordinal1 < @dv_ordinal2
|
---|
| 284 | assert @dv_ordinal2 > @dv_ordinal1
|
---|
| 285 | @dv_ordinal1.value = 4
|
---|
| 286 | assert 4, @dv_ordinal1.value
|
---|
| 287 | assert @dv_ordinal1 > @dv_ordinal2
|
---|
| 288 | assert_raise(ArgumentError){@dv_ordinal1.limits = @reference_range}
|
---|
[216] | 289 | meaning = OpenEHR::RM::DataTypes::Text::DvText.new('limits')
|
---|
| 290 | limit_reference_range = OpenEHR::RM::DataTypes::Quantity::ReferenceRange.new(meaning, @dv_interval)
|
---|
[191] | 291 | assert_nothing_raised(Exception){@dv_ordinal1.limits = limit_reference_range}
|
---|
| 292 | assert_equal 'limits', @dv_ordinal1.limits.meaning.value
|
---|
| 293 | end
|
---|
| 294 |
|
---|
| 295 | def test_dv_quantity
|
---|
| 296 | assert_equal 3, @dv_quantity.magnitude
|
---|
| 297 | assert_equal 'mg', @dv_quantity.units
|
---|
| 298 | assert_equal '~', @dv_quantity.magnitude_status
|
---|
[216] | 299 | dv_quantity2 = OpenEHR::RM::DataTypes::Quantity::DvQuantity.new(4, 'mg', '~')
|
---|
[191] | 300 | assert_equal 'mg', dv_quantity2.units
|
---|
| 301 | assert @dv_quantity.is_strictly_comparable_to?(dv_quantity2)
|
---|
| 302 | assert_nothing_raised(Exception){@dv_quantity.precision = -1}
|
---|
| 303 | assert_equal(-1, @dv_quantity.precision)
|
---|
| 304 | assert !@dv_quantity.is_integral?
|
---|
| 305 | assert_raise(ArgumentError){@dv_quantity.precision = -1.1}
|
---|
| 306 | @dv_quantity.precision = 0
|
---|
| 307 | assert @dv_quantity.is_integral?
|
---|
| 308 | dv_quantity3 = @dv_quantity + dv_quantity2
|
---|
| 309 | assert_equal 7, dv_quantity3.magnitude
|
---|
| 310 | assert_equal 'mg', dv_quantity3.units
|
---|
| 311 | dv_quantity3 = @dv_quantity - dv_quantity2
|
---|
| 312 | assert_equal(-1, dv_quantity3.magnitude)
|
---|
| 313 | assert_equal 'mg', dv_quantity3.units
|
---|
| 314 | end
|
---|
| 315 |
|
---|
| 316 | def test_dv_count
|
---|
| 317 | assert_equal 1, @dv_count.magnitude
|
---|
[216] | 318 | dv_count2 = OpenEHR::RM::DataTypes::Quantity::DvCount.new(2)
|
---|
[191] | 319 | dv_count3 = @dv_count + dv_count2
|
---|
| 320 | assert 3, dv_count3.magnitude
|
---|
| 321 | dv_count3 = dv_count2 - @dv_count
|
---|
| 322 | assert 1, dv_count3.magnitude
|
---|
| 323 | end
|
---|
| 324 |
|
---|
| 325 | def test_proportion_kind
|
---|
[216] | 326 | assert_equal 0, OpenEHR::RM::DataTypes::Quantity::ProportionKind::PK_RATIO
|
---|
| 327 | assert_equal 1, OpenEHR::RM::DataTypes::Quantity::ProportionKind::PK_UNITARY
|
---|
| 328 | assert_equal 2, OpenEHR::RM::DataTypes::Quantity::ProportionKind::PK_PERCENT
|
---|
| 329 | assert_equal 3, OpenEHR::RM::DataTypes::Quantity::ProportionKind::PK_FRACTION
|
---|
| 330 | assert_equal 4, OpenEHR::RM::DataTypes::Quantity::ProportionKind::PK_INTEGER_FRACTION
|
---|
| 331 | assert OpenEHR::RM::DataTypes::Quantity::ProportionKind.valid_proportion_kind?(0)
|
---|
| 332 | assert OpenEHR::RM::DataTypes::Quantity::ProportionKind.valid_proportion_kind?(4)
|
---|
| 333 | assert !OpenEHR::RM::DataTypes::Quantity::ProportionKind.valid_proportion_kind?(-1)
|
---|
| 334 | assert !OpenEHR::RM::DataTypes::Quantity::ProportionKind.valid_proportion_kind?(5)
|
---|
[191] | 335 | end
|
---|
| 336 |
|
---|
| 337 | def test_dv_proportion
|
---|
| 338 | assert_equal 2.0, @dv_proportion.numerator
|
---|
| 339 | assert_equal 3.0, @dv_proportion.denominator
|
---|
| 340 | assert_equal 0, @dv_proportion.type
|
---|
| 341 | assert_equal 2.0/3.0, @dv_proportion.magnitude
|
---|
| 342 | assert @dv_proportion.is_integral?
|
---|
[216] | 343 | dv_proportion2 = OpenEHR::RM::DataTypes::Quantity::DvProportion.new(1,3,0)
|
---|
[191] | 344 | assert @dv_proportion.is_strictly_comparable_to?(dv_proportion2)
|
---|
[216] | 345 | dv_proportion2 = OpenEHR::RM::DataTypes::Quantity::DvProportion.new(1,3,4)
|
---|
[191] | 346 | assert !@dv_proportion.is_strictly_comparable_to?(dv_proportion2)
|
---|
| 347 | assert_raise(ArgumentError){
|
---|
[216] | 348 | dv_proportion2 = OpenEHR::RM::DataTypes::Quantity::DvProportion.new(1.5,2.3,3)}
|
---|
[191] | 349 | assert_raise(ArgumentError){
|
---|
[216] | 350 | dv_proportion2 = OpenEHR::RM::DataTypes::Quantity::DvProportion.new(10,10,1)}
|
---|
[191] | 351 | assert_nothing_raised(Exception){
|
---|
[216] | 352 | dv_proportion2 = OpenEHR::RM::DataTypes::Quantity::DvProportion.new(10,1,1)}
|
---|
[191] | 353 | assert_raise(ArgumentError){
|
---|
[216] | 354 | dv_proportion2 = OpenEHR::RM::DataTypes::Quantity::DvProportion.new(10,10,2)}
|
---|
[191] | 355 | assert_nothing_raised(Exception){
|
---|
[216] | 356 | dv_proportion2 = OpenEHR::RM::DataTypes::Quantity::DvProportion.new(10,100,2)}
|
---|
[191] | 357 | end
|
---|
| 358 |
|
---|
| 359 | end
|
---|
| 360 |
|
---|
| 361 | class EncapsulatedTest < Test::Unit::TestCase
|
---|
| 362 | def setup
|
---|
[216] | 363 | charset = OpenEHR::RM::DataTypes::Text::CodePhrase.new('UTF-8','character-sets')
|
---|
| 364 | language = OpenEHR::RM::DataTypes::Text::CodePhrase.new('ja', 'languages')
|
---|
[191] | 365 | assert_nothing_raised(Exception){
|
---|
[216] | 366 | @dv_encapsulated = OpenEHR::RM::DataTypes::Encapsulated::DvEncapsulated.new(charset, language, 10)}
|
---|
[191] | 367 | assert_nothing_raised(Exception){
|
---|
[216] | 368 | @dv_parsable = OpenEHR::RM::DataTypes::Encapsulated::DvParsable.new(charset, language, 10, 'XML','<TEST>test</TEST>')}
|
---|
| 369 | media_type = OpenEHR::RM::DataTypes::Text::CodePhrase.new('text/html', 'media-types')
|
---|
| 370 | uri = OpenEHR::RM::DataTypes::Uri::DvUri.new("http://www.openehr.jp/changeset/test?cmd=93#file0")
|
---|
[191] | 371 | assert_nothing_raised(Exception){
|
---|
[216] | 372 | @dv_multimedia = OpenEHR::RM::DataTypes::Encapsulated::DvMultimedia.new(charset, language, 10, media_type, uri)}
|
---|
[191] | 373 | end
|
---|
| 374 |
|
---|
| 375 | def test_init
|
---|
[216] | 376 | assert_instance_of OpenEHR::RM::DataTypes::Encapsulated::DvEncapsulated, @dv_encapsulated
|
---|
| 377 | assert_instance_of OpenEHR::RM::DataTypes::Encapsulated::DvParsable, @dv_parsable
|
---|
| 378 | assert_instance_of OpenEHR::RM::DataTypes::Encapsulated::DvMultimedia, @dv_multimedia
|
---|
[191] | 379 | end
|
---|
| 380 |
|
---|
| 381 | def test_dv_encapsulated
|
---|
| 382 | assert_equal 'UTF-8', @dv_encapsulated.charset.code_string
|
---|
| 383 | assert_equal 'ja', @dv_encapsulated.language.code_string
|
---|
| 384 | assert_equal 10, @dv_encapsulated.size
|
---|
[216] | 385 | wrong_charset = OpenEHR::RM::DataTypes::Text::CodePhrase.new('USO8000', 'character-sets')
|
---|
[191] | 386 | assert_raise(ArgumentError){@dv_encapsulated.charset = wrong_charset}
|
---|
[216] | 387 | charset = OpenEHR::RM::DataTypes::Text::CodePhrase.new('EUC-JP', 'character-sets')
|
---|
[191] | 388 | assert_nothing_raised(Exception){@dv_encapsulated.charset = charset}
|
---|
| 389 | assert_equal 'EUC-JP', @dv_encapsulated.charset.code_string
|
---|
[216] | 390 | wrong_language = OpenEHR::RM::DataTypes::Text::CodePhrase.new('jpg', 'language')
|
---|
[191] | 391 | assert_raise(ArgumentError){@dv_encapsulated.language = wrong_language}
|
---|
[216] | 392 | language = OpenEHR::RM::DataTypes::Text::CodePhrase.new('eng', 'language')
|
---|
[191] | 393 | assert_nothing_raised(Exception){@dv_encapsulated.language = language}
|
---|
| 394 | assert_equal 'eng', @dv_encapsulated.language.code_string
|
---|
| 395 | assert_raise(ArgumentError){@dv_encapsulated.size = -1}
|
---|
| 396 | assert_nothing_raised(Exception){@dv_encapsulated.size = 0}
|
---|
| 397 | assert_equal 0, @dv_encapsulated.size
|
---|
| 398 | end
|
---|
| 399 |
|
---|
| 400 | def test_dv_parsable
|
---|
| 401 | assert_equal 'UTF-8', @dv_parsable.charset.code_string
|
---|
| 402 | assert_equal 'ja', @dv_parsable.language.code_string
|
---|
| 403 | assert_equal 10, @dv_parsable.size
|
---|
| 404 | assert_equal 'XML', @dv_parsable.formalism
|
---|
| 405 | assert_equal '<TEST>test</TEST>', @dv_parsable.value
|
---|
| 406 | assert_raise(ArgumentError){
|
---|
| 407 | @dv_parsable.formalism = nil }
|
---|
| 408 | assert_nothing_raised(Exception){
|
---|
| 409 | @dv_parsable.formalism = 'HTML' }
|
---|
| 410 | assert_equal 'HTML', @dv_parsable.formalism
|
---|
| 411 | assert_raise(ArgumentError){
|
---|
| 412 | @dv_parsable.value = nil }
|
---|
| 413 | assert_nothing_raised(Exception){
|
---|
| 414 | @dv_parsable.value = '<H1>test</H1>' }
|
---|
| 415 | assert_equal '<H1>test</H1>', @dv_parsable.value
|
---|
| 416 | end
|
---|
| 417 |
|
---|
| 418 | def test_dv_multimedia
|
---|
| 419 | assert_equal 'UTF-8', @dv_multimedia.charset.code_string
|
---|
| 420 | assert_equal 'ja', @dv_multimedia.language.code_string
|
---|
| 421 | assert_equal 10, @dv_multimedia.size
|
---|
| 422 | assert_equal 'text/html', @dv_multimedia.media_type.code_string
|
---|
| 423 | assert_equal 'http://www.openehr.jp/changeset/test?cmd=93#file0', @dv_multimedia.uri.value
|
---|
| 424 | end
|
---|
| 425 | end
|
---|
| 426 |
|
---|
| 427 |
|
---|
| 428 | class TestDvTimeSpecification < Test::Unit::TestCase
|
---|
| 429 | def setup
|
---|
[216] | 430 | charset = OpenEHR::RM::DataTypes::Text::CodePhrase.new('UTF-8','character-sets')
|
---|
| 431 | language = OpenEHR::RM::DataTypes::Text::CodePhrase.new('ja', 'languages')
|
---|
[191] | 432 | assert_nothing_raised(Exception){
|
---|
[216] | 433 | dv_parsable = OpenEHR::RM::DataTypes::Encapsulated::DvParsable.new(charset, language, 10, 'XML','<TEST>test</TEST>')
|
---|
| 434 | @dv_time_specification = OpenEHR::RM::DataTypes::TimeSpecification::DvTimeSpecification.new(dv_parsable)}
|
---|
[191] | 435 | # assert_nothing_raised(Exception){
|
---|
| 436 | # @dv_periodic_time_specification = DV_Periodic_Time_Specification.new('[200004181100;200004181110]/(7d)@DWIST', charset, language, 10, 'HL7:PIVL')}
|
---|
| 437 | end
|
---|
| 438 |
|
---|
| 439 | def test_init
|
---|
[216] | 440 | assert_instance_of OpenEHR::RM::DataTypes::TimeSpecification::DvTimeSpecification, @dv_time_specification
|
---|
[191] | 441 | end
|
---|
| 442 |
|
---|
| 443 | def test_dv_time_specification
|
---|
| 444 | assert_equal '<TEST>test</TEST>', @dv_time_specification.value.value
|
---|
| 445 | end
|
---|
| 446 | end
|
---|