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