/usr/lib/python2.7/dist-packages/dicom/test/test_filewriter.py is in python-dicom 0.9.7-1.1ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 | # test_filewriter.py
"""unittest cases for dicom.filewriter module"""
# Copyright (c) 2008-2012 Darcy Mason
# This file is part of pydicom, released under a modified MIT license.
# See the file license.txt included with this distribution, also
# available at http://pydicom.googlecode.com
import sys
import os.path
import os
import unittest
from dicom.filereader import read_file
from dicom.filewriter import write_data_element
from dicom.tag import Tag
from dicom.dataset import Dataset, FileDataset
from dicom.sequence import Sequence
from dicom.util.hexutil import hex2bytes, bytes2hex
# from cStringIO import StringIO
from dicom.filebase import DicomStringIO
from dicom.dataelem import DataElement
from dicom.util.hexutil import hex2bytes, bytes2hex
from pkg_resources import Requirement, resource_filename
test_dir = resource_filename(Requirement.parse("pydicom"),"dicom/testfiles")
rtplan_name = os.path.join(test_dir, "rtplan.dcm")
rtdose_name = os.path.join(test_dir, "rtdose.dcm")
ct_name = os.path.join(test_dir, "CT_small.dcm")
mr_name = os.path.join(test_dir, "MR_small.dcm")
jpeg_name = os.path.join(test_dir, "JPEG2000.dcm")
# Set up rtplan_out, rtdose_out etc. Filenames as above, with '2' appended
for inname in ['rtplan', 'rtdose', 'ct', 'mr', 'jpeg']:
exec(inname + "_out = " + inname + "_name + '2'")
def files_identical(a, b):
"""Return a tuple (file a == file b, index of first difference)"""
a_bytes = file(a, "rb").read()
b_bytes = file(b, "rb").read()
return bytes_identical(a_bytes, b_bytes)
def bytes_identical(a_bytes, b_bytes):
"""Return a tuple (bytes a == bytes b, index of first difference)"""
if a_bytes == b_bytes:
return True, 0 # True, dummy argument
else:
pos = 0
while a_bytes[pos] == b_bytes[pos]:
pos += 1
return False, pos # False (not identical files), position of first difference
class WriteFileTests(unittest.TestCase):
def compare(self, in_filename, out_filename):
"""Read file1, write file2, then compare. Return value as for files_identical"""
dataset = read_file(in_filename)
dataset.save_as(out_filename)
same, pos = files_identical(in_filename, out_filename)
self.assert_(same, "Files are not identical - first difference at 0x%x" % pos)
if os.path.exists(out_filename):
os.remove(out_filename) # get rid of the file
def testRTPlan(self):
"""Input file, write back and verify them identical (RT Plan file)"""
self.compare(rtplan_name, rtplan_out)
def testRTDose(self):
"""Input file, write back and verify them identical (RT Dose file)"""
self.compare(rtdose_name, rtdose_out)
def testCT(self):
"""Input file, write back and verify them identical (CT file)....."""
self.compare(ct_name, ct_out)
def testMR(self):
"""Input file, write back and verify them identical (MR file)....."""
self.compare(mr_name, mr_out)
def testJPEG2000(self):
"""Input file, write back and verify them identical (JPEG2K file)."""
self.compare(jpeg_name, jpeg_out)
def testListItemWriteBack(self):
"""Change item in a list and confirm it is written to file .."""
DS_expected = 0
CS_expected = "new"
SS_expected = 999
ds = read_file(ct_name)
ds.ImagePositionPatient[2] = DS_expected
ds.ImageType[1] = CS_expected
ds[(0x0043, 0x1012)].value[0] = SS_expected
ds.save_as(ct_out)
# Now read it back in and check that the values were changed
ds = read_file(ct_out)
self.assert_(ds.ImageType[1] == CS_expected, "Item in a list not written correctly to file (VR=CS)")
self.assert_(ds[0x00431012].value[0] == SS_expected, "Item in a list not written correctly to file (VR=SS)")
self.assert_(ds.ImagePositionPatient[2] == DS_expected, "Item in a list not written correctly to file (VR=DS)")
if os.path.exists(ct_out):
os.remove(ct_out)
class WriteDataElementTests(unittest.TestCase):
"""Attempt to write data elements has the expected behaviour"""
def setUp(self):
# Create a dummy (in memory) file to write to
self.f1 = DicomStringIO()
self.f1.is_little_endian = True
self.f1.is_implicit_VR = True
def test_empty_AT(self):
"""Write empty AT correctly.........."""
# Was issue 74
data_elem = DataElement(0x00280009, "AT", [])
expected = hex2bytes((
" 28 00 09 00" # (0028,0009) Frame Increment Pointer
" 00 00 00 00" # length 0
))
write_data_element(self.f1, data_elem)
got = self.f1.parent.getvalue()
msg = ("Did not write zero-length AT value correctly. "
"Expected %r, got %r") % (bytes2hex(expected), bytes2hex(got))
msg = "%r %r" % (type(expected), type(got))
msg = "'%r' '%r'" % (expected, got)
self.assertEqual(expected, got, msg)
class ScratchWriteTests(unittest.TestCase):
"""Simple dataset from scratch, written in all endian/VR combinations"""
def setUp(self):
# Create simple dataset for all tests
ds = Dataset()
ds.PatientName = "Name^Patient"
# Set up a simple nested sequence
# first, the innermost sequence
subitem1 = Dataset()
subitem1.ContourNumber = 1
subitem1.ContourData = ['2','4','8','16']
subitem2 = Dataset()
subitem2.ContourNumber = 2
subitem2.ContourData = ['32','64','128','196']
sub_ds = Dataset()
sub_ds.ContourSequence = Sequence((subitem1, subitem2)) # XXX in 0.9.5 will need sub_ds.ContourSequence
# Now the top-level sequence
ds.ROIContourSequence = Sequence((sub_ds,)) # Comma necessary to make it a one-tuple
# Store so each test can use it
self.ds = ds
def compare_write(self, hex_std, file_ds):
"""Write file and compare with expected byte string
:arg hex_std: the bytes which should be written, as space separated hex
:arg file_ds: a FileDataset instance containing the dataset to write
"""
out_filename = "scratch.dcm"
file_ds.save_as(out_filename)
std = hex2bytes(hex_std)
bytes_written = open(out_filename,'rb').read()
# print "std :", bytes2hex(std)
# print "written:", bytes2hex(bytes_written)
same, pos = bytes_identical(std, bytes_written)
self.assert_(same, "Writing from scratch not expected result - first difference at 0x%x" % pos)
if os.path.exists(out_filename):
os.remove(out_filename) # get rid of the file
def testImpl_LE_deflen_write(self):
"""Scratch Write for implicit VR little endian, defined length SQ's"""
from dicom.test._write_stds import impl_LE_deflen_std_hex as std
file_ds = FileDataset("test", self.ds)
self.compare_write(std, file_ds)
if __name__ == "__main__":
# This is called if run alone, but not if loaded through run_tests.py
# If not run from the directory where the sample images are, then need to switch there
dir_name = os.path.dirname(sys.argv[0])
save_dir = os.getcwd()
if dir_name:
os.chdir(dir_name)
os.chdir("../testfiles")
unittest.main()
os.chdir(save_dir)
|